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
ETHTransactionRequestshould 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 walletkeyIdentity: the keyIdentity of walletecType: 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
BuildSolTransactionRequestshould 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
BuildTronTransactionRequestshould 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)
2. 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
PayloadBuildTonTransactionRequestshould 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)
2. 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
PayloadBuildBtcTransactionRequestshould 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)
2. 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()
}
Xrp Transaction
1. Build XRP Transaction
create a new Build
PayloadBuildXrpTransactionRequestshould include the following attributes:chainId: Chain ID (e.g., XRP mainnet is xrp, testnet is xrp-testnet).
fromAddress: Sender's XRP wallet address.
toAddr: Recipient's XRP wallet address.
amount: Amount to transfer.
paillierGroupID: User's Paillier group ID.
keyGenGroupID: Master wallet's key generation group ID.
keyIdentity: The keyIdentity of the wallet.
ellipticCurveType: Cryptographic algorithm type (e.g., ecdsa, eddsa).
derivationPath: Derivation path for the key.
Example:
let request = PayloadBuildXrpTransactionRequest()
request.chainId = "chainId"
request.fromAddress = "fromAddress"
request.toAddr = "toAddress"
request.amount = "amount"
request.ellipticCurveType = "ecType"
request.paillierGroupID = "paillierGroupId"
request.keyGenGroupID = "keygenGroupId"
request.keyIdentity = "keyIdentity"
request.derivationPath = "derivationPath"
let rawTxBytes = try client.buildXrpTransaction(request)2. Send XRP Transaction
Use an XRP library or network provider (such as the XRPL JSON-RPC API) to send the raw transaction.
Last updated