Onchain Plugin for Dart—an advanced cross-platform solution that seamlessly integrates with Ethereum, Tron, Solana and Cardano blockchains, supporting key features such as Legacy EIP1559, EIP2930, EIP71, and now, the cutting-edge EIP721 standard. This plugin empowers developers with comprehensive capabilities for Ethereum transactions, smart contracts, and token standards, including NFTs through EIP721. Beyond Ethereum, it facilitates a wide range of Tron, Solana and Cardano operations, including account creation, asset transfer, stake, pool, metaplex and smart contract executions.
Unleash the potential of your Dart applications on the Ethereum Virtual Machine (EVM) network. With the Onchain Plugin, seamlessly transact, deploy smart contracts, and engage with decentralized applications on one of the most influential blockchain networks. Effortlessly harness the power of EIP1559, EIP2930, and the latest EIP721 standard for enhanced Ethereum capabilities.
-
Sign (Transaction, Personal Signing): Enable secure transaction and personal data signing within your Dart applications, ensuring cryptographic integrity and authentication.
-
EIP1559: Embrace the efficiency of the Ethereum Improvement Proposal 1559, optimizing transaction fee mechanisms for enhanced predictability and user experience.
-
EIP2930 (Access List): Streamline contract interactions with the Ethereum blockchain using Access Lists, enhancing efficiency and reducing transaction costs by specifying accounts with direct access permissions.
-
Interact with Contract: Seamlessly engage with Ethereum smart contracts, unlocking the full potential of decentralized applications through efficient contract interactions within your Dart projects.
-
Interact with Ethereum Node (JSON RPC): Facilitate direct communication with Ethereum nodes through JSON RPC, enabling your Dart applications to access and query blockchain data in a standardized and efficient manner.
-
EIP712 (Legacy, v3, v4): Implement Ethereum Improvement Proposal 712 standards for structured and secure message signing, supporting legacy as well as versions 3 and 4 to ensure compatibility and compliance across diverse Ethereum ecosystems.
Dive into the Tron Virtual Machine (TVM) networks with confidence. The Onchain Plugin for Dart extends support to Tron, enabling smooth account creation, asset transfers, and execution of various smart contracts. Explore a multitude of Tron contracts, including smart contracts, with ease, empowering your Dart applications to thrive in the diverse Tron blockchain ecosystem.
-
Sign (Transaction, Personal Signing) for Tron: Securely authorize Tron transactions and sign personal data within your Dart applications, ensuring cryptographic integrity and user authentication.
-
Multi-Signature: Enhance security and decentralized decision-making on the Tron blockchain with multi-signature capabilities. Enable collaboration by requiring multiple cryptographic signatures for transactions, reinforcing trust and integrity within the Tron network. Empower your Dart applications with sophisticated multi-signature functionality for a resilient and collaborative approach to transaction authorization on Tron.
-
Interact with Tron Smart Contract: Seamlessly engage with Tron's smart contracts, enabling your Dart projects to execute and manage transactions on the Tron blockchain with ease.
-
Create Tron Native Contract Transactions: Effortlessly initiate a wide array of Tron native contract transactions, including account creation, asset transfers, voting, smart contract creation, and more. Explore a comprehensive list of supported contract operations tailored for Tron's blockchain.
-
Interact with Tron HTTP Node: Facilitate direct communication with Tron's blockchain through HTTP nodes, allowing your Dart applications to query and interact with Tron's network in a standardized and efficient manner.
-
All Features of Tron: Harness the full potential of Tron's blockchain by leveraging all its features, including shielded transfers, market transactions, resource delegation, contract management, and more. Empower your Dart applications with comprehensive functionality for a rich and dynamic Tron blockchain experience.
Delve confidently into the Solana blockchain ecosystem with the Onchain Plugin for Dart, your gateway to seamless integration with Solana's powerful network. Empower your Dart applications to navigate the Solana landscape with ease, from account creation to asset transfers and execution of a diverse range of smart contracts. Uncover the full potential of Solana's network, harnessing its scalability and performance to drive innovation and growth in your projects. Explore the multitude of Solana contracts, including smart contracts, and unlock new possibilities for your Dart applications to flourish within the dynamic Solana blockchain ecosystem.
-
Transaction: Versioned Transaction Generation, Serialization, and Deserialization.
-
Sign: Effortlessly Sign Transactions
-
Instructions: The plugin offers numerous pre-built instructions, simplifying the process of creating your own transactions. Here are some examples:
- addressLockupTable
- associatedTokenAccount
- computeBudget
- ed25519
- memo
- nameService
- secp256k1
- splToken
- splTokenMetaData
- splTokenSwap
- stake
- stakePool
- system
- tokenLending
- vote
- Metaplex
- auctionHouse
- auctioneer
- bubblegum
- candyMachineCore
- fixedPriceSale
- gumdrop
- hydra
- nftPacks
- tokenEntangler
- tokenMetaData
-
Custom Programs: The plugin facilitates the Solana Buffer layout structure, enabling effortless encoding and decoding of pertinent data
Dive confidently into the Cardano blockchain ecosystem with "on_chain" - your gateway to seamless integration with Cardano's powerful network. Empower your Dart applications to navigate the Cardano landscape with ease, from account creation to asset transfers and execution of a diverse range of smart contracts. Uncover the full potential of Cardano's network, harnessing its scalability and performance to drive innovation and growth in your projects. Explore the multitude of Cardano contracts, including smart contracts, and unlock new possibilities for your Dart applications to flourish within the dynamic Cardano blockchain ecosystem.
-
Transaction: Generate and construct Cardano transactions across both the Byron and Shelley eras. Serialization, and Deserialization.
-
Sign: Effortlessly Sign Transactions
-
Addresses: Comprehensive address support, base, reward, pointer, enterprise, as well as both Byron and legacy Byron formats.
-
HD-Wallet: Seed generator for legacy and Icarus formats, alongside HD wallet management for both Shelley and Byron era
-
Transactions: The plugin boasts extensive support for a variety of Cardano transactions. Here are some examples:
- Mint
- Plutus
- NativeScripts
- Certificate (Stake, Pool, MIR)
- Metadata
- Withdrawals
-
Private and public key
/// Ethereum /// Initialize an Ethereum private key. final ETHPrivateKey ethereumPrivateKey = ETHPrivateKey("..."); /// Generate a cryptographic signature for a transaction digest. final String sign = ethereumPrivateKey.sign("txDigest"); /// Generate a cryptographic signature for a personal message. final String personalSign = ethereumPrivateKey.signPersonalMessage("message"); /// Obtain the corresponding public key. final ETHPublicKey publicKey = ethereumPrivateKey.publicKey(); /// Verify the authenticity of a personal message using the public key. final bool verify = publicKey.verifyPersonalMessage("message", "signature"); /// Derive the Ethereum address associated with the public key. final EthereumAddress ethereumAddress = publicKey.toAddress(); /// Tron /// Initialize a Tron private key. final TronPrivateKey tronPrivateKey = TronPrivateKey("..."); /// Generate a cryptographic signature for a Tron transaction digest. final String tronSign = tronPrivateKey.sign("txDigest"); /// Generate a cryptographic signature for a Tron personal message. final String tronPersonalSign = tronPrivateKey.signPersonalMessage("message"); /// Obtain the corresponding Tron public key. final TronPublicKey tronPublicKey = tronPrivateKey.publicKey(); /// Verify the authenticity of a Tron personal message using the public key. final bool verifyTron = tronPublicKey.verifyPersonalMessage("message", "signature"); /// Derive the Tron address associated with the public key. final TronAddress tronAddress = tronPublicKey.toAddress(); /// Convert the Tron address to a base58-encoded format. final String base58TronAddress = tronAddress.toString(true); /// Convert the Tron address to a hexadecimal format. final String hexTronAddress = tronAddress.toString(false); /// Solana /// Initialize a Solana private key. final SolanaPrivateKey solanaPrivateKey = SolanaPrivateKey.fromSeedHex("..."); /// Generate a cryptographic signature for a solana transaction serialized. final String solanaSign = solanaPrivateKey.sign("txDigestBytes"); /// Obtain the corresponding Solana public key. final SolanaPublicKey solanaPublicKey = solanaPrivateKey.publicKey(); /// Verify signature. final bool verifySignature = solanaPublicKey.verify("messageBytes", "signatureBytes"); /// Derive the Solana address associated with the public key. final SolAddress solanaAddress = solanaPublicKey.toAddress(); /// Cardano // Define a private key final privateKey = AdaPrivateKey.fromBytes(...); // Create a Byron address final byronAddress = ADAByronAddress.fromPublicKey(publicKey: ..., chaincode: ...); // Generate a legacy Byron address final byronLegacyAddress = ADAByronAddress.legacy( publicKey: .., chaincode: .., hdPathKey:.., hdPath: ''); // Construct a Shelley base address final shellyBase = ADABaseAddress( "addr_test1qzkrh0ytcw257np6x6lxp74a6p4erj7rqt9azycnckgp2f27p5uc85frnln985tjn0xv8fmdv4t696d3j9zvu0ktx0gs62w8wv"); // Formulate a Shelley reward address final shellyReward = ADARewardAddress("stake..."); // Create a Shelley pointer address final shellyPointer = ADAPointerAddress.fromPublicKey( pubkeyBytes: ...Bip32KholawMstKeyGeneratorConst.masterKeyHmacKey, pointer: Pointer(slot: slot, txIndex: txIndex, certIndex: certIndex)); // Define an enterprise address final enterpriseAddress = ADAEnterpriseAddress("...");
-
Ethreum transaction
Check out all the examples at the provided link.
/// Connect to the WebSocket service final wsocketService = await RPCWebSocketService.connect( "wss://polygon-mumbai-bor.publicnode.com"); /// Create an Ethereum RPC instance final rpc = EVMRPC(wsocketService); /// Define a seed for generating a private key final seed = BytesUtils.fromHexString( "6fed8bf347b201c4ff0379c9173a042163dbd5f1110bcb983ac8615dcbb98c853f7c1b524dcebdf47e2d19778d0b30e25065d5a5012d83b874ab7034e95a713f"); /// Derive the BIP44 path for Ethereum final bip44 = Bip44.fromSeed(seed, Bip44Coins.ethereum).deriveDefaultPath; /// Create an Ethereum private key from the BIP44 private key final privateKey = ETHPrivateKey.fromBytes(bip44.privateKey.raw); /// Derive the public key and Ethereum address from the private key final publicKey = privateKey.publicKey(); final address = publicKey.toAddress(); /// Define the target ERC-20 contract address final contractAddress = ETHAddress("0x6c6b4fd6502c74ed8a15d54b9152973f3aa24e51"); /// Define the transfer function fragment using ABI final transferFragment = AbiFunctionFragment.fromJson({ "inputs": [ {"internalType": "address", "name": "to", "type": "address"}, {"internalType": "uint256", "name": "value", "type": "uint256"} ], "name": "transfer", "stateMutability": "nonpayable", "type": "function" }, false); /// Request gas price from the RPC service final gasPrice = await rpc.request(RPCGetGasPrice()); /// Request nonce (transaction count) for the sender's address final nonce = await rpc.request(RPCGetTransactionCount(address: address.address)); /// Build an Ethereum transaction for a contract call (transfer) ETHTransaction tr = ETHTransaction( type: ETHTransactionType.legacy, /// Sender's Ethereum address from: address, /// Target ERC-20 contract address to: contractAddress, /// Nonce (transaction count) for the sender nonce: nonce, /// Placeholder for gas limit (to be estimated later) gasLimit: BigInt.zero, /// Gas price obtained from RPC service (only for legacy and eip2930 transaction) gasPrice: gasPrice, data: transferFragment.encode([ /// Recipient address ETHAddress("0xBfD365373f559Cd398A408b975FD18B16632d348"), /// Amount to transfer (in Wei) ETHHelper.toWei("100") ]), /// No Ether value sent with the transaction value: BigInt.zero, /// Ethereum chain ID (Mumbai testnet) chainId: BigInt.from(80001), ); /// Estimate gas limit for the transaction final gasLimit = await rpc.request(RPCEstimateGas( transaction: tr.toEstimate(), )); /// Update the transaction with the estimated gas limit tr = tr.copyWith(gasLimit: gasLimit); /// Serialize the unsigned transaction final unsignedSerialized = tr.serialized; /// Sign the transaction with the private key final signature = privateKey.sign(unsignedSerialized); /// Serialize the signed transaction final signedSerialized = BytesUtils.toHexString(tr.signedSerialized(signature), prefix: "0x"); /// Send the signed transaction to the Ethereum network await rpc.request(RPCSendRawTransaction(transaction: signedSerialized));
-
Contract intraction
Tron and Ethereum
Check out all the examples at the provided link.
/// For Tron: If the output parameters include an address, set isTron to true. /// If it doesn't, set isTron to false to receive an ETH address instead of a Tron address. final contract = ContractABI.fromJson(tronContract["entrys"]!, isTron: true); final rpc = EVMRPC(RPCHttpService("https://api.shasta.trongrid.io/jsonrpc")); final call1 = await rpc.request(RPCCall.fromMethod( contractAddress: /// use hex address (visible to false) TronAddress("TLKdBQPmZbScLWENtAW5uVJCwJWMb2n6vU").toAddress(false), function: contract.functionFromName("checkInt"), params: [ BigInt.from(12), -BigInt.from(150), BigInt.from(25), BigInt.from(2), ]));
Tron with Http Node
Check out all the examples at the provided link.
final contract = ContractABI.fromJson(tronContract["entrys"]!, isTron: true); final rpc = TronProvider(TronHTTPProvider(url: "https://api.shasta.trongrid.io")); final call1 = await rpc.request(TronRequestTriggerConstantContract.fromMethod( ownerAddress: TronAddress("TLKdBQPmZbScLWENtAW5uVJCwJWMb2n6vU"), contractAddress: TronAddress("TLKdBQPmZbScLWENtAW5uVJCwJWMb2n6vU"), function: contract.functionFromName("checkInt"), /// trx amount in call callValue: null, /// trc10 amount and token id in call callTokenValue: null, tokenId: null, params: [ -BigInt.from(12), -BigInt.from(150), BigInt.from(25), BigInt.from(2), ], ));
-
Tron transaction
Check out all the examples at the provided link.
Transfer TRX
/// intialize private key, address, receiver and .... final seed = BytesUtils.fromHexString( "6fed8bf347b201c4ff0379c9173a042163dbd5f1110bcb983ac8615dcbb98c853f7c1b524dcebdf47e2d19778d0b30e25065d5a5012d83b874ab7034e95a713f"); final bip44 = Bip44.fromSeed(seed, Bip44Coins.tron); final prv = TronPrivateKey.fromBytes(bip44.privateKey.raw); final publicKey = prv.publicKey(); final address = publicKey.toAddress(); final receiverAddress = TronAddress("TF3cDajEAaJ8jFXFB2KF3XSUbTpZWzuSrp"); /// intialize shasta http provider to send and receive requests final rpc = TronProvider(TronHTTPProvider(url: "https://api.shasta.trongrid.io")); /// create transfer contract (TRX Transfer) final transferContract = TransferContract( /// 10 TRX amount: TronHelper.toSun("10"), ownerAddress: address, toAddress: receiverAddress, ); /// validate transacation and got required data like block hash and .... final request = await rpc.request(TronRequestCreateTransaction.fromContract( /// params: permission ID (multi-sig Transaction), optional data like memo transferContract, visible: false)); /// An error has occurred with the request, and we need to investigate the issue to determine what is happening. if (!request.isSuccess) { /// print(request.error ?? request.respose); return; } /// get transactionRaw from response and make sure sed fee limit final rawTr = request.transactionRaw!.copyWith(feeLimit: BigInt.from(10000000)); // txID final _ = rawTr.txID; /// get transaaction digest and sign with private key final sign = prv.sign(rawTr.toBuffer()); /// create transaction object and add raw data and signature to this final transaction = Transaction(rawData: rawTr, signature: [sign]); /// get raw data buffer final raw = BytesUtils.toHexString(transaction.toBuffer()); /// send transaction to network await rpc.request(TronRequestBroadcastHex(transaction: raw));
Frozen balance (bandwidth, energy)
/// create contract final contract = FreezeBalanceV2Contract( ownerAddress: ownerAddress, frozenBalance: TronHelper.toSun("3.5"), resource: ResourceCode.bandWidth); /// validate transacation and got required data like block hash and .... final request = await rpc.request(TronRequestFreezeBalanceV2.fromContract( /// params: permission ID (multi-sig Transaction) contract)); /// An error has occurred with the request, and we need to investigate the issue to determine what is happening. if (!request.isSuccess) { //// print(request.error); return; } /// get transactionRaw from response and make sure set fee limit final rawTr = request.transactionRaw!.copyWith( feeLimit: BigInt.from(10000000), data: utf8.encode("https://github.com/mrtnetwork")); final _ = rawTr.txID; /// get transaaction digest and sign with private key final sign = ownerPrivateKey.sign(rawTr.toBuffer()); /// create transaction object and add raw data and signature to this final transaction = Transaction(rawData: rawTr, signature: [sign]); /// send transaction to network await rpc.request(TronRequestBroadcastHex(transaction: transaction.toHex));
-
Solana transaction
Check out all the examples at the provided link.
Transfer SOL
/// Set up the RPC service with the Solana devnet endpoint. final service = RPCHttpService("https://api.devnet.solana.com"); /// Initialize the Solana RPC client. final rpc = SolanaRPC(service); /// Define the owner's private key and derive the owner's public key. final ownerPrivateKey = SolanaPrivateKey.fromSeedHex( "4e27902b3df33d7857dc9d218a3b34a6550e9c7621a6d601d06240a517d22017"); final owner = ownerPrivateKey.publicKey().toAddress(); /// Define the recipient's address. final receiver = SolAddress("9eaiUBgyT7EY1go2qrCmdRZMisYkGdtrrem3TgP9WSDb"); /// Retrieve the latest block hash. final blockHash = await rpc.request(const SolanaRPCGetLatestBlockhash()); /// Create a transfer instruction to move funds from the owner to the receiver. final transferInstruction = SystemProgram.transfer( from: owner, layout: SystemTransferLayout(lamports: SolanaUtils.toLamports("0.001")), to: receiver); /// Construct a Solana transaction with the transfer instruction. final transaction = SolanaTransaction( instructions: [transferInstruction], recentBlockhash: blockHash.blockhash, payerKey: owner, type: TransactionType.v0); /// Sign the transaction with the owner's private key. final ownerSignature = ownerPrivateKey.sign(transaction.serializeMessage()); transaction.addSignature(owner, ownerSignature); /// Serialize the transaction. final serializedTransaction = transaction.serializeString(); /// Send the transaction to the Solana network. await rpc.request( SolanaRPCSendTransaction(encodedTransaction: serializedTransaction));
-
Cardano Transaction
Check out all the examples at the provided link.
Transfer ADA
/// Create a BIP32 derivation from a seed final bip32 = CardanoIcarusBip32.fromSeed(List<int>.filled(20, 12)); /// Derive a spending key from the BIP32 derivation path final spend = bip32.derivePath("1852'/1815'/0'/0/0"); /// Extract the private key from the spending key final privateKey = AdaPrivateKey.fromBytes(spend.privateKey.raw); /// Define the sender enterprise address ADAEnterpriseAddress addr = ADAEnterpriseAddress( "addr_test1vp0q6wvr6y3elejn69efhnxr5akk24azaxcez3xw8m9n85gmr5qny", network: ADANetwork.testnetPreprod); /// Define the receiver enterprise address ADAEnterpriseAddress receiver = ADAEnterpriseAddress( "addr_test1vp0q6wvr6y3elejn69efhnxr5akk24azaxcez3xw8m9n85gmr5qny", network: ADANetwork.testnetPreprod); /// Set up the Blockfrost provider final provider = BlockforestProvider(BlockforestHTTPProvider( url: "https://cardano-preprod.blockfrost.io/api/v0/", projectId: "preprodMVwzqm4PuBDBSfEULoMzoj5QZcy5o3z5")); /// Define transaction inputs and outputs final input = TransactionInput( transactionId: TransactionHash.fromHex( "6419830644a3310e8ddf55998154bd07afe9f4a73872b6dd4d39ac43ff59ad8c"), index: 0); final output = TransactionOutput( address: receiver, amount: Value(coin: ADAHelper.toLovelaces("1"))); final change = TransactionOutput( address: addr, amount: Value( coin: ADAHelper.toLovelaces("10000") - ADAHelper.toLovelaces("1.2"))); final fee = ADAHelper.toLovelaces("0.2"); /// Construct the transaction body final body = TransactionBody(inputs: [input], outputs: [change, output], fee: fee); /// Create the ADA transaction with witness final transaction = ADATransaction( body: body, witnessSet: TransactionWitnessSet(vKeys: [ privateKey.createSignatureWitness(body.toHash().data), ])); /// Submit the transaction via Blockfrost provider await provider.request(BlockfrostRequestSubmitTransaction( transactionCborBytes: transaction.serialize()));
-
-
EIP-712
/// Create an EIP-712 message final Eip712TypedData eip712 = Eip712TypedData( types: { "EIP712Domain": [ const Eip712TypeDetails(name: "name", type: "string"), const Eip712TypeDetails(name: "version", type: "string"), const Eip712TypeDetails(name: "chainId", type: "uint256"), const Eip712TypeDetails(name: "verifyingContract", type: "address"), ], "Person": [ const Eip712TypeDetails(name: "name", type: "string"), const Eip712TypeDetails(name: "wallet", type: "address"), ], "Mail": [ const Eip712TypeDetails(name: "from", type: "Person"), const Eip712TypeDetails(name: "to", type: "Person"), const Eip712TypeDetails(name: "contents", type: "string") ], }, primaryType: "Mail", domain: { "name": "Ether Mail", "version": "1", "chainId": BigInt.from(80001), "verifyingContract": "0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC", }, message: { "from": { "name": "Cow", "wallet": "0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826" }, "to": { "name": "Bob", "wallet": "0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB" }, "contents": "Hello, Bob!", }); /// Encode the types of the EIP-712 message final encodeTypes = eip712.encode(); /// Define a private key for signing the EIP-712 message final privateKey = ETHPrivateKey( "db8cf18222bb47698309de20e0befa9a55ef1f0af001dcefa79d31446484dc65"); /// Sign the encoded types with the private key, setting hashMessage to false final _ = privateKey.sign(encodeTypes, hashMessage: false).toHex();
The plugin offers extensive support for pre-built programs, each comprising four key sections:
- Layouts: These receive the desired data for each program and decode it for transaction processing.
- Programs: These are responsible for generating instructions.
- Account: This section manages accounts associated with the program.
- RPC: Utilized for obtaining accounts linked to the program.
- Utils: Provides various program utilities.
Example:
/// Define the layout for initializing the candy machine.
final initializeCandyMachineLayout =
MetaplexCandyMachineInitializeCandyMachineLayout(
data: CandyMachineData(
itemsAvailable: BigInt.two,
symbol: "MRT",
sellerFeeBasisPoints: 100,
maxSupply: BigInt.from(1000),
isMutable: false,
creators: [Creator(address: address, verified: true, share: 0)]));
/// Find the mint counter PDA.
final mint = MetaplexCandyMachineProgramUtils.findMintCounterPda(
id: id, user: user, candyGuard: candyGuard, candyMachine: candyMachine);
/// Initialize the candy machine.
final instruction = MetaplexCandyMachineCoreProgram.initializeCandyMachine(
candyMachine: candyMachine,
authorityPda: authorityPda,
authority: authority,
payer: payer,
collectionMetadata: collectionMetadata,
collectionMint: collectionMint,
collectionMasterEdition: collectionMasterEdition,
collectionUpdateAuthority: collectionUpdateAuthority,
collectionAuthorityRecord: collectionAuthorityRecord,
tokenMetadataProgram: tokenMetadataProgram,
layout: layout);
/// Request the candy machine account information from the RPC.
final CandyMachineAccount account =
await rpc.request(SolanaRPCGetCandyMachineAccount(account: account));
/// Extract the authority from the candy machine account.
final authority = account.authority;
-
Ethereum
Discover the full spectrum of methods in the link.
/// HTTP RPC Service final httpRpc = RPCHttpService("https://bsc-testnet.drpc.org/"); // Initialize an HTTP RPC service for interacting with the Binance Smart Chain (BSC) testnet. /// WebSocket RPC Service final websocketRpc = await RPCWebSocketService.connect( "wss://go.getblock.io/b9c91d92aaeb4e5ba2d4cca664ab708c", onEvents: (p0) {}, onClose: (p0) {}); // Establish a WebSocket RPC connection to the specified endpoint for real-time updates. /// Ethereum RPC final rpc = EVMRPC(httpRpc); // Create an Ethereum RPC instance using the HTTP RPC service. /// Get Balance final balance = await rpc.request(RPCGetBalance( address: ETHAddress("0x7Fbb78c66505876284a49Ad89BEE3df2e0B7ca5E").address)); // Request the balance of a specific Ethereum address using the RPC service. /// Get Block final block = await rpc .request(RPCGetBlockByNumber(blockNumber: BlockTagOrNumber.latest)); // Request information about the latest Ethereum block using the RPC service. /// Contract Call final call = await rpc.request(RPCCall.fromRaw(contractAddress: ".....", raw: "raw")); // Make a contract call using the RPC service, specifying the contract address and raw data. /// Methods Reference /// Explore all available methods in the ethereum/rpc/methods/ directory. /// These methods encapsulate various Ethereum RPC calls for convenient usage.
-
Tron Full-Http node
Discover the full spectrum of methods in the link.
/// Tron Provider Initialization final rpc = TronProvider(TronHTTPProvider(url: "https://api.trongrid.io")); // Initialize a Tron Provider using an HTTP endpoint to interact with the Tron blockchain. /// Get Account Information final accountInfo = await rpc.request(TronRequestGetAccount( address: TronAddress("TMcbQBuj5ATtm9feRiMp6QRd587hT7HHyU"))); // Request detailed account information for the specified Tron address. /// Get Account Resource Information final accountResource = await rpc.request(TronRequestGetAccountResource( address: TronAddress("TMcbQBuj5ATtm9feRiMp6QRd587hT7HHyU"))); // Retrieve resource-related information for the specified Tron address. /// Get Chain Parameters final chainParameters = await rpc.request(TronRequestGetChainParameters()); // Fetch parameters specific to the Tron blockchain. /// Get Latest Block Information final block = await rpc.request(TronRequestGetNowBlock());
-
Solana RPC
Discover the full spectrum of methods in the link.
/// Initialize the Solana RPC client with the devnet endpoint. final service = SolanaRPC(RPCHttpService("https://api.devnet.solana.com")); /// Retrieve the account information for a specific address. final accountModel = await service.request(const SolanaRPCGetAccountInfo( account: SolAddress.unchecked( "527pWSWfeQGLM7SoyVXjCRkrSZBtDkH6ShEBJB3nUDkA"))); /// Retrieve the account information for a specific address with context. final accountModelWithContext = await service.requestWithContext( const SolanaRPCGetAccountInfo( account: SolAddress.unchecked( "527pWSWfeQGLM7SoyVXjCRkrSZBtDkH6ShEBJB3nUDkA"))); /// Retrieve the account information for a specific address and return as JSON. final accountResponseInJson = await service.requestDynamic( const SolanaRPCGetAccountInfo( account: SolAddress.unchecked( "527pWSWfeQGLM7SoyVXjCRkrSZBtDkH6ShEBJB3nUDkA")));
-
Cardano (blockfrost)
Discover the full spectrum of methods in the link.
/// Set up the Blockfrost provider with the specified URL and project ID final provider = BlockforestProvider(BlockforestHTTPProvider( url: "https://cardano-preprod.blockfrost.io/api/v0/", projectId: "preprodMVwzqm4PuBDBSfEULoMzoj5QZcy5o3z5")); /// Retrieve UTXOs for a specific Cardano address final List<ADAAccountUTXOResponse> accountUtxos = await provider.request( BlockfrostRequestAddressUTXOs(ADAAddress.fromAddress( "addr_test1vp0q6wvr6y3elejn69efhnxr5akk24azaxcez3xw8m9n85gmr5qny"))); /// Fetch the latest epoch's protocol parameters final ADAEpochParametersResponse protocolParams = await provider.request(BlockfrostRequestLatestEpochProtocolParameters()); /// Get UTXOs associated with a specific transaction final ADATransactionUTXOSResponse transaction = await provider.request( BlockfrostRequestTransactionUTXOs( "69edd1c1c4fdc282e3fe1d90f368a228d7702316dc33e494e5bee7db81d6183b"));
-
/// Generate a 12-word mnemonic phrase.
final mnemonic =
Bip39MnemonicGenerator().fromWordsNumber(Bip39WordsNum.wordsNum12);
/// Generate a seed from the mnemonic phrase with a specific passphrase.
final seed = Bip39SeedGenerator(mnemonic).generate("MRTNETWORK");
/// Define the cryptocurrency coins.
final solanaCoin = Bip44Coins.solana;
final tronCoin = Bip44Coins.tron;
final ethereumCoin = Bip44Coins.ethereum;
/// Derive the default derivation paths for Solana, Tron, and Ethereum.
final solanaDefaultPath = Bip44.fromSeed(seed, solanaCoin).deriveDefaultPath;
final tronDefaultPath = Bip44.fromSeed(seed, tronCoin).deriveDefaultPath;
final ethereumDefaultPath =
Bip44.fromSeed(seed, ethereumCoin).deriveDefaultPath;
/// Generate private keys for Solana, Tron, and Ethereum from their respective derivation paths.
final solanaPrivateKey =
SolanaPrivateKey.fromSeed(solanaDefaultPath.privateKey.raw);
final tronPrivateKey =
TronPrivateKey.fromBytes(tronDefaultPath.privateKey.raw);
final ethereumPrivateKey =
ETHPrivateKey.fromBytes(ethereumDefaultPath.privateKey.raw);
/// Cardano
/// Generate a mnemonic using 15 words
final mnemonic =
Bip39MnemonicGenerator().fromWordsNumber(Bip39WordsNum.wordsNum15);
/// Generate seeds for Cardano Icarus and legacy Byron wallets using the mnemonic
final seed = CardanoIcarusSeedGenerator(mnemonic.toStr()).generate();
final legacySeed =
CardanoByronLegacySeedGenerator(mnemonic.toStr()).generate();
/// Create a CIP-1852 object from the seed for Cardano Icarus
final cip1852 = Cip1852.fromSeed(seed, Cip1852Coins.cardanoIcarus);
/// Initialize Cardano Shelley from the CIP-1852 object
final shelly = CardanoShelley.fromCip1852Object(cip1852);
/// Extract private keys for payment and stake from the Shelley wallet
final payment = shelly.bip44.privateKey;
final stake = shelly.bip44Sk.privateKey;
/// Derive a BIP-44 wallet from the legacy seed for Cardano Byron Ledger
final bip44 = Bip44.fromSeed(legacySeed, Bip44Coins.cardanoByronLedger);
/// Create a Cardano Byron Legacy wallet from the legacy seed
final byron = CardanoByronLegacy.fromSeed(legacySeed);
Contributions are welcome! Please follow these guidelines:
- Fork the repository and create a new branch.
- Make your changes and ensure tests pass.
- Submit a pull request with a detailed description of your changes.
Please file feature requests and bugs in the issue tracker.