RPC 0.6.0 cleanup

lib/src/main/kotlin/com/swmansion/starknet/account/StandardAccount.kt

@@ -33,9 +33,6 @@ class StandardAccount(
             .add(version.value)
             .toFelt
     }
-    private val defaultFeeEstimateSimulationFlags: Set<SimulationFlagForEstimateFee> by lazy {
-        setOf(SimulationFlagForEstimateFee.SKIP_VALIDATE)
-    }
 
     /**
      * @param provider a provider used to interact with Starknet
@@ -49,7 +46,7 @@ class StandardAccount(
         cairoVersion,
     )
 
-    override fun sign(calls: List<Call>, params: ExecutionParams, forFeeEstimate: Boolean): InvokeTransactionV1Payload {
+    override fun signV1(calls: List<Call>, params: ExecutionParams, forFeeEstimate: Boolean): InvokeTransactionV1Payload {
         val calldata = AccountCalldataTransformer.callsToExecuteCalldata(calls, cairoVersion)
         val signVersion = when (forFeeEstimate) {
             true -> estimateVersion(Felt.ONE)
@@ -69,7 +66,7 @@ class StandardAccount(
         return signedTransaction.toPayload()
     }
 
-    override fun sign(calls: List<Call>, params: ExecutionParamsV3, forFeeEstimate: Boolean): InvokeTransactionV3Payload {
+    override fun signV3(calls: List<Call>, params: InvokeParamsV3, forFeeEstimate: Boolean): InvokeTransactionV3Payload {
         val calldata = AccountCalldataTransformer.callsToExecuteCalldata(calls, cairoVersion)
         val signVersion = when (forFeeEstimate) {
             true -> estimateVersion(Felt(3))
@@ -82,19 +79,14 @@ class StandardAccount(
             nonce = params.nonce,
             version = signVersion,
             resourceBounds = params.resourceBounds,
-            tip = params.tip,
-            paymasterData = params.paymasterData,
-            accountDeploymentData = params.accountDeploymentData,
-            nonceDataAvailabilityMode = params.nonceDataAvailabilityMode,
-            feeDataAvailabilityMode = params.feeDataAvailabilityMode,
         )
 
         val signedTransaction = tx.copy(signature = signer.signTransaction(tx))
 
         return signedTransaction.toPayload()
     }
 
-    override fun signDeployAccount(
+    override fun signDeployAccountV1(
         classHash: Felt,
         calldata: Calldata,
         salt: Felt,
@@ -121,7 +113,7 @@ class StandardAccount(
         return signedTransaction.toPayload()
     }
 
-    override fun signDeployAccount(
+    override fun signDeployAccountV3(
         classHash: Felt,
         calldata: Calldata,
         salt: Felt,
@@ -141,17 +133,13 @@ class StandardAccount(
             version = signVersion,
             nonce = params.nonce,
             resourceBounds = params.resourceBounds,
-            tip = params.tip,
-            paymasterData = params.paymasterData,
-            nonceDataAvailabilityMode = params.nonceDataAvailabilityMode,
-            feeDataAvailabilityMode = params.feeDataAvailabilityMode,
         )
         val signedTransaction = tx.copy(signature = signer.signTransaction(tx))
 
         return signedTransaction.toPayload()
     }
 
-    override fun signDeclare(
+    override fun signDeclareV1(
         contractDefinition: Cairo0ContractDefinition,
         classHash: Felt,
         params: ExecutionParams,
@@ -175,7 +163,7 @@ class StandardAccount(
         return signedTransaction.toPayload()
     }
 
-    override fun signDeclare(
+    override fun signDeclareV2(
         sierraContractDefinition: Cairo1ContractDefinition,
         casmContractDefinition: CasmContractDefinition,
         params: ExecutionParams,
@@ -199,7 +187,7 @@ class StandardAccount(
         return signedTransaction.toPayload()
     }
 
-    override fun signDeclare(
+    override fun signDeclareV3(
         sierraContractDefinition: Cairo1ContractDefinition,
         casmContractDefinition: CasmContractDefinition,
         params: DeclareParamsV3,
@@ -216,12 +204,7 @@ class StandardAccount(
             nonce = params.nonce,
             version = signVersion,
             resourceBounds = params.resourceBounds,
-            tip = params.tip,
-            paymasterData = params.paymasterData,
-            accountDeploymentData = params.accountDeploymentData,
             casmContractDefinition = casmContractDefinition,
-            nonceDataAvailabilityMode = params.nonceDataAvailabilityMode,
-            feeDataAvailabilityMode = params.feeDataAvailabilityMode,
         )
         val signedTransaction = tx.copy(signature = signer.signTransaction(tx))
 
@@ -277,51 +260,51 @@ class StandardAccount(
         throw e
     }
 
-    override fun execute(calls: List<Call>, maxFee: Felt): Request<InvokeFunctionResponse> {
+    override fun executeV1(calls: List<Call>, maxFee: Felt): Request<InvokeFunctionResponse> {
         return getNonce().compose { nonce ->
             val signParams = ExecutionParams(nonce = nonce, maxFee = maxFee)
-            val payload = sign(calls, signParams)
+            val payload = signV1(calls, signParams)
 
             return@compose provider.invokeFunction(payload)
         }
     }
 
     override fun executeV3(calls: List<Call>, l1ResourceBounds: ResourceBounds): Request<InvokeFunctionResponse> {
         return getNonce().compose { nonce ->
-            val signParams = ExecutionParamsV3(
+            val signParams = InvokeParamsV3(
                 nonce = nonce,
                 l1ResourceBounds = l1ResourceBounds,
             )
-            val payload = sign(calls, signParams, false)
+            val payload = signV3(calls, signParams, false)
 
             return@compose provider.invokeFunction(payload)
         }
     }
 
-    override fun execute(calls: List<Call>): Request<InvokeFunctionResponse> {
-        return estimateFee(calls).compose { estimateFee ->
+    override fun executeV1(calls: List<Call>): Request<InvokeFunctionResponse> {
+        return estimateFeeV1(calls).compose { estimateFee ->
             val maxFee = estimateFee.first().toMaxFee()
-            execute(calls, maxFee)
+            executeV1(calls, maxFee)
         }
     }
 
     override fun executeV3(calls: List<Call>): Request<InvokeFunctionResponse> {
-        return estimateFee(calls).compose { estimateFee ->
+        return estimateFeeV3(calls).compose { estimateFee ->
             val resourceBounds = estimateFee.first().toResourceBounds()
             executeV3(calls, resourceBounds.l1Gas)
         }
     }
 
-    override fun execute(call: Call, maxFee: Felt): Request<InvokeFunctionResponse> {
-        return execute(listOf(call), maxFee)
+    override fun executeV1(call: Call, maxFee: Felt): Request<InvokeFunctionResponse> {
+        return executeV1(listOf(call), maxFee)
     }
 
     override fun executeV3(call: Call, l1ResourceBounds: ResourceBounds): Request<InvokeFunctionResponse> {
         return executeV3(listOf(call), l1ResourceBounds)
     }
 
-    override fun execute(call: Call): Request<InvokeFunctionResponse> {
-        return execute(listOf(call))
+    override fun executeV1(call: Call): Request<InvokeFunctionResponse> {
+        return executeV1(listOf(call))
     }
 
     override fun executeV3(call: Call): Request<InvokeFunctionResponse> {
@@ -336,72 +319,59 @@ class StandardAccount(
 
     override fun getNonce(blockNumber: Int) = provider.getNonce(address, blockNumber)
 
-    override fun estimateFee(call: Call): Request<List<EstimateFeeResponse>> {
-        return estimateFee(listOf(call))
+    override fun estimateFeeV1(call: Call): Request<List<EstimateFeeResponse>> {
+        return estimateFeeV1(listOf(call))
     }
 
-    override fun estimateFee(call: Call, simulationFlags: Set<SimulationFlagForEstimateFee>): Request<List<EstimateFeeResponse>> {
-        return estimateFee(listOf(call), simulationFlags)
+    override fun estimateFeeV1(call: Call, skipValidate: Boolean): Request<List<EstimateFeeResponse>> {
+        return estimateFeeV1(listOf(call), skipValidate)
     }
 
-    override fun estimateFee(call: Call, blockTag: BlockTag): Request<List<EstimateFeeResponse>> {
-        return estimateFee(listOf(call), blockTag)
+    override fun estimateFeeV1(call: Call, blockTag: BlockTag): Request<List<EstimateFeeResponse>> {
+        return estimateFeeV1(listOf(call), blockTag)
     }
 
-    override fun estimateFee(
+    override fun estimateFeeV1(
         call: Call,
         blockTag: BlockTag,
-        simulationFlags: Set<SimulationFlagForEstimateFee>,
-    ): Request<List<EstimateFeeResponse>> {
-        return estimateFee(listOf(call), blockTag, simulationFlags)
-    }
-
-    override fun estimateFee(calls: List<Call>): Request<List<EstimateFeeResponse>> {
-        return estimateFee(calls, BlockTag.PENDING)
-    }
-
-    override fun estimateFeeV3(calls: List<Call>): Request<List<EstimateFeeResponse>> {
-        return estimateFeeV3(calls, BlockTag.PENDING, defaultFeeEstimateSimulationFlags)
-    }
-
-    override fun estimateFee(
-        calls: List<Call>,
-        simulationFlags: Set<SimulationFlagForEstimateFee>,
+        skipValidate: Boolean,
     ): Request<List<EstimateFeeResponse>> {
-        return estimateFee(calls, BlockTag.PENDING, simulationFlags)
+        return estimateFeeV1(listOf(call), blockTag, skipValidate)
     }
 
-    override fun estimateFeeV3(
-        calls: List<Call>,
-        simulationFlags: Set<SimulationFlagForEstimateFee>,
-    ): Request<List<EstimateFeeResponse>> {
-        return estimateFeeV3(calls, BlockTag.PENDING, simulationFlags)
+    override fun estimateFeeV1(calls: List<Call>): Request<List<EstimateFeeResponse>> {
+        return estimateFeeV1(calls, BlockTag.PENDING, false)
     }
 
-    override fun estimateFeeV3(calls: List<Call>, blockTag: BlockTag): Request<List<EstimateFeeResponse>> {
-        return estimateFeeV3(calls, blockTag)
+    override fun estimateFeeV1(calls: List<Call>, skipValidate: Boolean): Request<List<EstimateFeeResponse>> {
+        return estimateFeeV1(calls, BlockTag.PENDING, skipValidate)
     }
 
-    override fun estimateFee(calls: List<Call>, blockTag: BlockTag): Request<List<EstimateFeeResponse>> {
-        return estimateFee(calls, blockTag, defaultFeeEstimateSimulationFlags)
+    override fun estimateFeeV1(calls: List<Call>, blockTag: BlockTag): Request<List<EstimateFeeResponse>> {
+        return estimateFeeV1(calls, blockTag, false)
     }
 
-    override fun estimateFee(
+    override fun estimateFeeV1(
         calls: List<Call>,
         blockTag: BlockTag,
-        simulationFlags: Set<SimulationFlagForEstimateFee>,
+        skipValidate: Boolean,
     ): Request<List<EstimateFeeResponse>> {
         return getNonce(blockTag).compose { nonce ->
-            val payload = buildEstimateFeePayload(calls, nonce)
+            val simulationFlags = prepareSimulationFlagsForFeeEstimate(skipValidate)
+            val payload = buildEstimateFeeV1Payload(calls, nonce)
             return@compose provider.getEstimateFee(payload, blockTag, simulationFlags)
         }
     }
 
+    override fun estimateFeeV3(call: Call): Request<List<EstimateFeeResponse>> {
+        return estimateFeeV3(listOf(call))
+    }
+
     override fun estimateFeeV3(
         call: Call,
-        simulationFlags: Set<SimulationFlagForEstimateFee>,
+        skipValidate: Boolean,
     ): Request<List<EstimateFeeResponse>> {
-        return estimateFeeV3(listOf(call), simulationFlags)
+        return estimateFeeV3(listOf(call), skipValidate)
     }
 
     override fun estimateFeeV3(call: Call, blockTag: BlockTag): Request<List<EstimateFeeResponse>> {
@@ -411,25 +381,46 @@ class StandardAccount(
     override fun estimateFeeV3(
         call: Call,
         blockTag: BlockTag,
-        simulationFlags: Set<SimulationFlagForEstimateFee>,
+        skipValidate: Boolean,
     ): Request<List<EstimateFeeResponse>> {
-        return estimateFeeV3(listOf(call), blockTag, simulationFlags)
+        return estimateFeeV3(listOf(call), blockTag, skipValidate)
+    }
+
+    override fun estimateFeeV3(calls: List<Call>): Request<List<EstimateFeeResponse>> {
+        return estimateFeeV3(calls, BlockTag.PENDING, false)
+    }
+
+    override fun estimateFeeV3(calls: List<Call>, skipValidate: Boolean): Request<List<EstimateFeeResponse>> {
+        return estimateFeeV3(calls, BlockTag.PENDING, skipValidate)
+    }
+
+    override fun estimateFeeV3(calls: List<Call>, blockTag: BlockTag): Request<List<EstimateFeeResponse>> {
+        return estimateFeeV3(calls, blockTag, false)
     }
 
     override fun estimateFeeV3(
         calls: List<Call>,
         blockTag: BlockTag,
-        simulationFlags: Set<SimulationFlagForEstimateFee>,
+        skipValidate: Boolean,
     ): Request<List<EstimateFeeResponse>> {
         return getNonce(blockTag).compose { nonce ->
             val payload = buildEstimateFeeV3Payload(calls, nonce)
+            val simulationFlags = prepareSimulationFlagsForFeeEstimate(skipValidate)
             return@compose provider.getEstimateFee(payload, blockTag, simulationFlags)
         }
     }
 
-    private fun buildEstimateFeePayload(calls: List<Call>, nonce: Felt): List<TransactionPayload> {
+    private fun prepareSimulationFlagsForFeeEstimate(skipValidate: Boolean): Set<SimulationFlagForEstimateFee> {
+        return if (skipValidate) {
+            setOf(SimulationFlagForEstimateFee.SKIP_VALIDATE)
+        } else {
+            emptySet()
+        }
+    }
+
+    private fun buildEstimateFeeV1Payload(calls: List<Call>, nonce: Felt): List<TransactionPayload> {
         val executionParams = ExecutionParams(nonce = nonce, maxFee = Felt.ZERO)
-        val payload = sign(calls, executionParams, true)
+        val payload = signV1(calls, executionParams, true)
 
         val signedTransaction = TransactionFactory.makeInvokeV1Transaction(
             senderAddress = payload.senderAddress,
@@ -444,11 +435,11 @@ class StandardAccount(
     }
 
     private fun buildEstimateFeeV3Payload(calls: List<Call>, nonce: Felt): List<TransactionPayload> {
-        val executionParams = ExecutionParamsV3(
+        val executionParams = InvokeParamsV3(
             nonce = nonce,
             l1ResourceBounds = ResourceBounds.ZERO,
         )
-        val payload = sign(calls, executionParams, false)
+        val payload = signV3(calls, executionParams, true)
 
         val signedTransaction = TransactionFactory.makeInvokeV3Transaction(
             senderAddress = payload.senderAddress,
@@ -458,11 +449,6 @@ class StandardAccount(
             signature = payload.signature,
             version = payload.version,
             resourceBounds = payload.resourceBounds,
-            tip = payload.tip,
-            paymasterData = payload.paymasterData,
-            accountDeploymentData = payload.accountDeploymentData,
-            nonceDataAvailabilityMode = payload.nonceDataAvailabilityMode,
-            feeDataAvailabilityMode = payload.feeDataAvailabilityMode,
         )
         return listOf(signedTransaction.toPayload())
     }