Transaction

• To create the transaction with wallet

ETH Transaction

1. Build ETH Transaction

To create an Ethereum transaction, use the ETHTransactionRequest with the following attributes:

• create a new Build ETHTransactionRequest should include the following attributes:

  • chainID : Chain ID (e.g., Ethereum is 1).

  • toAddress : Recipient's wallet address.

  • amount : Amount to transfer.

  • gasPrice : Gas price per unit.

  • gasLimit : Maximum gas allowed for the transaction.

  • nonce : Transaction count for the sender's account.

  • data : Optional additional data for the transaction.

  • paillierGroupID : User's Paillier group ID.

  • keyGenGroupID : the keygen Group ID of master wallet

  • keyIdentity : the keyIdentity of wallet

  • ecType: Cryptographic algorithm type (e.g., eddsa, ecdsa)

Example:

    let request = PayloadBuildETHTransactionRequest()
    request.chainID = chainId
    request.toAddress = toAddress
    request.amount = amount
    request.gasPrice = gasPrice
    request.gasLimit = gasLimit
    request.nonce = nonce
    request.data = data
    request.ecType = wallet.ecType
    request.paillierGroupID = paillierGroupId
    request.keyGenGroupID = keygenGroupId
    request.keyIdentity = wallet.keyIdentity

    let rawTransaction = try client.buildETHTransaction(request)

2. Send ETH Transaction with Web3

Example:

    import web3swift
    func sendRawTransaction(rawTransactionData: Data) {
    let infuraUrl = "https://mainnet.infura.io/v3/YOUR_INFURA_PROJECT_ID"
    let web3 = try! Web3.new(URL(string: infuraUrl)!)

    // Create a raw transaction from data
    let rawTxBytes = rawTransactionData

    // Send the raw transaction
    web3.eth.sendRawTransaction(rawTx: rawTxBytes) { result in
        switch result {
        case .success(let transactionHash):
            print("Transaction successfully sent. Hash: \(transactionHash)")
        case .failure(let error):
            print("Failed to send transaction: \(error.localizedDescription)")
        }
    }
}

SOLANA Transaction

1. Build Solana Transaction

• create a new Build BuildSolTransactionRequest should include the following attributes:

  • chainID: Chain ID (e.g., Solana mainnet is 501).

  • fromAddress: Sender's wallet address.

  • toAddress: Recipient's wallet address.

  • Amount: Amount to transfer.

  • paillierGroupID: User's Paillier group ID.

  • keyGenGroupID: Master wallet's key generation group ID.

  • KkeyIdentity: the keyIdentity of wallet

  • eCType: Cryptographic algorithm type (e.g., eddsa, ecdsa).

Example:

   let request = PayloadBuildSolTransactionRequest()
    request.chainID = chainId
    request.fromAddress = fromAddress
    request.toAddress = toAddress
    request.amount = amount
    request.ecType = wallet.ecType
    request.paillierGroupID = paillierGroupId
    request.keyGenGroupID = keygenGroupId
    request.keyIdentity = wallet.keyIdentity
    
    let rawTransaction = try client.buildSolTransaction(request)

2. Send SOLANA Transaction

• Use a Solana library to send the raw transaction. Encode the raw transaction to Base58 before sending. Example:

import Solana

func sendRawTransaction(rawTxBytes: Data) {
    let endpoint = APIEndPoint.mainnetBeta
    let solana = Solana(router: NetworkingRouter(endpoint: endpoint), accountStorage: InMemoryAccountStorage())

    // Encode raw transaction bytes to Base58
    let rawTxBase58 = rawTxBytes.base58EncodedString()

    // Send raw transaction
    solana.api.sendTransaction(
        serializedTransaction: rawTxBase58,
        configs: RequestConfiguration(encoding: "base64", skipPreflight: false, commitment: "finalized")
    ) { result in
        switch result {
        case .success(let transactionHash):
            print("Transaction successful! Hash: \(transactionHash)")
        case .failure(let error):
            print("Transaction failed: \(error.localizedDescription)")
        }
    }
}

import Base58

extension Data {
    func base58EncodedString() -> String {
        return Base58.encode(self)
    }
}

Tron Transaction

1. Build Tron Transaction

• create a new Build BuildTronTransactionRequest should include the following attributes:

  • chainID: Chain ID (e.g., Tron mainnet is 728, testnet is 939).

  • fromAddress: Sender's wallet address.

  • toAddress: Recipient's wallet address.

  • Amount: Amount to transfer.

  • paillierGroupID: User's Paillier group ID.

  • keyGenGroupID: Master wallet's key generation group ID.

  • KkeyIdentity: the keyIdentity of wallet

  • eCType: Cryptographic algorithm type (e.g., eddsa, ecdsa).

Example:

   let request = PayloadBuildTronTransactionRequest()
    request.chainID = chainId
    request.fromAddress = fromAddress
    request.toAddress = toAddress
    request.amount = amount
    request.ecType = wallet.ecType
    request.paillierGroupID = paillierGroupId
    request.keyGenGroupID = keygenGroupId
    request.keyIdentity = wallet.keyIdentity
    
    let rawTransaction = try client.buildTronTransaction(request)

3. Send Tron Transaction

• Use a Tron library to send the raw transaction. Encode the raw transaction to Base58 before sending. Example:

import Tron

func sendRawTransaction(rawTxBytes: Data) {
    let endpoint = APIEndPoint.mainnetBeta
    let rawTxBytes = Tron(router: NetworkingRouter(endpoint: endpoint), accountStorage: InMemoryAccountStorage())

    // Send raw transaction
    tron.api.sendTransaction(
        serializedTransaction: rawTxBytes,
        configs: RequestConfiguration(encoding: "base64", skipPreflight: false, commitment: "finalized")
    ) { result in
        switch result {
        case .success(let transactionHash):
            print("Transaction successful! Hash: \(transactionHash)")
        case .failure(let error):
            print("Transaction failed: \(error.localizedDescription)")
        }
    }
}

Ton CoinTransaction

1. Build Ton Coin Transaction

• create a new Build PayloadBuildTonTransactionRequest should include the following attributes:

  • chainID: Chain ID (e.g., Ton mainnet is ton, testnet is ton-testnet).

  • fromAddress: Sender's wallet address.

  • toAddress: Recipient's wallet address.

  • amount: Amount to transfer.

  • paillierGroupID: User's Paillier group ID.

  • keyGenGroupID: Master wallet's key generation group ID.

  • keyIdentity: the keyIdentity of wallet

  • ellipticCurveType: Cryptographic algorithm type (e.g., eddsa, ecdsa).

  • derivationPath: derivation Path of Ton chain "m/44'/607'/0'"

  • subwallet: The type of ton wallet v3r2 (698983191)

  • comment: memo of transaction

  • bounce: the transaction to bounce (true, false)

Example:

   let request = PayloadBuildTonTransactionRequest()
        request.keyGenGroupID = "keygenGroupId"
        request.paillierGroupID = "paillierGroupId"
        request.keyIdentity = "keyIdentity"
        request.ellipticCurveType = "eddsa"
        request.derivationPath = "derivationPath"
        request.chainID = "ton-testnet"
        request.toAddress = "toAddress"
        request.fromAddress = "fromAddress"
        request.amount = "amount"
        request.subwallet = "subWallet"
        request.comment = "memo"
        request.bounce = true
    
    let rawTxBytes = try client.buildTonTransaction(request)

3. Send Ton Coin Transaction

• Use a Ton library to send the raw transaction. Encode the raw transaction to Base64 before sending. Example:

import Foundation

struct BOCRequest: Codable {
    let boc: String
}

func sendRawTransaction(rawTxBytes: Data) {
    let bocMessage = rawTxBytes.base64EncodedString()
    // 2. Create the URL
    guard let url = URL(string: "https://quiknode/sendBocReturnHash") else {
        print("Invalid URL")
        return
    }
    
    // 3. Construct the URLRequest
    var request = URLRequest(url: url)
    request.httpMethod = "POST"
    // Add headers
    request.setValue("application/json", forHTTPHeaderField: "Content-Type")
    request.setValue("application/json", forHTTPHeaderField: "Accept")
    
    // 4. Create the request body
    let bocPayload = BOCRequest(
        boc: bocMessage
    )
    
    do {
        // Convert the Swift struct to JSON
        let jsonData = try JSONEncoder().encode(bocPayload)
        request.httpBody = jsonData
    } catch {
        print("Error encoding JSON: \(error.localizedDescription)")
        return
    }
    
    // 5. Send the request with URLSession
    let task = URLSession.shared.dataTask(with: request) { data, response, error in
        // Parse the response data (if any)
        if let data = data,
           let responseString = String(data: data, encoding: .utf8) {
            print("Response: \(responseString)")
        }
    }
    
    task.resume()

}

Bitcoin Transaction

1. Build Bitcoin Transaction

• create a new Build PayloadBuildBtcTransactionRequest should include the following attributes:

  • chainID: Chain ID (e.g., BTC mainnet is btc, testnet is btc-testnet).

  • fromAddress: Sender's wallet address.

  • receiverAddress: Recipient's wallet address.

  • amount: Amount to transfer.

  • paillierGroupID: User's Paillier group ID.

  • keyGenGroupID: Master wallet's key generation group ID.

  • keyIdentity: the keyIdentity of wallet

  • ellipticCurveType: Cryptographic algorithm type (e.g., eddsa, ecdsa).

  • IgnoringFee: The flag used to skip fee enforcement on testnet. This should always be set to false on mainnet.

Example:

   let request = PayloadBuildBtcTransactionRequest()
        request.chainId = "chainId"
        request.fromAddress = "fromAddress"
        request.receiverAddress = "toAddress"
        request.amount = "amount"
        request.ellipticCurveType = "ecType"
        request.paillierGroupID = "paillierGroupId"
        request.keyGenGroupID = "keygenGroupId"
        request.keyIdentity = "keyIdentity"
        request.derivationPath = "derivationPath"
        request.IgnoringFee = true
    
    let rawTxBytes = try client.buildBtcTransaction(request)

3. Send Bitcoin Transaction

• Use a BTC library to send the raw transaction Example:

import Foundation

extension Data {
    /// Returns a lowercase hex string representation of the Data.
    func toHexString() -> String {
        return self.map { String(format: "%02x", $0) }.joined()
    }
}

func sendRawTransaction(rawTxBytes: Data) {
    
    // 1. Define the URL
    guard let url = URL(string: "https://blockstream.info/testnet/api/tx") else {
        print("Invalid URL")
        return
    }
    
    // 2. Prepare the URLRequest
    var request = URLRequest(url: url)
    request.httpMethod = "POST"
    // Blockstream’s API expects `text/plain`
    request.setValue("text/plain", forHTTPHeaderField: "Content-Type")
    
    // 3. The raw transaction in hex (same as in your curl --data)
    let rawTransactionHex = rawTxBytes.toHexString()
    
    // 4. Convert the hex string to Data and assign to request's body
    request.httpBody = rawTransactionHex.data(using: .utf8)
    
    // 5. Send the request
    let task = URLSession.shared.dataTask(with: request) { data, response, error in
        // Handle client-side error
        if let error = error {
            print("Error: \(error)")
            return
        }
        
        // Check server response
        guard let httpResponse = response as? HTTPURLResponse else {
            print("No response from server.")
            return
        }
        
        // Print status for debugging
        print("Status code: \(httpResponse.statusCode)")
        
        // Handle response data
        if let data = data, let responseString = String(data: data, encoding: .utf8) {
            // The API typically returns the transaction ID if successful,
            // or an error message otherwise.
            print("Response body: \(responseString)")
        } else {
            print("No data in response.")
        }
    }
    
    task.resume()

}