on_chain

Description:

on chain

ON CHAIN Dart Package #
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.
Features #
EVM Network #
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.


TVM Networks #
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.


Solana #
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


Cardano #
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



EXAMPLES #
Key and addresses #


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("...");
copied to clipboard


Transaction #


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));

copied to clipboard


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),
]));

copied to clipboard
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),
],
));
copied to clipboard


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));
copied to clipboard
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));
copied to clipboard


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));

copied to clipboard


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()));
copied to clipboard




EIP712 #


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();
copied to clipboard


Solana-Specific #
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;

copied to clipboard
JSON-RPC #


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.


copied to clipboard


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());
copied to clipboard


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")));
copied to clipboard


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"));
copied to clipboard




BIP-39, Addresses, and HD Wallet Key Management Process #
/// 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);

copied to clipboard
Contributing #
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.

Feature requests and bugs #
Please file feature requests and bugs in the issue tracker.