Flutter Algorand区块链交互插件algorand_dart的使用

Algorand是一个公共区块链和协议，旨在为所有参与者提供去中心化、规模和安全性。其PURE PROOF OF STAKE™共识机制确保了完全参与、保护和速度在一个真正去中心化的网络中。借助algorand_dart插件，您可以轻松地在Flutter应用中与Algorand区块链进行交互。

安装

首先，您需要在pubspec.yaml文件中添加algorand_dart依赖：

dependencies:
  algorand_dart: ^latest-version

注意：algorand-dart要求Dart >=2.12.0和null safety，请查看pub.dev获取最新版本。

初始化客户端

创建一个AlgodClient和IndexerClient并传递给Algorand构造函数。我们为本地托管节点和第三方服务（如PureStake）提供了额外的支持。

import 'package:algorand_dart/algorand_dart.dart';

final algodClient = AlgodClient(
    apiUrl: PureStake.TESTNET_ALGOD_API_URL,
    apiKey: 'your_api_key',
    tokenKey: PureStake.API_TOKEN_HEADER,
);

final indexerClient = IndexerClient(
    apiUrl: PureStake.TESTNET_INDEXER_API_URL,
    apiKey: 'your_api_key',
    tokenKey: PureStake.API_TOKEN_HEADER,
);

final algorand = Algorand(
    algodClient: algodClient,
    indexerClient: indexerClient,
);

发送支付

一旦安装完成，您可以简单地连接您的应用程序到区块链并开始发送支付：

final account = await algorand.createAccount();
final newAccount = await algorand.createAccount();

await algorand.sendPayment(
    account: account,
    recipient: newAccount.address,
    amount: Algo.toMicroAlgos(5),
    note: 'Hi from Flutter!',
);

如果您希望等待交易确认，可以使用waitForConfirmation参数：

final transactionId = await algorand.sendPayment(
    account: account,
    recipient: newAccount.address,
    amount: Algo.toMicroAlgos(5),
    note: 'Hi from Flutter!',
    waitForConfirmation: true,
    timeout: 3,
);

创建资产

创建一个新的资产同样简单：

final transactionId = await algorand.assetManager.createAsset(
    account: account,
    assetName: 'FlutterCoin',
    unitName: 'Flutter',
    totalAssets: 10000,
    decimals: 2,
);

或者使用TransactionBuilder来创建更具体的原始交易：

final params = await algorand.getSuggestedTransactionParams();

final transaction = await (AssetConfigTransactionBuilder()
      ..assetName = 'FlutterCoin'
      ..unitName = 'Flutter'
      ..totalAssetsToCreate = 10000
      ..decimals = 2
      ..defaultFrozen = false
      ..managerAddress = account.address
      ..reserveAddress = account.address
      ..freezeAddress = account.address
      ..clawbackAddress = account.address
      ..sender = account.address
      ..suggestedParams = params)
    .build();

final signedTransaction = await transaction.sign(account);

final txId = await algorand.sendTransaction(signedTransaction);

原子转移

原子转移意味着转移中的交易要么全部成功，要么全部失败。以下是创建原子转移的示例：

final params = await algorand.getSuggestedTransactionParams();

final transactionA = await (PaymentTransactionBuilder()
    ..sender = accountA.address
    ..note = 'Atomic transfer from account A to account B'
    ..amount = Algo.toMicroAlgos(1.2)
    ..receiver = accountB.address
    ..suggestedParams = params)
  .build();

final transactionB = await (PaymentTransactionBuilder()
    ..sender = accountB.address
    ..note = 'Atomic transfer from account B to account A'
    ..amount = Algo.toMicroAlgos(2)
    ..receiver = accountA.address
    ..suggestedParams = params)
  .build();

AtomicTransfer.group([transactionA, transactionB]);

final signedTxA = await transactionA.sign(accountA);
final signedTxB = await transactionB.sign(accountB);

final txId = await algorand.sendTransactions([signedTxA, signedTxB]);

账户管理

创建新账户

final account = await algorand.createAccount();

或者使用Account类：

final account = await Account.random();

提取公钥地址、签名密钥和助记词/种子短语：

final publicAddress = account.publicAddress;
final words = await account.seedPhrase;

加载现有账户

final account = await algorand.loadAccountFromSeed(seed);

恢复账户

final restoredAccount = await algorand.restoreAccount(['25-word-mnemonic']);

状态智能合约

合约账户

final arguments = <Uint8List>[];
arguments.add(Uint8List.fromList([123]));

final result =
    await algorand.applicationManager.compileTEAL(sampleArgsTeal);
final logicSig = LogicSignature.fromProgram(
  program: result.program,
  arguments: arguments,
);

final receiver =
    'KTFZ5SQU3AQ6UFYI2QOWF5X5XJTAFRHACWHXAZV6CPLNKS2KSGQWPT4ACE';
final params = await algorand.getSuggestedTransactionParams();
final transaction = await (PaymentTransactionBuilder()
      ..sender = logicSig.toAddress()
      ..note = 'Logic Signature'
      ..amount = 100000
      ..receiver = Address.fromAlgorandAddress(address: receiver)
      ..suggestedParams = params)
    .build();

final signedTx = await logicSig.signTransaction(transaction: transaction);

final txId = await algorand.sendTransaction(
  signedTx,
  waitForConfirmation: true,
);

账户委托

final arguments = <Uint8List>[];
arguments.add(Uint8List.fromList([123]));

final result =
    await algorand.applicationManager.compileTEAL(sampleArgsTeal);
final logicSig = await LogicSignature.fromProgram(
  program: result.program,
  arguments: arguments,
).sign(account: account);

final receiver =
    'KTFZ5SQU3AQ6UFYI2QOWF5X5XJTAFRHACWHXAZV6CPLNKS2KSGQWPT4ACE';
final params = await algorand.getSuggestedTransactionParams();
final transaction = await (PaymentTransactionBuilder()
      ..sender = account.address
      ..note = 'Account delegation'
      ..amount = 100000
      ..receiver = Address.fromAlgorandAddress(address: receiver)
      ..suggestedParams = params)
    .build();

final signedTx = await logicSig.signTransaction(transaction: transaction);

final txId = await algorand.sendTransaction(
  signedTx,
  waitForConfirmation: true,
);

多重签名

创建多重签名地址

final one = Address.fromAlgorandAddress(
  address: 'XMHLMNAVJIMAW2RHJXLXKKK4G3J3U6VONNO3BTAQYVDC3MHTGDP3J5OCRU',
);
final two = Address.fromAlgorandAddress(
  address: 'HTNOX33OCQI2JCOLZ2IRM3BC2WZ6JUILSLEORBPFI6W7GU5Q4ZW6LINHLA',
);

final three = Address.fromAlgorandAddress(
  address: 'E6JSNTY4PVCY3IRZ6XEDHEO6VIHCQ5KGXCIQKFQCMB2N6HXRY4IB43VSHI',
);

final publicKeys = [one, two, three]
    .map((address) => Ed25519PublicKey(bytes: address.publicKey))
    .toList();

final multiSigAddr =
    MultiSigAddress(version: 1, threshold: 2, publicKeys: publicKeys);

使用多重签名账户签署交易

final account1 = await Account.fromSeed(seed1);
final account2 = await Account.fromSeed(seed2);
final account3 = await Account.fromSeed(seed3);

final publicKeys = [account1, account2, account3]
    .map((account) => Ed25519PublicKey(bytes: account.address.publicKey))
    .toList();

final msa =
    MultiSigAddress(version: 1, threshold: 2, publicKeys: publicKeys);

final params = await algorand.getSuggestedTransactionParams();
final transaction = await (PaymentTransactionBuilder()
      ..sender = msa.toAddress()
      ..note = 'MSA '
      ..amount = 1000000
      ..receiver = account3.address
      ..suggestedParams = params)
    .build();

final signedTx = await msa.sign(
  account: account1,
  transaction: transaction,
);

final completeTx = await msa.append(
  account: account2,
  transaction: signedTx,
);

final txId = await algorand.sendTransaction(
  completeTx,
  waitForConfirmation: true,
);