Transactions

Overview

This guide covers transaction operations including sending ETH/SOL, ERC20 tokens, signing transactions, and smart contract interactions with the Dynamic Swift SDK.

Prerequisites

Dynamic SDK initialized (see Installation Guide)
User authenticated (see Authentication Guide)
Wallets available (see Wallet Creation)
Network configured (see Networks)

EVM Transactions

Send ETH Transaction

import DynamicSDKSwift

let sdk = DynamicSDK.instance()

func sendTransaction(wallet: BaseWallet, to: String, amountInWei: Int) async {
    do {
        // Get current gas price
        let chainId = 1 // Ethereum mainnet, or use your target chain
        let client = try await sdk.evm.createPublicClient(chainId: chainId)
        let gasPrice = try await client.getGasPrice()
        
        // Create transaction
        let transaction = EthereumTransaction(
            to: to,
            value: amountInWei,
            gasLimit: 21000,  // Standard ETH transfer
            maxFeePerGas: Int(gasPrice.value * 2),
            maxPriorityFeePerGas: Int(gasPrice.value)
        )
        
        // Send transaction
        let txHash = try await sdk.evm.sendTransaction(
            transaction: transaction,
            wallet: wallet
        )
        
        print("Transaction sent!")
        print("Hash: \(txHash)")
    } catch {
        print("Transaction failed: \(error)")
    }
}

Complete Send Transaction Example

import SwiftUI
import DynamicSDKSwift

struct SendTransactionView: View {
    let wallet: BaseWallet
    
    @State private var recipient = ""
    @State private var amount = ""
    @State private var txHash: String?
    @State private var isLoading = false
    @State private var errorMessage: String?
    
    private let sdk = DynamicSDK.instance()
    
    var body: some View {
        VStack(spacing: 16) {
            TextField("Recipient address", text: $recipient)
                .textFieldStyle(.roundedBorder)
                .autocapitalization(.none)
            
            TextField("Amount (ETH)", text: $amount)
                .textFieldStyle(.roundedBorder)
                .keyboardType(.decimalPad)
            
            Button("Send Transaction") {
                sendTransaction()
            }
            .disabled(recipient.isEmpty || amount.isEmpty || isLoading)
            .buttonStyle(.borderedProminent)
            
            if isLoading {
                ProgressView("Sending...")
            }
            
            if let hash = txHash {
                VStack(alignment: .leading, spacing: 8) {
                    Text("Transaction Sent!")
                        .font(.headline)
                        .foregroundColor(.green)
                    
                    Text("Hash: \(hash)")
                        .font(.system(.caption, design: .monospaced))
                        .lineLimit(2)
                    
                    Button("Copy Hash") {
                        UIPasteboard.general.string = hash
                    }
                    .font(.caption)
                }
                .padding()
                .background(Color.green.opacity(0.1))
                .cornerRadius(8)
            }
            
            if let error = errorMessage {
                Text(error)
                    .foregroundColor(.red)
                    .font(.caption)
            }
        }
        .padding()
    }
    
    private func sendTransaction() {
        guard let amountDouble = Double(amount) else {
            errorMessage = "Invalid amount"
            return
        }
        
        isLoading = true
        errorMessage = nil
        txHash = nil
        
        Task { @MainActor in
            do {
                // Convert ETH to Wei (1 ETH = 10^18 Wei)
                let amountInWei = Int(amountDouble * pow(10, 18))
                
                // Get gas price
                let chainId = 84532 // Base Sepolia - adjust as needed
                let client = try await sdk.evm.createPublicClient(chainId: chainId)
                let gasPrice = try await client.getGasPrice()
                
                // Create and send transaction
                let transaction = EthereumTransaction(
                    to: recipient,
                    value: amountInWei,
                    gasLimit: 21000,
                    maxFeePerGas: Int(gasPrice.value * 2),
                    maxPriorityFeePerGas: Int(gasPrice.value)
                )
                
                txHash = try await sdk.evm.sendTransaction(
                    transaction: transaction,
                    wallet: wallet
                )
            } catch {
                errorMessage = "Failed: \(error.localizedDescription)"
            }
            isLoading = false
        }
    }
}

Sign Transaction (Without Sending)

To sign a transaction without broadcasting it:

import DynamicSDKSwift

let sdk = DynamicSDK.instance()

func signTransaction(wallet: BaseWallet) async {
    do {
        let transaction = EthereumTransaction(
            to: "0x...",
            value: 1000000000000000, // 0.001 ETH in Wei
            gasLimit: 21000,
            maxFeePerGas: 20000000000,
            maxPriorityFeePerGas: 1000000000
        )
        
        // Sign without sending
        let signedTx = try await sdk.evm.signTransaction(
            transaction: transaction,
            wallet: wallet
        )
        
        print("Signed transaction: \(signedTx)")
    } catch {
        print("Failed to sign: \(error)")
    }
}

ERC20 Token Transfers

Send ERC20 Tokens

import DynamicSDKSwift

let sdk = DynamicSDK.instance()

func sendERC20(
    wallet: BaseWallet,
    tokenAddress: String,
    recipient: String,
    amount: String  // Amount in token's smallest unit
) async {
    do {
        let input = WriteContractInput(
            contractAddress: tokenAddress,
            functionName: "transfer",
            args: [recipient, amount],
            abi: Erc20.abi
        )
        
        let txHash = try await sdk.evm.writeContract(
            wallet: wallet,
            input: input
        )
        
        print("ERC20 transfer sent!")
        print("Hash: \(txHash)")
    } catch {
        print("Failed to send ERC20: \(error)")
    }
}

Complete ERC20 Transfer Example

import SwiftUI
import DynamicSDKSwift

struct SendERC20View: View {
    let wallet: BaseWallet
    
    @State private var tokenAddress = ""
    @State private var recipient = ""
    @State private var amount = ""
    @State private var txHash: String?
    @State private var isLoading = false
    @State private var errorMessage: String?
    
    private let sdk = DynamicSDK.instance()
    
    var body: some View {
        VStack(spacing: 16) {
            TextField("Token contract address", text: $tokenAddress)
                .textFieldStyle(.roundedBorder)
                .autocapitalization(.none)
            
            TextField("Recipient address", text: $recipient)
                .textFieldStyle(.roundedBorder)
                .autocapitalization(.none)
            
            TextField("Amount (in smallest unit)", text: $amount)
                .textFieldStyle(.roundedBorder)
                .keyboardType(.numberPad)
            
            Button("Send Tokens") {
                sendTokens()
            }
            .disabled(tokenAddress.isEmpty || recipient.isEmpty || amount.isEmpty || isLoading)
            .buttonStyle(.borderedProminent)
            
            if isLoading {
                ProgressView("Sending...")
            }
            
            if let hash = txHash {
                Text("Transaction: \(hash)")
                    .font(.caption)
                    .foregroundColor(.green)
            }
            
            if let error = errorMessage {
                Text(error)
                    .foregroundColor(.red)
                    .font(.caption)
            }
        }
        .padding()
    }
    
    private func sendTokens() {
        isLoading = true
        errorMessage = nil
        txHash = nil
        
        Task { @MainActor in
            do {
                let input = WriteContractInput(
                    contractAddress: tokenAddress,
                    functionName: "transfer",
                    args: [recipient, amount],
                    abi: Erc20.abi
                )
                
                txHash = try await sdk.evm.writeContract(
                    wallet: wallet,
                    input: input
                )
            } catch {
                errorMessage = "Failed: \(error.localizedDescription)"
            }
            isLoading = false
        }
    }
}

Smart Contract Interactions

Write to Contract

import DynamicSDKSwift

let sdk = DynamicSDK.instance()

func writeContract(wallet: BaseWallet) async {
    // Example: Calling a custom contract function
    let customAbi = """
    [
        {
            "inputs": [
                {"name": "value", "type": "uint256"}
            ],
            "name": "setValue",
            "outputs": [],
            "stateMutability": "nonpayable",
            "type": "function"
        }
    ]
    """
    
    do {
        let input = WriteContractInput(
            contractAddress: "0xYourContractAddress",
            functionName: "setValue",
            args: ["12345"],
            abi: customAbi
        )
        
        let txHash = try await sdk.evm.writeContract(
            wallet: wallet,
            input: input
        )
        
        print("Contract interaction successful!")
        print("Hash: \(txHash)")
    } catch {
        print("Contract call failed: \(error)")
    }
}

Solana Transactions

Sign and Send Solana Transaction

import DynamicSDKSwift

let sdk = DynamicSDK.instance()

func sendSolanaTransaction(wallet: BaseWallet, base64Transaction: String) async {
    do {
        // Create connection and signer
        let connection = try await sdk.solana.createConnection()
        let signer = try await sdk.solana.createSigner(wallet: wallet)
        
        // Get latest blockhash
        let blockhash = try await connection.getLatestBlockhash()
        print("Latest blockhash: \(blockhash)")
        
        // Sign and send transaction
        let signature = try await signer.signAndSendEncodedTransaction(
            base64Transaction: base64Transaction
        )
        
        print("Solana transaction sent!")
        print("Signature: \(signature)")
    } catch {
        print("Solana transaction failed: \(error)")
    }
}

Sign Solana Message

import DynamicSDKSwift

let sdk = DynamicSDK.instance()

func signSolanaMessage(wallet: BaseWallet, message: String) async {
    do {
        let signer = try await sdk.solana.createSigner(wallet: wallet)
        let signature = try await signer.signMessage(message: message)
        
        print("Message signed!")
        print("Signature: \(signature)")
    } catch {
        print("Failed to sign message: \(error)")
    }
}

Sign Solana Transaction (Without Sending)

import DynamicSDKSwift

let sdk = DynamicSDK.instance()

func signSolanaTransaction(wallet: BaseWallet, base64Transaction: String) async {
    do {
        let signer = try await sdk.solana.createSigner(wallet: wallet)
        let signedTx = try await signer.signEncodedTransaction(
            base64Transaction: base64Transaction
        )
        
        print("Transaction signed!")
        print("Signed transaction: \(signedTx)")
    } catch {
        print("Failed to sign transaction: \(error)")
    }
}

Transaction Helpers

Get Gas Price

import DynamicSDKSwift

let sdk = DynamicSDK.instance()

func getGasPrice(chainId: Int) async -> Int? {
    do {
        let client = try await sdk.evm.createPublicClient(chainId: chainId)
        let gasPrice = try await client.getGasPrice()
        return Int(gasPrice.value)
    } catch {
        print("Failed to get gas price: \(error)")
        return nil
    }
}

Estimate Gas

For contract interactions, you may want to estimate gas:

// Gas limits for common operations:
// - ETH transfer: 21000
// - ERC20 transfer: ~65000
// - Complex contract calls: varies (estimate or use higher limit)

Best Practices

1. Always Get Current Gas Price

let client = try await sdk.evm.createPublicClient(chainId: chainId)
let gasPrice = try await client.getGasPrice()

// Add buffer for price fluctuations
let maxFeePerGas = Int(gasPrice.value * 2)

2. Handle Transaction Errors

do {
    let txHash = try await sdk.evm.sendTransaction(
        transaction: transaction,
        wallet: wallet
    )
} catch {
    // Common errors:
    // - Insufficient funds
    // - Gas price too low
    // - Invalid recipient address
    // - Network issues
    
    if error.localizedDescription.contains("insufficient") {
        showError("Insufficient funds for transaction")
    } else {
        showError("Transaction failed: \(error.localizedDescription)")
    }
}

3. Show Transaction Status

struct TransactionStatusView: View {
    let txHash: String
    let chainId: Int
    
    var explorerUrl: String {
        // Map chain ID to block explorer
        switch chainId {
        case 1: return "https://etherscan.io/tx/\(txHash)"
        case 84532: return "https://sepolia.basescan.org/tx/\(txHash)"
        case 137: return "https://polygonscan.com/tx/\(txHash)"
        default: return ""
        }
    }
    
    var body: some View {
        VStack {
            Text("Transaction Submitted")
                .font(.headline)
            
            Text(txHash)
                .font(.caption)
                .lineLimit(1)
                .truncationMode(.middle)
            
            if !explorerUrl.isEmpty {
                Link("View on Explorer", destination: URL(string: explorerUrl)!)
                    .font(.caption)
            }
        }
    }
}

4. Confirm Before Sending

struct ConfirmTransactionView: View {
    let recipient: String
    let amount: String
    let onConfirm: () -> Void
    let onCancel: () -> Void
    
    var body: some View {
        VStack(spacing: 16) {
            Text("Confirm Transaction")
                .font(.headline)
            
            VStack(alignment: .leading) {
                Text("To: \(recipient)")
                Text("Amount: \(amount) ETH")
            }
            .font(.caption)
            
            HStack {
                Button("Cancel", action: onCancel)
                    .buttonStyle(.bordered)
                
                Button("Confirm", action: onConfirm)
                    .buttonStyle(.borderedProminent)
            }
        }
        .padding()
    }
}

Error Handling

do {
    let txHash = try await sdk.evm.sendTransaction(
        transaction: transaction,
        wallet: wallet
    )
} catch {
    let errorMessage: String
    let errorDesc = error.localizedDescription.lowercased()
    
    if errorDesc.contains("insufficient") {
        errorMessage = "Insufficient balance for this transaction"
    } else if errorDesc.contains("gas") {
        errorMessage = "Gas estimation failed. Try increasing gas limit."
    } else if errorDesc.contains("rejected") || errorDesc.contains("denied") {
        errorMessage = "Transaction was rejected"
    } else if errorDesc.contains("network") {
        errorMessage = "Network error. Please check your connection."
    } else {
        errorMessage = "Transaction failed. Please try again."
    }
    
    showAlert(errorMessage)
}

Next Steps

After mastering transactions, you can:

Getting Started

Authentication

Wallets

Blockchain

SDK Reference

Overview

Prerequisites

EVM Transactions

Send ETH Transaction

Complete Send Transaction Example

Sign Transaction (Without Sending)

ERC20 Token Transfers

Send ERC20 Tokens

Complete ERC20 Transfer Example

Smart Contract Interactions

Write to Contract

Solana Transactions

Sign and Send Solana Transaction

Sign Solana Message

Sign Solana Transaction (Without Sending)

Transaction Helpers

Get Gas Price

Estimate Gas

Best Practices

1. Always Get Current Gas Price

2. Handle Transaction Errors

3. Show Transaction Status

4. Confirm Before Sending

Error Handling

Next Steps

Getting Started

Authentication

Wallets

Blockchain

SDK Reference

​Overview

​Prerequisites

​EVM Transactions

​Send ETH Transaction

​Complete Send Transaction Example

​Sign Transaction (Without Sending)

​ERC20 Token Transfers

​Send ERC20 Tokens

​Complete ERC20 Transfer Example

​Smart Contract Interactions

​Write to Contract

​Solana Transactions

​Sign and Send Solana Transaction

​Sign Solana Message

​Sign Solana Transaction (Without Sending)

​Transaction Helpers

​Get Gas Price

​Estimate Gas

​Best Practices

​1. Always Get Current Gas Price

​2. Handle Transaction Errors

​3. Show Transaction Status

​4. Confirm Before Sending

​Error Handling

​Transaction-Related Errors

​Next Steps

Overview

Prerequisites

EVM Transactions

Send ETH Transaction

Complete Send Transaction Example

Sign Transaction (Without Sending)

ERC20 Token Transfers

Send ERC20 Tokens

Complete ERC20 Transfer Example

Smart Contract Interactions

Write to Contract

Solana Transactions

Sign and Send Solana Transaction

Sign Solana Message

Sign Solana Transaction (Without Sending)

Transaction Helpers

Get Gas Price

Estimate Gas

Best Practices

1. Always Get Current Gas Price

2. Handle Transaction Errors

3. Show Transaction Status

4. Confirm Before Sending

Error Handling

Transaction-Related Errors

Next Steps