simulateTransactions

import com.swmansion.starknet.account.Account
import com.swmansion.starknet.account.StandardAccount
import com.swmansion.starknet.crypto.StarknetCurve
import com.swmansion.starknet.data.ContractAddressCalculator
import com.swmansion.starknet.data.selectorFromName
import com.swmansion.starknet.data.types.*
import com.swmansion.starknet.extensions.toFelt
import com.swmansion.starknet.provider.exceptions.RequestFailedException
import com.swmansion.starknet.provider.exceptions.RpcRequestFailedException
import com.swmansion.starknet.provider.rpc.JsonRpcProvider
import com.swmansion.starknet.service.http.HttpResponse
import com.swmansion.starknet.service.http.HttpService
import com.swmansion.starknet.signer.Signer
import com.swmansion.starknet.signer.StarkCurveSigner
import org.junit.jupiter.api.*
import org.junit.jupiter.api.Assertions.*
import org.junit.jupiter.api.parallel.Execution
import org.junit.jupiter.api.parallel.ExecutionMode
import org.mockito.kotlin.any
import org.mockito.kotlin.doReturn
import org.mockito.kotlin.mock
import starknet.data.loadTypedData
import starknet.utils.DevnetClient
import starknet.utils.ScarbClient
import java.math.BigInteger
import java.nio.file.Path
import java.nio.file.Paths
import java.time.Duration
import java.time.Instant
import kotlin.io.path.readText
fun main() { 
   //sampleStart 
   val account = StandardAccount(accountAddress, signer, provider, chainId)
devnetClient.prefundAccountStrk(accountAddress)

val nonce = account.getNonce().send()
val call = Call(balanceContractAddress, "increase_balance", listOf(Felt(1000)))
val resourceBounds = ResourceBoundsMapping(
    l1Gas = ResourceBounds(
        maxAmount = Uint64(100_000_000_000),
        maxPricePerUnit = Uint128(10_000_000_000_000_000),
    ),
    l2Gas = ResourceBounds(
        maxAmount = Uint64(100_000_000_000_000),
        maxPricePerUnit = Uint128(1_000_000_000_000_000_000),
    ),
    l1DataGas = ResourceBounds(
        maxAmount = Uint64(100_000_000_000),
        maxPricePerUnit = Uint128(10_000_000_000_000_000),
    ),
)
val params = InvokeParamsV3(
    nonce = nonce,
    resourceBounds = resourceBounds,
)

val invokeTx = account.signV3(call, params)

val privateKey = Felt(22222)
val publicKey = StarknetCurve.getPublicKey(privateKey)
val salt = Felt.ONE
val calldata = listOf(publicKey)

val newAccountAddress = ContractAddressCalculator.calculateAddressFromHash(
    classHash = accountContractClassHash,
    calldata = calldata,
    salt = salt,
)
val newAccount = StandardAccount(newAccountAddress, privateKey, provider, chainId)

devnetClient.prefundAccountStrk(newAccountAddress)

val deployAccountTx = newAccount.signDeployAccountV3(
    classHash = accountContractClassHash,
    calldata = calldata,
    salt = salt,
    resourceBounds = resourceBounds,
)

val simulationFlags = setOf<SimulationFlag>()
val simulationResult = provider.simulateTransactions(
    transactions = listOf(invokeTx, deployAccountTx),
    blockTag = BlockTag.PENDING,
    simulationFlags = simulationFlags,
).send()
assertEquals(2, simulationResult.values.size)
assertTrue(simulationResult.values[0].transactionTrace is InvokeTransactionTraceBase)
assertTrue(simulationResult.values[0].transactionTrace is InvokeTransactionTrace)
assertTrue(simulationResult.values[1].transactionTrace is DeployAccountTransactionTrace) 
   //sampleEnd
}