1. 缩进要求

• 每级缩进使用 4 个空格。

• 不推荐使用制表符（Tab）。

2. 空行使用规则

• 顶层声明之间（如 transition、function、struct、record 和 mapping）需要用单个空行分隔。

• import 语句之间可以选择性地使用单个空行分隔。

• 文件顶部的最后一个 import 语句后应该跟一个空行。

3. 文件结构顺序

按照以下顺序组织文件内容：

1. 导入语句（Imports）

2. 程序声明（Program declaration）

3. 映射（Mappings）

4. 记录和结构体（Records + Structs）

5. 函数和转换（Functions + Transitions）

二、命名规范

各类型命名方式如下：

• 包名：使用 snake_case（推荐使用单个词）。

• 结构体和记录：使用 CamelCase。

• 结构体和记录成员：使用 snake_case。

• 函数名：使用 snake_case。

• 函数参数：使用 snake_case。

• 变量名：使用 snake_case。

• 输入参数：使用 snake_case。

三、语法规范

1. 大括号使用

• 开括号总是与声明在同一行，不要将开括号放在新行。

2. 分号使用

• 每个语句（包括 return 语句）都必须以分号结束，保持语句结束的一致性。

3. 逗号使用

• 当结束定界符出现在单独一行时，应包含尾随逗号，以提高代码的可维护性和可读性。

四、条件分支处理

推荐做法

• 使用三元表达式而不是 if-else 语句，可以更好地控制电路大小和效率。

原因解释

• Leo 编译器会将 transitions 中的 if-else 语句重写为三元表达式序列，因为底层电路构造不支持分支操作。

• 三元表达式是最经济的条件形式，可以在评估条件之前解析第一个和第二个表达式的值。

性能影响

• 使用 if-else 会导致电路创建分支，每个分支都需要完整评估，条件内的每个计算成本都会翻倍。这会显著增加约束数量并降低电路效率。

代码示例

• 不推荐：

  if (condition) {
      return a;
  } else {
      return b;
  }
  

• 推荐：

  return condition ? a : b;
  

五、最佳实践建议

1. 代码组织

• 保持代码结构清晰，遵循文件元素的标准顺序，使用一致的命名约定。

2. 性能优化

• 优先使用三元表达式，避免不必要的条件分支，注意控制电路大小。

3. 可维护性

• 保持代码格式的一致性，适当使用空行增加可读性，遵循标准的命名规范。

这些规范和最佳实践可以帮助开发者编写更高效、更易维护的 Leo 代码，同时确保生成的电路具有最佳性能。

• Aleo Twitter

• Aleo Discord

• Aleo 官网

介绍

Spruce DID Kit 是一个功能强大的工具包，旨在帮助开发者构建和管理去中心化身份（Decentralized Identity）。它是 SpruceKit 生态系统的一部分，专注于实现和管理符合 W3C 标准的可验证凭证（Verifiable Credentials，VC）和去中心化标识符（Decentralized Identifiers，DID）。通过使用 Spruce DID Kit，开发者可以轻松地创建、签署、验证和管理数字身份和凭证，确保身份数据的安全性和隐私性。

主要功能和组件

1. DIDKit: 这是 Spruce DID Kit 的核心库之一，提供了处理 W3C 可验证凭证和去中心化标识符的工具。DIDKit 支持各种数据模型和协议，帮助开发者实现标准化的身份管理解决方案。

2. TreeLDR: 一种模式定义语言，用于描述模式的结构和语义。它连接了 RDF（资源描述框架）与结构化模式框架（如 JSON Schema），提供了更丰富的数据描述能力。

3. Rebase: 这个库用于处理加密可验证的声明，并基于这些声明发行可验证凭证（VC）。它确保了声明的真实性和可信性，是身份验证流程的关键部分。

4. 以太坊登录: 这一功能允许用户使用其以太坊账户和 ENS（以太坊名称服务）配置文件来控制他们的数字身份。它提供了一种新的身份验证方法，增强了用户对其数字身份的控制。

使用场景

Spruce DID Kit 可用于多个场景，包括但不限于：

• 数字身份验证：创建和验证用户的数字身份，确保用户数据的真实性和隐私性。

• 身份钱包构建：开发支持可验证凭证的数字钱包，用户可以在这些钱包中存储和管理其身份数据。

• 现有系统增强：将可验证凭证功能集成到现有的身份管理系统或钱包中，提升系统的安全性和功能性。

快速入门指南

本教程将带你了解如何使用 SpruceID 工具，重点讲解使用 DIDKit CLI 程序进行凭证发行和验证的基础知识。

第0步：安装 DIDKit

要在GNU/Linux、MacOS或Windows+WSL上安装DIDKit命令行程序，首先需要安装Cargo。

cargo install didkit-cli

这将会把 didkit 二进制文件添加到你的 Cargo 安装路径中，通常位于 ~/.cargo/bin，你可以将其添加到系统的PATH中以方便使用。

第1步：使用 DID 发行和验证你的第一个可验证凭证（VC）

生成 did-key DID要发行你的第一个凭证，你需要一个签名密钥。使用DIDKit生成一个Ed25519私钥，并使用did-key DID方法创建一个DID：

didkit generate-ed25519-key > issuer_key.jwk
issuer_did=$(didkit key-to-did key -k issuer_key.jwk)
echo $issuer_did

在准备好签名密钥及其DID后，指定要签名的可验证凭证（VC）的JSON格式：

cat > unsigned-vc.json << EOF
{
    "@context": "https://www.w3.org/2018/credentials/v1",
    "id": "urn:uuid:$(uuidgen)",
    "type": ["VerifiableCredential"],
    "issuer": "${issuer_did}",
    "issuanceDate": "$(date -u +%FT%TZ)",
    "credentialSubject": {
        "id": "did:example:my-data-subject-identifier"
    }
}
EOF

@context 属性表明这个JSON对象是一个W3C可验证凭证。id 属性是这个VC的标识符。type 属性识别这个VC为一个基本数据模型。issuer 属性包含发行者的URI（即之前生成的did-key），issuanceDate 表示发行时间（当前UTC时间）。credentialSubject 包含实际的声明。

签署VC要使用DIDKit CLI签署VC，指定签名密钥的路径、验证方法（-v）、证明目的（-p）和未签名的凭证：

vm=$(didkit key-to-verification-method key --key-path issuer_key.jwk)
didkit vc-issue-credential --key-path issuer_key.jwk \
                           -v "${vm}" -p assertionMethod \
                           < unsigned-vc.json > signed-vc.json
cat signed-vc.json

这将生成一个已签名的VC。验证已签名的VC：

didkit vc-verify-credential < signed-vc.json

确保没有出现任何检查失败、警告或错误。为了验证，修改 signed-vc.json 的内容，然后再次验证它以查看验证失败的情况。

第2步：验证由did-web发行的VC

要验证来自Spruce演示服务器的VC：

curl https://demo.spruceid.com/get-example-vc > example-vc.json

example-vc.json 应该类似于：

{
  "@context": ["https://www.w3.org/2018/credentials/v1"],
  "type": "VerifiableCredential",
  "credentialSubject": {},
  "issuer": "did:web:demo.spruceid.com",
  "issuanceDate": "2021-09-13T18:23:56Z",
  "proof": {
    "type": "Ed25519Signature2018",
    "proofPurpose": "assertionMethod",
    "verificationMethod": "did:web:demo.spruceid.com#_t-v-Ep7AtkELhhvAzCCDzy1O5Bn_z1CVFv9yiRXdHY",
    "created": "2021-09-13T18:23:56.483Z",
    "jws": "eyJhbGciOiJFZERTQSIsImNyaXQiOlsiYjY0Il0sImI2NCI6ZmFsc2V9..X5J2jI5j3TPqFO_g6XOlB730WlXJ8mDsfoyLQ4u60MelVosi1Et6V_pB7-zELDggdqZTsKQjSqDodv0m7ui1Bg"
  },
  "expirationDate": "2021-10-13T18:23:56Z"
}

验证VC：

didkit vc-verify-credential -p assertionMethod < example-vc.json

确保没有出现任何检查失败、警告或错误。修改 example-vc.json 的内容，然后再次验证它以查看验证失败的情况。要直接解析did-web DID：

didkit did-resolve did:web:demo.spruceid.com

更多信息请访问：

https://www.sprucekit.dev

总结

通过前面的简单学习，你已经学习了使用did-key DID发行可验证凭证（VC），并验证它以及通过did-web DID发行的VC的整个过程。通过SpruceKit和DIDKit，你拥有了构建和验证去中心化身份解决方案的强大工具。这只是一个开始，在SpruceID生态系统中还有许多功能和能力等待你探索。一起加油！

• Aleo Twitter

• Aleo Discord

• Aleo 官网

背景

在现代区块链应用中，资产管理和交易安全性成为了关键问题，尤其是在需要多人共同管理或决策的情况下。传统的单签名（Single-Signature）模式，虽然简单易用，但存在单点故障的风险。为了增强安全性和分散控制权，区块链引入了多签名合约（Multi-signature contract）机制。多签合约允许一个钱包或账户的资产由多个参与者共同管理，只有在达到预设的签名阈值时，交易才能被执行。

这里我们要学习的一个 Aleo 的多签合约 Coffer multisig wallet 正是一个实现了多签名功能的智能合约。这种合约设计适合那些需要多方共同参与决策的场景，例如企业财务管理、去中心化自治组织（DAO）或需要高安全性的个人账户管理。

作用

Coffer multisig wallet 多签合约在以下方面具有自己的优势：

1. 安全性提升：

   • 合约定义了多个持有者（最多可以有9个），这些持有者共同管理同一个钱包（WalletInfo结构体表示）。只有在达到预设的签名数量（阈值）时，交易才会被执行。这有效防止了单点失误或恶意操作导致的资金丢失。

2. 灵活的资产管理：

   • 该合约允许在多名持有者之间创建并管理钱包账户，支持复杂的资金管理操作。每个钱包可以持有多种代币，并且支持代币的存入、转出和转移操作。通过create_wallet3、create_transfer3、confirm_transfer、reject_transfer等多个操作函数，合约实现了完整的资产管理流程。

3. 透明的交易流程：

   • 合约中的每一步操作都被记录在链上，确保了所有持有者都能透明地看到每一笔交易的状态。例如，create_transfer3创建一笔待确认的转账，之后的confirm_transfer和reject_transfer函数让持有者们对这笔交易进行确认或拒绝，只有当确认数达到阈值时，交易才会通过execute_confirmed_transfer执行。

4. 去中心化控制：

   • 多签合约分散了资产的控制权，使得单一持有者无法单独进行敏感操作，必须通过集体决策。这种去中心化的控制方式，特别适合于需要多人共同参与决策的组织或项目，确保了管理的公平性和公正性。

综上， Coffer multisig wallet 合约在多签的实现上提供了强大的安全性和管理功能，适用于需要多人共同管理的场景，有效地解决了传统单签名模式中的风险问题。

现在我们开始一起学习 Aleo 伤的这个多签合约（大部分关键代码已给出注释）。

实现

钱包相关结构体与记录定义

    struct WalletInfo {
        wallet_id: field,   // 钱包ID，唯一标识钱包

        holder1: address,   // 持有者1的地址
        holder2: address,   // 持有者2的地址
        holder3: address,   // 持有者3的地址
        holder4: address,   // 持有者4的地址（可选）
        holder5: address,   // 持有者5的地址（可选）
        holder6: address,   // 持有者6的地址（可选）
        holder7: address,   // 持有者7的地址（可选）
        holder8: address,   // 持有者8的地址（可选）
        holder9: address,   // 持有者9的地址（可选）

        holder_count: u8,   // 持有者数量
        threshold: u8       // 批准转账所需的最少确认数
    }

    record WalletHolder {
        owner: address,     // 钱包持有者的地址
        owner_id: u8,       // 持有者ID
        wallet: WalletInfo, // 钱包的基本信息
    }

    record PendingTransfer {
        owner: address,     // 转账请求的持有者
        transfer_id: field, // 转账ID
        creator: address,   // 转账创建者
        wallet: WalletInfo, // 与转账相关的钱包信息
        token_id: u64,      // 代币ID
        amount: u128,       // 转账金额
        to_address: address, // 接收方地址
        to_wallet_id: field, // 接收方钱包ID
    }

    record SignedTransfer {
        owner: address,     // 签名转账的持有者
        transfer_id: field, // 转账ID
        creator: address,   // 转账创建者
        wallet: WalletInfo, // 与转账相关的钱包信息
        token_id: u64,      // 代币ID
        amount: u128,       // 转账金额
        to_address: address, // 接收方地址
        to_wallet_id: field, // 接收方钱包ID
        confirmed: bool,    // 是否确认（true为确认，false为拒绝）
    }

    struct WalletBalanceKey {
        wallet_id: field,   // 钱包ID
        token_id: u64       // 代币ID
    }

    struct TransferStatus {
        confirmation_count: u8, // 已确认的次数
        rejection_count: u8,    // 已拒绝的次数
        status: u8,             // 转账状态（0-创建，1-执行，2-拒绝）
    }

映射 (Mappings)

    mapping wallet_exists: field => bool; // 用于检查钱包是否存在

    mapping wallet_balances: field => u128; // 用于存储钱包的代币余额

    mapping transfers: field => TransferStatus; // 用于存储转账状态

Transition Functions (过渡函数)

    transition create_wallet3(owner1: address, owner2: address, owner3: address, threshold: u8, wallet_id: field) -> (WalletHolder, WalletHolder, WalletHolder) {
        let holder_count: u8 = 3u8; // 定义持有者数量为3
        let zero_address: address = aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc; // 定义占位符地址

        assert (threshold > 0u8 && threshold <= holder_count); // 确保阈值在有效范围内
        assert (owner1 != owner2); // 确保持有者1和持有者2地址不相同

        let wallet_info: WalletInfo = WalletInfo {
            wallet_id: wallet_id,
            holder1: owner1,
            holder2: owner2,
            holder3: owner3,
            holder4: zero_address,
            holder5: zero_address,
            holder6: zero_address,
            holder7: zero_address,
            holder8: zero_address,
            holder9: zero_address,
            holder_count: holder_count,
            threshold: threshold
        }; // 创建一个包含三个持有者的钱包信息

        let wallet_holder1: WalletHolder = WalletHolder {
            owner: owner1,
            owner_id: 1u8,
            wallet: wallet_info
        }; // 创建第一个钱包持有者

        let wallet_holder2: WalletHolder = WalletHolder {
            owner: owner2,
            owner_id: 2u8,
            wallet: wallet_info
        }; // 创建第二个钱包持有者

        let wallet_holder3: WalletHolder = WalletHolder {
            owner: owner3,
            owner_id: 3u8,
            wallet: wallet_info
        }; // 创建第三个钱包持有者

        return (wallet_holder1, wallet_holder2, wallet_holder3) then finalize(wallet_id); // 返回钱包持有者记录并调用 finalize 函数
    }

    finalize create_wallet3(wallet_id: field) {
        assert(!Mapping::get_or_use(wallet_exists, wallet_id, false)); // 确保钱包ID唯一
        Mapping::set(wallet_exists, wallet_id, true); // 标记钱包为已存在
    }

    transition create_transfer3(wallet_holder: WalletHolder, token_id: u64, amount: u128, to_address: address, to_wallet_id: field, transfer_id: field) -> (WalletHolder, PendingTransfer, PendingTransfer, PendingTransfer) {
        let holder_count: u8 = 3u8;
        let zero_address: address = aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc;

        assert(wallet_holder.wallet.holder_count == holder_count); // 确保持有者数量为3
        assert(to_address == zero_address || to_wallet_id == 0field); // 确保转账目标仅为地址或钱包ID之一

        let pending1: PendingTransfer = PendingTransfer {
            owner: wallet_holder.wallet.holder1,
            transfer_id: transfer_id,
            creator: wallet_holder.owner,
            wallet: wallet_holder.wallet,
            token_id: token_id,
            amount: amount,
            to_address: to_address,
            to_wallet_id: to_wallet_id
        }; // 为持有者1创建待处理转账

        let pending2: PendingTransfer = PendingTransfer {
            owner: wallet_holder.wallet.holder2,
            transfer_id: transfer_id,
            creator: wallet_holder.owner,
            wallet: wallet_holder.wallet,
            token_id: token_id,
            amount: amount,
            to_address: to_address,
            to_wallet_id: to_wallet_id
        }; // 为持有者2创建待处理转账

        let pending3: PendingTransfer = PendingTransfer {
            owner: wallet_holder.wallet.holder3,
            transfer_id: transfer_id,
            creator: wallet_holder.owner,
            wallet: wallet_holder.wallet,
            token_id: token_id,
            amount: amount,
            to_address: to_address,
            to_wallet_id: to_wallet_id
        }; // 为持有者3创建待处理转账

        let new_wallet_holder: WalletHolder = WalletHolder {
            owner: wallet_holder.owner,
            owner_id: wallet_holder.owner_id,
            wallet: wallet_holder.wallet
        }; // 创建更新后的钱包持有者

        return (new_wallet_holder, pending1, pending2, pending3) then finalize(transfer_id); // 返回更新后的钱包持有者和待处理转账记录并调用 finalize
    }

    finalize create_transfer3(transfer_id: field) {
        assert(!Mapping::contains(transfers, transfer_id)); // 确保转账ID唯一
        Mapping::set(transfers, transfer_id, TransferStatus {
            confirmation_count: 1u8,
            rejection_count: 0u8,
            status: 0u8,
        }); // 初始化转账状态
    }

    transition confirm_transfer(pending_transfer: PendingTransfer) -> SignedTransfer {
        let signed: SignedTransfer = SignedTransfer {
            owner: pending_transfer.owner,
            transfer_id: pending_transfer.transfer_id,
            creator: pending_transfer.creator,
            wallet: pending_transfer.wallet,
            token_id: pending_transfer.token_id,
            amount: pending_transfer.amount,
            to_address: pending_transfer.to_address,
            to_wallet_id: pending_transfer.to_wallet_id,
            confirmed: true
        }; // 创建一个签名的转账记录

        return (signed) then finalize(pending_transfer.transfer_id); // 返回签名记录并调用 finalize
    }

    finalize confirm_transfer(transfer_id: field) {
        let transfer_status: TransferStatus = Mapping::get(transfers, transfer_id);

        Mapping::set(transfers, transfer_id, TransferStatus {
                        confirmation_count: transfer_status.confirmation_count + 1u8, // 增加确认次数
            rejection_count: transfer_status.rejection_count, // 保持拒绝次数不变
            status: transfer_status.status // 保持当前转账状态不变
        });
    }

    transition reject_transfer(pending_transfer: PendingTransfer) -> SignedTransfer {
        let signed: SignedTransfer = SignedTransfer {
            owner: pending_transfer.owner,
            transfer_id: pending_transfer.transfer_id,
            creator: pending_transfer.creator,
            wallet: pending_transfer.wallet,
            token_id: pending_transfer.token_id,
            amount: pending_transfer.amount,
            to_address: pending_transfer.to_address,
            to_wallet_id: pending_transfer.to_wallet_id,
            confirmed: false // 将转账标记为拒绝
        };

        return (signed) then finalize(pending_transfer.transfer_id); // 返回已拒绝的签名记录并调用 finalize
    }

    finalize reject_transfer(transfer_id: field) {
        let transfer_status: TransferStatus = Mapping::get(transfers, transfer_id);
        Mapping::set(transfers, transfer_id, TransferStatus {
            confirmation_count: transfer_status.confirmation_count, // 保持确认次数不变
            rejection_count: transfer_status.rejection_count + 1u8, // 增加拒绝次数
            status: transfer_status.status // 保持当前转账状态不变
        });
    }

    transition execute_confirmed_transfer(signed_transfer: SignedTransfer) -> (SignedTransfer, Token) {
        let zero_address: address = aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc;
        assert(signed_transfer.to_wallet_id == 0field || signed_transfer.to_address == zero_address); // 确保目标为有效的地址或钱包

        let token: Token = Token {
            owner: signed_transfer.to_address, // 生成新的 Token 对象
            amount: signed_transfer.to_wallet_id == 0field ? signed_transfer.amount : 0u128, // 如果目标是地址，设置金额
            token_id: signed_transfer.token_id
        };
        let to_wallet_balance_key: field = signed_transfer.to_wallet_id == 0field ? 0field : get_wallet_balance_key(token.token_id, signed_transfer.to_wallet_id); // 生成目标钱包的余额密钥

        let new_signed: SignedTransfer = SignedTransfer {
            owner: signed_transfer.owner,
            transfer_id: signed_transfer.transfer_id,
            creator: signed_transfer.creator,
            wallet: signed_transfer.wallet,
            token_id: signed_transfer.token_id,
            amount: signed_transfer.amount,
            to_address: signed_transfer.to_address,
            to_wallet_id: signed_transfer.to_wallet_id,
            confirmed: signed_transfer.confirmed
        };
        return (new_signed, token) then finalize(signed_transfer.transfer_id, signed_transfer.wallet.threshold, get_wallet_balance_key(token.token_id, signed_transfer.wallet.wallet_id), signed_transfer.amount, to_wallet_balance_key); // 返回更新后的签名记录和 Token 对象，并调用 finalize
    }

    finalize execute_confirmed_transfer(transfer_id: field, wallet_threshold: u8, wallet_balance_key: field, amount: u128, to_wallet_balance_key: field) {
        let transfer_status: TransferStatus = Mapping::get(transfers, transfer_id);
        assert(transfer_status.status == 0u8); // 确保转账尚未执行
        assert(transfer_status.confirmation_count >= wallet_threshold); // 确保达到确认阈值

        let balance: u128 = Mapping::get(wallet_balances, wallet_balance_key);
        Mapping::set(wallet_balances, wallet_balance_key, balance - amount); // 从钱包余额中扣除转账金额

        if (to_wallet_balance_key == 0field) {
            // 如果目标是地址，代币已经在 transition 中生成，无需进一步处理
        } else {
            let to_balance: u128 = Mapping::get_or_use(wallet_balances, to_wallet_balance_key, 0u128);
            Mapping::set(wallet_balances, to_wallet_balance_key, to_balance + amount); // 如果目标是钱包，增加目标钱包的余额
        }

        Mapping::set(transfers, transfer_id, TransferStatus { 
            confirmation_count: transfer_status.confirmation_count,
            rejection_count: transfer_status.rejection_count,
            status: 1u8 // 更新转账状态为已执行
        });
    }

    transition deposit(token: Token, amount: u128, wallet_id: field) -> (Token) {
        let change: Token = Token {
            owner: token.owner,
            amount: token.amount - amount, // 计算剩余代币
            token_id: token.token_id,
        };

        return (change) then finalize(wallet_id, get_wallet_balance_key(token.token_id, wallet_id), amount); // 返回剩余代币并调用 finalize
    }

    finalize deposit(wallet_id: field, wallet_balance_key: field, amount: u128) {
        assert (Mapping::contains(wallet_exists, wallet_id)); // 确保钱包存在

        let balance: u128 = Mapping::get_or_use(wallet_balances, wallet_balance_key, 0u128);
        Mapping::set(wallet_balances, wallet_balance_key, balance + amount); // 增加钱包的余额
    }

    inline get_wallet_balance_key(token_id: u64, wallet_id: field) -> field {
        return BHP256::hash_to_field(WalletBalanceKey {token_id: token_id, wallet_id: wallet_id}); // 生成钱包余额的哈希密钥
    }

代币相关结构体与记录定义

    // ██████████████████████████████████████████████████████████████████████
    //                                 Tokens
    // ██████████████████████████████████████████████████████████████████████

    record Token {
        owner: address,  // 代币的持有者地址
        amount: u128,    // 代币的数量
        token_id: u64,   // 代币的ID
    }

    struct TokenInfo {
        token_id: u64,   // 代币的ID
        max_supply: u128, // 代币的最大供应量
        decimals: u8,    // 代币的小数位数
    }

    mapping registered_tokens: u64 => TokenInfo; // 存储已注册的代币信息

    transition create_token(token_id: u64, decimals: u8, max_supply: u128) {
        let new_token: TokenInfo = TokenInfo{
            token_id,
            decimals,
            max_supply,
        }; // 创建新的代币信息

        return then finalize(new_token); // 返回代币信息并调用 finalize
    }

    finalize create_token(new_token: TokenInfo) {
        assert(!Mapping::contains(registered_tokens, new_token.token_id)); // 确保代币ID唯一
        Mapping::set(registered_tokens, new_token.token_id, new_token);    // 将新代币信息存储到映射中
    }

    transition mint_private(
        receiver: address, 
        token_id: u64, 
        amount: u128,
    ) -> Token {
        assert(amount <= 1000u128 * (10u128 ** 6u8)); // 确保铸造的代币数量不超过限制
        return Token {
            owner: receiver,
            amount: amount,
            token_id,
        } then finalize(token_id);  // 返回铸造的代币并调用 finalize
    }

    finalize mint_private(token_id: u64) {
        let token_info: TokenInfo = Mapping::get(registered_tokens, token_id); // 获取代币信息（此处没有具体操作，可根据需求扩展）
    }

}

代码总结

• 该智能合约用于管理钱包和代币的创建、转账、存储及相关操作。

• WalletInfo 和 WalletHolder 定义了钱包的基本信息和持有者的结构。

• PendingTransfer 和 SignedTransfer 用于表示和管理转账的不同状态。

• 映射（Mappings）用于存储钱包是否存在、钱包的余额及转账的状态等。

• 过渡函数（Transition Functions）实现了钱包的创建、转账的确认与拒绝、代币的创建与铸造等核心功能。

• 最后，finalize 用于确保每个操作的状态正确更新。

通过这些结构和功能，该智能合约能够实现一个多签名钱包系统，其中持有者们可以通过共同投票决定是否执行某笔转账。这些功能可以扩展到更复杂的金融应用场景中。我们从中也可以学习如何编写一个多签合约的思路，并且理解和掌握 Leo 这门编程语言。

• Aleo Twitter

• Aleo Discord

• Aleo 官网

简介

ZK Gaming SDK 是一个用于与 Aleo 零知识平台交互的游戏开发 API。它为开发者提供了丰富的工具和接口，使得在 Aleo 区块链上构建去中心化游戏变得更加容易。

你可以查看 Boloney，这是第一个使用 ZK Gaming Toolkit 构建的游戏。

开始使用

运行 API 主要有两种方式：本地运行或在隔离的 Minikube 容器中运行。

本地运行

在本地运行 API 之前，请确保已安装以下软件：

• Node.js 版本 18.16.0 LTS

• Yarn

• Aleo

• Leo

• SnarkOS

• Aleo 开发服务器 - 运行 cargo install aleo-development-server

首先启动本地 SnarkOS 信标节点：

snarkos start --nodisplay --dev 0 --beacon "APrivateKey1zkp8CZNn3yeCseEtxuVPbDCwSyhGW6yZKUYKfgXmcpoGPWH"

⚠️ 请不要更改私钥，因为应用程序在开发过程中是配置为使用此私钥的。

然后，在另一个终端窗口中启动 Aleo 开发服务器：

aleo-develop start -p http://127.0.0.1:3030

⚠️ 请确保指定该本地地址。如果未指定地址，开发服务器将连接到公共测试网，而在开发过程中通常不希望这样做。

接着，本地构建所有程序：

./build_local_programs.sh

首次运行 API 时，请确保同时部署这些程序：

DEPLOY_PROGRAMS=true DEPLOY_PRIVATE_KEY=APrivateKey1zkp8CZNn3yeCseEtxuVPbDCwSyhGW6yZKUYKfgXmcpoGPWH yarn start

注意查看应用程序和开发服务器的日志。

所有程序成功部署到网络后，API 应可在 http://localhost:5001 访问。

如果没有重置网络，以后本地运行 API 时，只需运行：

yarn start

如果你希望重置网络，可以先停止信标进程，然后运行：

snarkos clean --dev 0

⚠️ 重置本地网络后，你将需要重新部署程序。

使用 Minikube 运行

⚠️ 除非你在进行部署或确实了解自己在做什么，否则强烈建议不要使用此方法。通过 Minikube 运行 API 时，应用程序将连接到公共测试网，这对于开发来说并不理想。

在使用 Minikube 运行 API 之前，请确保已安装以下软件：

• Docker

• kubectl

• Minikube - 仅执行“安装”部分的第一步

• Skaffold

在运行 Minikube 之前，确保 Docker 正在运行。如果你使用 MacOS，请确保给 Docker 分配至少 8GB 的内存和至少 50GB 的虚拟磁盘空间。可以通过打开 Docker Desktop -> 设置（右上角）-> 资源进行配置。

启动 Minikube：

minikube start --cpus=max --memory=max

启用 Ingress 插件：

minikube addons enable ingress

在新的终端标签中运行：

这将允许你在后台运行时访问部署的应用程序。

回到第一个终端标签并运行：

skaffold run

这将构建 API 并将其部署到 Minikube 集群中。

要检查 Pod 的状态，运行：

kubectl -n zk-gaming-tk-local get pods

要查看日志，运行：

# pod_name 可从上一步命令的输出中获取
kubectl -n zk-gaming-tk-local logs <pod_name> -f

如果 Pod 正常运行，API 应可在 http://zk-gaming-tk.localhost 访问。

⚠️ 在 MacOS 上，可能需要配置 dnsmasq 以访问自定义域名。可以参考 此指南，并使用 .localhost 替代 .test 和 .box。

提交 PR

⚠️ 这些步骤只能由有钱包访问权限的维护人员完成。

如果 PR 包含对 Leo 程序的任何更改，请在合并之前确保执行以下操作，以便正确地将程序部署到测试网：

1. 前往 此处 并给 Kryha Aleo 账户添加一些积分。

2. 等待交易完成。请勿关闭浏览器标签页！

3. 完成 PR，流水线应会自动将新程序部署到测试网上。请耐心等待……部署时间约为每个程序 8 分钟。

添加新 Leo 程序

创建新 Leo 程序时，需要更新流水线，以便程序正确部署到测试网。

假设程序名称为 cool_program，要正确部署，打开 azure-pipelines.yaml 并在 run_check_script 作业中添加以下内容：

files=$(git diff HEAD HEAD~ --name-only)

while IFS= read -r name; do
    # 之前的 case 省略
    ...
    elif [[ $name =~ ^contracts/cool_program/* ]]; then
        echo "##vso[task.setvariable variable=coolProgramUpdated;isoutput=true]True"
    fi
done <<<"$files"

接着，在 build_and_deploy_leo_programs_stage 中定义新变量：

variables:
    # 之前的变量省略
    ...
    coolProgramUpdated: $[stageDependencies.check_updated_programs.run_check_script.outputs['UpdatedPrograms.coolProgramUpdated']]

在 build_and_deploy_leo_programs_job 作业中，所有之前定义的步骤之后，添加以下新步骤：

- script: |
    docker build -f Dockerfile.program . \
      --build-arg APP_NAME=cool_program \
      --build-arg PRIVATE_KEY=$(privateKey) \
      --build-arg BUILD_ID=$(buildId) \
      --build-arg FEE=600000 \
      --build-arg ZK_GAMING_ALEO="eu.gcr.io/web3-335312/aleo/zk-gaming-snarkos:latest"
  displayName: Cool Program Docker build
  condition: and(succeeded(), eq(variables['coolProgramUpdated'], 'True'))
  retryCountOnTaskFailure: 3
- script: echo "##vso[task.setvariable variable=coolProgramVersion;isoutput=true]$(buildId)"
  displayName: Update Cool Program version locally
  condition: and(succeeded(), eq(variables['coolProgramUpdated'], 'True'))
- script: |
    az pipelines variable-group variable update \
      --group-id $(aleoProgramIdsGroupId) \
      --name coolProgramVersion \
      --org $(devOpsOrg) \
      --project $(devOpsProject) \
      --value $(buildId)
  displayName: Update Cool Program version in variable group
  condition: and(succeeded(), eq(variables['coolProgramUpdated'], 'True'))
  env:
    SYSTEM_ACCESSTOKEN: $(System.AccessToken)

变量版本需要添加到流水线变量组。为此，请联系 marius@kryha.io。

更新 Leo 和 SnarkOS 版本

由于 Leo 和 SnarkOS 目前处于活跃开发中，有些更改可能会破坏构建，因此我们在 Dockerfile.snarkos 中手动设置了与工具包正确配合使用的最新版本的提交哈希。如果你希望更新到新版本，应执行以下步骤：

1. git pull 最新的 Leo 或 SnarkOS 代码，并运行 cargo install --path . 在本地安装新版本。

2. 确保程序使用更新后的 CLI 工具正确构建和运行。

3. 使用 yarn start 在本地运行工具包，并确保端点按预期工作。

4. 在 Leo 或 SnarkOS 仓库中运行 git log 并复制 HEAD 提交哈希。

5. 打开 Dockerfile.snarkos 并将提交哈希设置为复制的值。

6. 通过 skaffold run 运行工具包，并确保其正常工作。

总结

通过这篇教程，我们已经了解了如何在本地和 Minikube 环境中运行 ZK Gaming Toolkit，如何设置开发环境，以及如何添加和部署新的 Leo 程序。ZK Gaming Toolkit 为开发者提供了强大的工具，使得在 Aleo 区块链上构建去中心化应用和游戏变得更加简便和高效。

• Aleo Twitter

• Aleo Discord

• Aleo 官网

简介

AleoJS 是一个为 Aleo 区块链开发的轻量级库，旨在简化开发者与 Aleo 生态系统的交互。它通过提供一系列工具和接口，让开发者可以更方便地在 Aleo 区块链上构建、测试和部署去中心化应用（dApps）。AleoJS 借鉴了 zk-gaming-toolkit 的灵感，同时为开发者提供了更加友好的编程体验。

主要特点包括：

1. 简化开发流程：通过提供命令行工具和自动化的项目结构，开发者可以快速启动和管理 Aleo 项目。

2. 支持多种网络：AleoJS 支持测试网和主网等多种网络，方便开发者在不同环境中测试和部署应用。

3. 自动生成类型：在编译过程中，AleoJS 会自动生成 Leo 和 JavaScript 类型，简化了智能合约与前端应用之间的数据交互。

4. 强大的测试支持：AleoJS 提供了丰富的测试框架，帮助开发者验证智能合约的正确性和稳定性。

安装

在开始之前，请确保您已经设置了以下环境：

1. Rust：安装指南

2. SnarkOS：安装指南

3. Leo语言：安装指南

通过 NPM 安装

您可以通过 npm 全局安装 Aleo.js：

npm install -g @aleojs/cli@latest

从源码安装

如果尚未设置 pnpm，请参考 pnpm 安装指南。

# 下载源码
git clone https://github.com/venture23-zkp/aleojs

cd aleojs

# 安装依赖项
pnpm install

# 构建项目
npm run build

# 安装 aleojs
npm run install:cli

使用方法

安装完成后，您可以通过以下命令使用 AleoJS：

aleojs-cli-dev

安装成功的输出如下：

_    _                _ ____
/ \  | | ___  ___     | / ___|
/ _ \ | |/ _ \/ _ \ _  | \___ \
/ ___ \| |  __/ (_) | |_| |___) |
/_/   \_\_|\___|\___/ \___/|____/
Usage: aleojs-cli-dev [options] [command]

AleoJS CLI

Options:
  -h, --help                       显示帮助信息
  -V, --version                    输出版本号

Commands:
  init [options] <project-name>    初始化您的 AleoJS 项目
  add <program-name>               添加新组件或资源
  compile                          编译您的 AleoJS 项目
  unflatten                        为程序生成leo构建文件
  autogen                          为合约生成ts类型（仅在生成构建后使用）
  start [options] <node>           运行您的 AleoJS 项目
  run [options] <file>             运行文件
  deploy [options] <program-name>  部署程序
  execute <file-path>              执行脚本
  help [command]                   显示帮助信息

初始化新项目

通过指定项目名称来初始化一个新项目：

aleojs-cli-dev init <PROJECT_NAME>

例如，我们可以创建一个名为 token 的新项目。

这将自动为项目安装依赖项。

在项目初始化完成后，AleoJS 将生成以下目录结构：

├── contract
│   └── base-contract.ts
├── node_modules/
├── programs
│   ├── sample_program.leo
│   └── token.leo
├── scripts
│   └── deploy.ts
├── test
│   ├── sample_program.test.ts
│   └── token.test.ts
├── .env
├── .gitignore
├── aleo-config.js
├── babel.config.json
├── jest.config.json
├── package-lock.json
├── package.json
├── README.md
├── node_modules/
└── tsconfig.json

在初始化项目后，会生成以下几个重要目录：

• contract：包含一个名为 base-contract.ts 的文件，这是一个包含常用方法和Aleo程序在JavaScript中的配置的类。

• programs：用于存放所有 Leo 程序的目录。初始化时会自动生成 token.leo 和 sample_program.leo 文件。

• scripts：用于存放特定任务和用户脚本的目录。

• test：用于存放所有测试文件的目录。

• aleo-config.js：配置文件，包含私钥、执行链上或模拟运行的模式以及不同网络的配置。

aleo-config.js 配置文件详解

import dotenv from 'dotenv';
dotenv.config();

export default {
  accounts: [process.env.ALEO_PRIVATE_KEY],
  mode: 'execute',
  mainnet: {},
  networks: {
    testnet3: {
      endpoint: 'http://localhost:3030',
      accounts: [process.env.ALEO_PRIVATE_KEY_TESTNET3, 
                 process.env.ALEO_DEVNET_PRIVATE_KEY2],
      priorityFee: 0.01
    },
    mainnet: {
      endpoint: 'https://api.explorer.aleo.org/v1',
      accounts: [process.env.ALEO_PRIVATE_KEY_MAINNET],
      priorityFee: 0.001
    }
  },
  defaultNetwork: 'testnet3'
};

该配置文件支持两种执行模式：

1. execute 模式：在该模式下，会生成并在链上广播证明。内部调用 snarkos developer execute 命令。

2. evaluate 模式：在该模式下，不会生成和广播证明。内部调用 leo run 命令。

aleo-config 作为整个项目的默认配置，也可以根据每个程序进行覆盖。

添加或修改程序

要添加一个新程序，可以在 programs/ 目录中创建一个新文件。要修改现有文件，可以直接修改文件或运行以下命令：

aleojs-cli-dev add [PROGRAM_NAME]

编译项目

要编译项目，运行以下命令：

aleojs-cli-dev compile

这将创建 artifacts 文件夹，其中包含两个主要目录：

• leo：包含所有的 Leo 包。对于 programs 目录中的每个程序，将生成相应的 Leo 包。程序代码会被复制到 src/main.leo 文件中，并进行编译。如果所有程序都编译成功，则生成的 .aleo 文件会被解析为 Leo 和 JS 类型文件，存放在 js 目录中。

• js：包含 Leo 类型文件、JS 类型文件、js2leo（Leo 类型到 JS 类型的转换）、leo2js（JS 类型到 Leo 类型的转换）。对于每个程序，还会创建 <PROGRAM-NAME>.ts 文件，包含程序的所有转换和映射。

目录结构如下：

├── js
│   ├── js2leo
│   │   ├── index.ts
│   │   └── token.ts
│   ├── leo2js
│   │   ├── index.ts
│   │   └── token.ts
│   └── types
│       ├── index.ts
│       └── token.ts
│   ├── sample_program.ts
│   ├── token.ts
└── leo
    ├── sample_program
    │   ├── README.md
    │   ├── build
    │   ├── inputs
    │   ├── leo.lock
    │   ├── outputs
    │   ├── program.json
    │   └── src
    └── token
        ├── README.md
        ├── build
        ├── inputs
        ├── leo.lock
        ├── outputs
        ├── program.json
        └── src

注意：由于 sample_program 没有类型文件，因此不需要生成 js2leo、leo2js 或 type 文件。

运行测试

在编译成功后，您可以基于生成的文件编写测试用例。

一个用于 sample_program 和 token 程序的示例测试文件已创建。运行所有测试的命令如下：

npm run test

如果您只想测试某个特定的文件，可以使用以下命令：

npm run test -- sample_program.test.ts

小提示：您不需要输入完整的测试文件名称。您可以使用文件名的一部分，系统将自动运行与输入名称匹配的测试。 例如：npm run test -- sample

高级测试

在 test 目录下创建一个测试文件（文件名例如 token.test.ts），以下是一个示例测试文件：

import { parseRecordString } from '@aleojs/core';
import { PrivateKey } from '@aleohq/sdk';

import { TokenContract } from '../artifacts/js/token';
import { token, tokenLeo } from '../artifacts/js/types/token';
import { gettoken } from '../artifacts/js/leo2js/token';

const TIMEOUT = 200_000;
const amount = BigInt(2);

// 初始化合约类
const mode = 'execute';
const contract = new TokenContract({ mode });

// 该方法会映射 `aleo-config.js` 中定义的网络，并返回相应私钥地址的数组
const [admin, user] = contract.getAccounts();

// 此方法返回与指定 Aleo 地址关联的私钥
const adminPrivateKey = contract.getPrivateKey(admin);

// 自定义函数，用于解析 token 记录数据
function parseRecordtoToken(
  recordString: string,
  mode?: 'execute' | 'evaluate',
  privateKey?: string
): token {
  // 如果是 `execute` 模式下记录是加密的，因此我们需要解密它们
  if (mode && mode === 'execute') {
    if (!privateKey)
      throw new Error('需要私钥来进行解密');
    const record = gettoken(
      parseRecordString(
        PrivateKey.from_string(privateKey).to_view_key().decrypt(recordString)
      ) as tokenLeo
    );
    return record;
  }
  const record = gettoken(
    parseRecordString(JSON.stringify(recordString)) as tokenLeo
  );
  return record;
}

// 在测试开始之前执行
beforeAll(async () => {
  // 在 `execute` 模式下运行测试之前需要先部署合约
  if (contract.config.mode === 'execute') {
    // 该方法检查链上是否已经部署了程序
    const deployed = await contract.isDeployed();

    // 如果合约已经部署，则跳过部署步骤
    if (deployed) return;

    const tx = await contract.deploy();
    await contract.wait(tx);
  }
}, TIMEOUT);

test(
  '铸造私人 token',
  async () => {
    const [result, tx] = await contract.mint_private(admin, amount);

    // 在 `evaluate` 模式下，tx 是 undefined，因此不需要等待它
    if (tx) await contract.wait(tx);

    const senderRecord: token = parseRecordtoToken(
      result,
      mode,
      adminPrivateKey
    );
    expect(senderRecord.owner).toBe(admin);
    expect(senderRecord.amount.toString()).toBe(amount.toString());
  },
  TIMEOUT
);

test(
  '转移私人 token',
  async () => {
    const [token, tx] = await contract.mint_private(admin, amount);
    if (tx) await contract.wait(tx);
    const record: token = parseRecordtoToken(token, mode, adminPrivateKey);

    // `transfer_private` 返回两个记录，因此 result1 和 result2 保存这些记录，tx1 保存交易执行数据
    const [result1, result2, tx1] = await contract.transfer_private(
      record,
      user,
      amount
    );

    if (tx1) await contract.wait(tx1);

    const privateKey = contract.getPrivateKey(user);
    const record1 = parseRecordtoToken(result1, mode, adminPrivateKey);
    const record2 = parseRecordtoToken(result2, mode, privateKey);

    expect(record1.amount).toBe(BigInt(0));
    expect(record2.amount).toBe(amount);
  },
  TIMEOUT
);

执行测试文件

要执行测试文件，可以使用以下命令：

npm test -- --runInBand token.test.ts

这将会运行 token.test.ts 文件中的所有测试用例，确保您的智能合约逻辑在实际操作中正常工作。

总结

本教程提供了关于Aleo.js的安装、项目启动、程序添加、编译、测试和部署的完整示例。希望通过这个教程能帮助你顺利地在Aleo区块链上进行开发。

• Aleo Twitter

• Aleo Discord

• Aleo 官网

Demox Labs 提供了一套模块化的 TypeScript 钱包适配器和组件，专为 Aleo 应用程序设计。这篇文章将为您介绍如何将 Wallet Adapter 集成到基于 React 的Aleo应用中，并提供详细的代码示例，帮助您快速上手。

快速设置（使用React UI）

1. 📲 安装依赖

首先，安装以下必要的依赖项：

npm install --save \
    @demox-labs/aleo-wallet-adapter-base \
    @demox-labs/aleo-wallet-adapter-react \
    @demox-labs/aleo-wallet-adapter-reactui \
    @demox-labs/aleo-wallet-adapter-leo \
    react

2. 🛠️ 集成设置

在React应用中，使用以下代码来集成Wallet Adapter：

import React, { FC, useMemo } from "react";
import { WalletProvider } from "@demox-labs/aleo-wallet-adapter-react";
import { WalletModalProvider } from "@demox-labs/aleo-wallet-adapter-reactui";
import { LeoWalletAdapter } from "@demox-labs/aleo-wallet-adapter-leo";
import { DecryptPermission, WalletAdapterNetwork } from "@demox-labs/aleo-wallet-adapter-base";

// 导入默认样式，可以根据需求覆盖
require("@demox-labs/aleo-wallet-adapter-reactui/styles.css");

export const Wallet: FC = () => {
  const wallets = useMemo(
    () => [new LeoWalletAdapter({ appName: "Leo Demo App" })],
    []
  );

  return (
    <WalletProvider
      wallets={wallets}
      decryptPermission={DecryptPermission.UponRequest}
      network={WalletAdapterNetwork.Localnet}
      autoConnect
    >
      <WalletModalProvider>
        {/* 你的应用组件在这里 */}
      </WalletModalProvider>
    </WalletProvider>
  );
};

功能实现示例

✍🏻 实现消息签名功能

使用以下代码片段可以为您的应用添加消息签名功能：

import { WalletNotConnectedError } from "@demox-labs/aleo-wallet-adapter-base";
import { useWallet } from "@demox-labs/aleo-wallet-adapter-react";
import { LeoWalletAdapter } from "@demox-labs/aleo-wallet-adapter-leo";
import React, { FC, useCallback } from "react";

export const SignMessage: FC = () => {
  const { wallet, publicKey } = useWallet();

  const onClick = useCallback(async () => {
    if (!publicKey) throw new WalletNotConnectedError();

    const message = "需要签名的消息";
    const bytes = new TextEncoder().encode(message);
    const signatureBytes = await (
      wallet?.adapter as LeoWalletAdapter
    ).signMessage(bytes);
    const signature = new TextDecoder().decode(signatureBytes);
    alert("签名消息: " + signature);
  }, [wallet, publicKey]);

  return (
    <button onClick={onClick} disabled={!publicKey}>
      签名消息
    </button>
  );
};

🔓 实现解密功能

以下代码片段展示了如何实现消息解密：

import { WalletNotConnectedError } from "@demox-labs/aleo-wallet-adapter-base";
import { useWallet } from "@demox-labs/aleo-wallet-adapter-react";
import React, { FC, useCallback } from "react";

export const DecryptMessage: FC = () => {
  const { publicKey, decrypt } = useWallet();

  const onClick = async () => {
    const cipherText = "需要解密的记录....";
    if (!publicKey) throw new WalletNotConnectedError();
    if (decrypt) {
      const decryptedPayload = await decrypt(cipherText);
      alert("解密结果: " + decryptedPayload);
    }
  };

  return (
    <button onClick={onClick} disabled={!publicKey}>
      解密消息
    </button>
  );
};

🗂️ 请求记录

您可以使用以下代码片段请求指定程序的记录：

import { WalletNotConnectedError } from "@demox-labs/aleo-wallet-adapter-base";
import { useWallet } from "@demox-labs/aleo-wallet-adapter-react";
import React, { FC, useCallback } from "react";

export const RequestRecords: FC = () => {
  const { publicKey, requestRecords } = useWallet();

  const onClick = async () => {
    const program = "credits.aleo";
    if (!publicKey) throw new WalletNotConnectedError();
    if (requestRecords) {
      const records = await requestRecords(program);
      console.log("记录: " + records);
    }
  };

  return (
    <button onClick={onClick} disabled={!publicKey}>
      请求记录
    </button>
  );
};

📡 请求交易

通过以下代码片段，您可以请求交易：

import {
  Transaction,
  WalletAdapterNetwork,
  WalletNotConnectedError
} from "@demox-labs/aleo-wallet-adapter-base";
import { useWallet } from "@demox-labs/aleo-wallet-adapter-react";
import React, { FC, useCallback } from "react";

export const RequestTransaction: FC = () => {
  const { publicKey, requestTransaction } = useWallet();

  const onClick = async () => {
    if (!publicKey) throw new WalletNotConnectedError();

    const record = `'{"id":"0f27d86a-1026-4980-9816-bcdce7569aa4","program_id":"credits.aleo","microcredits":"200000","spent":false,"data":{}}'`;
    const inputs = [JSON.parse(record), "aleo1kf3dgrz9...", "100u64"];
    const fee = 35_000;

    const aleoTransaction = Transaction.createTransaction(
      publicKey,
      WalletAdapterNetwork.Testnet,
      'credits.aleo',
      'transfer',
      inputs,
      fee
    );

    if (requestTransaction) {
      await requestTransaction(aleoTransaction);
    }
  };

  return (
    <button onClick={onClick} disabled={!publicKey}>
      请求交易
    </button>
  );
};

💻 部署Aleo程序

以下是如何部署Aleo程序的代码示例：

import {
  Deployment,
  WalletAdapterNetwork,
  WalletNotConnectedError
} from "@demox-labs/aleo-wallet-adapter-base";
import { useWallet } from "@demox-labs/aleo-wallet-adapter-react";
import React, { FC, useCallback } from "react";

export const DeployProgram: FC = () => {
  const { publicKey, requestDeploy } = useWallet();

  const onClick = async () => {
    if (!publicKey) throw new WalletNotConnectedError();

    const program = `
      program hello.aleo;
      function main:
        input r0 as u32.public;
        input r1 as u32.private;
        add r0 r1 into r2;
        output r2 as u32.private;
    `;
    const fee = 4_835_000;

    const aleoDeployment = new Deployment(
      publicKey,
      WalletAdapterNetwork.Testnet,
      program,
      fee
    );

    if (requestDeploy) {
      await requestDeploy(aleoDeployment);
    }
  };

  return (
    <button onClick={onClick} disabled={!publicKey}>
      部署程序
    </button>
  );
};

订阅事件

您可以使用以下代码订阅钱包事件，例如账户更改：

import { useWallet } from "@demox-labs/aleo-wallet-adapter-react";
import { LeoWalletAdapter } from "@demox-labs/aleo-wallet-adapter-leo";
import React, { FC, useEffect, useCallback } from "react";

export const SubscribeToEvent: FC = () => {
  const { wallet } = useWallet();

  const handleAccountChange = useCallback(() => {
    // 处理账户变化，重新连接
  }, [wallet]);

  useEffect(() => {
    (wallet?.adapter as LeoWalletAdapter).on('accountChange', handleAccountChange);
    return () => {
      (wallet?.adapter as LeoWalletAdapter).off('accountChange', handleAccountChange);
    }
  }, [wallet]);

  return (
    // 组件内容
  );
};

通过以上步骤和代码片段，您可以成功地在Aleo应用中集成Demox Labs的Wallet Adapter，为用户提供更加无缝和安全的体验。如果有更多问题或需要深入了解，建议查阅Demox Labs的官方文档或加入开发者社区获取更多支持。

• Aleo Twitter

• Aleo Discord

• Aleo 官网

在本教程中，我们将一步步了解如何使用 Puzzle SDK和WalletConnect 构建隐私的 dApps。除了构建隐私 dApp，还将学习如何集成 Puzzle Wallet 到我们自己的项目中，本教程都将提供必要的实现步骤和代码演示，让你快速上手。

Puzzle SDK概述

Puzzle SDK提供了React钩子，用于在隐私 dApp 和 Puzzle Wallet 之间进行交互。对于不使用React的人来说，也可以使用纯JavaScript 实现的 SDK。

下载钱包

你可以从Chrome商店或iOS的App Store下载Puzzle Wallet。

• Puzzle | Aleo Wallet - Chrome Web Store

• Puzzle | Aleo Wallet - App Store

下载 Puzzle SDK

要下载React SDK，请使用以下命令：

npm i @puzzlehq/sdk

对于JavaScript SDK，使用以下命令：

npm i @puzzlehq/sdk-core

克隆示例代码库

我们提供了一些示例代码库供你入门。例如，要克隆 build a token 代码库，使用以下命令：

git clone https://github.com/puzzlehq/build-a-token.git

运行示例dApp应用程序

要运行示例dApp应用程序，请按以下步骤操作：

# 进入项目目录
cd build-a-token

# 运行开发服务器
npm run dev

SDK概述

@puzzlehq/sdk暴露了多个JavaScript函数和React钩子用于dApp开发。所有来自@puzzlehq/sdk-core的函数也由@puzzlehq/sdk导出。

PuzzleWalletProvider

要使用React SDK，请将你的应用包裹在PuzzleWalletProvider中。

import ReactDOM from 'react-dom/client';
import YourApp from './YourApp.js';
import { PuzzleWalletProvider } from '@puzzlehq/sdk';

ReactDOM.createRoot(document.getElementById('root')!).render(
  <PuzzleWalletProvider
    dAppName="<YOUR DAPP NAME>"
    dAppDescription="<YOUR DAPP DESCRIPTION>"
    dAppUrl="<YOUR DAPP URL>"
    dAppIconURL="<YOUR DAPP ICON URL>"
    projectId="<YOUR WALLETCONNECT PROJECT ID>" // 可选
  >
    <YourApp />
  </PuzzleWalletProvider>
);

WalletConnect 概述

如果你不想使用我们的SDK，你可以直接通过任何WalletConnect V2包使用Puzzle Wallet功能。

WalletConnect方法

方法是由dApp发起的函数。

export const wc_aleo_methods = [
  'decrypt',
  'disconnect',
  'getSelectedAccount',
  'getBalance',
  'getRecords',
  'requestCreateEvent',
  'getEvent',
  'getEvents',
  'createSharedState',
  'importSharedState',
  'requestSignature',
];

WalletConnect 事件

事件是由钱包发起的函数。

export const wc_events = [
  'chainChanged',
  'accountSelected',
  'selectedAccountSynced',
  'sharedAccountSynced',
];

WalletConnect 链 ID

目前，Puzzle只支持一个链ID，但随着Aleo获得官方WalletConnect支持，这可能会改变。

export const wc_aleo_chains = ['aleo:1']; // 可能会更改

WalletConnect 项目 ID

const projectId = 'f0aaeffe71b636da453fce042d79d723';

WalletConnect Web3Modal 属性

export const web3modal_puzzle_props = {
  standaloneChains: wc_aleo_chains,
  enableExplorer: false,
  enableAccountView: true,
  enableNetworkView: true,
  enableStandaloneMode: true,
  mobileWallets: [
    {
      id: 'puzzle',
      name: 'Puzzle Wallet',
      links: {
        native: 'puzzleapp://',
        universal: '',
      },
    },
  ],
  desktopWallets: [
    {
      id: 'puzzle',
      name: 'Puzzle Wallet',
      links: {
        native: '',
        universal: 'https://walletconnect.puzzle.online/',
      },
    },
  ],
  walletImages: {
    puzzle: 'https://i.imgur.com/p9tHaFC.png',
  },
};

WalletConnect Sign Client 属性

export const signClient_puzzleProps = {
  requiredNamespaces: {
    aleo: {
      methods: wc_aleo_methods,
      chains: wc_aleo_chains,
      events: wc_events,
    },
  },
};

更多信息你可以在这里找到：Puzzle GitHub

通过上面的代码学习，你将学会如何将 Puzzle SDK 和 WalletConnect 集成到你的 Aleo dApp 中，这将是 dApp 开发的关键一步。

• Aleo Twitter

• Aleo Discord

• Aleo 官网

游戏、部署、赚取奖励！

1. 游戏

创建 Aleo 账户并使用 Puzzle Wallet：

• 下载 Puzzle Wallet，并按照扩展程序中的说明创建账户。然后需要几分钟等待 Aleo 积分和 Puzzle Pieces 到账。

• 进入 Where’s Alex 游戏 链接，连接你的钱包，并验证你拥有的 Puzzle Prudens。然后使用 Puzzle 的开发工具铸造一些 Puzzle Prudens。

铸造 Puzzle Prudens:

• 打开 Puzzle 的开发工具 并连接你的钱包。

• 在 "Create Event" 部分输入以下信息：

  • Program ID: puzzle_pieces_v015.aleo

  • Function ID: mint_private

  • Function Inputs: 500u64 你的 ALEO 账户地址

  示例：

  500u64 aleo1v2ny2f64fsa97xc6s9medy68cf69szqxms03tyevgz8v9jlfzgzslxt6ka
  

• 点击 "Create Event" 并等待交易完成。

• 一旦交易完成，你可以回到 Where’s Alex 并开始游戏！向以下属于 Puzzle 团队的 Aleo 地址发起挑战，获取 Earn 的资格：

  • 地址：aleo1u66muyfx8kp9zw957m4tkkpmrpjdnem4q4zpddh6zd2dejds3y9qa6p32u

2. 部署

让我们来 Fork 这个游戏，并创建你自己的 zkGame！这个过程分为三个步骤：

A. 设置你的 Where’s Alex :

1. Fork 这个游戏的前端代码和 Aleo 智能合约代码。访问 Where’s Alex 的 GitHub 仓库，Fork 前端代码和 Aleo 智能合约代码。

2. 阅读 Aleo 智能合约代码部分的 readme 文件，了解 Aleo 智能合约代码，以及了解 Where’s Alex 和 Puzzle 如何处理多方隐私。

B. 将你的 zkGame Aleo 程序部署到 Aleo

主要包括三个步骤：

步骤 1：获取 Aleo 程序部署工具

如果你还没有安装 Rust、snarkVM、snarkOS 和 Leo，现在需要安装它们。建议使用 VS Code 的用户添加 Leo 扩展。

步骤 2-6：制作你自己的 “zkGame Pieces” 程序和 “zkGame” 程序

1. 在 VS Code 中打开你新 Fork 的仓库，并进入 programs 文件夹。

2. 更新 puzzle_pieces_v015.leo 程序，使用你独特的标题/版本。

3. 更新 puzzle_pieces 的 program.json 文件，并使用 test.sh 脚本确保一切正常。

4. 更新 wheres_alex_v018.leo 程序以导入你自己的代币，并使用你独特的标题/版本。

5. 更新 program.json 文件和 test.sh 脚本，确保一切正常。

步骤 7-9：将你的 zkGame 程序部署到 Aleo

1. 为你的 Aleo 账户充值。你需要 70 Aleo Credits 来部署合约。创建新的账户，并将信用转移到你的主账户。

2. 部署 zkGame Pieces 程序：

snarkos developer deploy "INSERT_YOUR_PIECES_FORK_PROGRAM_NAME_HERE.aleo" --private-key "INSERT_YOUR_ALEO_PRIVATE_KEY_HERE" --query "https://api.explorer.aleo.org/v1" --broadcast "https://api.explorer.aleo.org/v1/testnet3/transaction/broadcast" --priority-fee 16000000

1. 部署 zkGame 程序：

snarkos developer deploy "INSERT_YOUR_WHERES_ALEX_FORK_PROGRAM_NAME_HERE.aleo" --private-key "INSERT_YOUR_ALEO_PRIVATE_KEY_HERE" --query "https://api.explorer.aleo.org/v1" --broadcast "https://api.explorer.aleo.org/v1/testnet3/transaction/broadcast" --priority-fee 17000000

C. 将你的 zkGame 前端部署到 Vercel

1. 更新前端引用的 Aleo 程序：

   • 打开 VS Code，在你 Fork 的仓库中。

   • 使用 “Control F” 在 src 文件夹中搜索 puzzle_pieces_v015.aleo 并替换为你部署的版本。

   • 使用 “Control F” 在 src 文件夹中搜索 wheres_alex_v018.aleo 并替换为你部署的版本。

   • 使用 “Control F” 在 src 文件夹中搜索 “fees” 并调整值以确保费用足够高。

2. 测试新程序的前端应用：

   • 使用以下命令在本地编译并测试：

   pnpm i && pnpm run dev
   

   • 连接钱包到你的本地版本 zkGame，并验证它是否工作正常。铸造一些 zkGame pieces 并验证你的余额。

3. 添加你个人风格的元素并部署到 Vercel：

   • 根据你的喜好，通过更新代币名称、游戏标题、背景图片、选择和图片等内容，来为你的 zkGame 增加一些个性化元素。

   • 然后通过 Vercel 部署你的游戏。

3. 赚取奖励

挑战 Puzzle 官方账户，在你新部署的程序的网站上与他们对战，地址如下：

• 地址：aleo1u66muyfx8kp9zw957m4tkkpmrpjdnem4q4zpddh6zd2dejds3y9qa6p32u

更多信息请参考：

https://docs.puzzle.online

通过这个教程开发部署的更多 zkGame 示例：

• Where’s Luna

• Where’s Adam

• Where’s Joe

• Where’s Dominion

• Where’s Daniel

恭喜你构建并部署了你的第一个 Aleo zkGame！

• Aleo Twitter

• Aleo Discord

• Aleo 官网

在这篇文章中将一步步的演示在 Staking.xyz 上质押 Aleo，验证者需要质押 ALEO 才能激活，如果你不想运行自己的验证者，可以将你的 ALEO 委托给其他验证者。委托是非托管的，这意味着你仍然完全控制你的资金。

什么是质押？

Aleo 是一个使用 zk 证明来支持隐私应用的 Layer 1 区块链。这些证明需要称为 provers 的特殊参与者，他们在不泄露内容的情况下创建交易的加密证明。验证者则是另一个关键参与者，他们对新区块和区块历史达成共识。为了防止 sybil 攻击，验证者需要质押 Aleo Credits。要成为活跃的验证者，必须自我质押 1000 万 Aleo Credits。验证者也可以通过接受其他代币持有者的委托来增加质押。

如何开始质押？

你可以通过两种方式参与 Aleo 质押：

1. 成为验证者：运行一个 Aleo 节点，与其他验证者通信以形成共识。

2. 成为委托者：选择验证者并将你的 Aleo Credits 质押给他们，同时保留对你资产的完全控制权。

在 Staking.xyz 上质押的步骤指南：

1. 访问 staking.xyz。在 staking.xyz 开始管理你的质押。

2. 选择质押数量。输入你想要质押的 ALEO 数量，这里质押数量不能低于1000 积分。

3. 获得质押奖励。质押奖励在每个区块中赚取，并直接添加到你的质押余额中，复投你的奖励。

4. 解除质押过程。你可以随时解质押。解质押后，你需要等待 1 小时才能转移你的 ALEO。

质押的重要注意事项：

委托者：

• 需要至少 10,000 Aleo Credits 才能开始赚取奖励。

• 奖励在 1-2 个区块后赚取，并自动复合。

验证者：

• 必须至少质押 10,000,000 Aleo Credits 才能成为活跃验证者。

• 如果他们有任何活跃的委托者，则无法退出活跃集。

选择验证者时的考虑：

• 性能：高在线时间和可靠的性能至关重要。

• 贡献：通过工具、社区或公共 RPC 端点为生态系统做出贡献的验证者。

• 佣金：合理的佣金率以确保可持续运营。

• 去中心化：避免委托过于集中的验证者，以维护网络弹性。

• 声誉：在其他生态系统中的表现可以预示在 Aleo 上的未来表现。

质押奖励和协议：

奖励：

• 协议发放初始总供应量的 5% 作为质押奖励。

• Coinbase 奖励分配给 Aleo 质押者，其中三分之一用于 Aleo provers 提供的解决方案。

ARC 提案：

• ARC-0037：区分工作和提款地址。

• ARC-0038：验证者可以从委托者那里收取佣金。

• ARC-0041：允许验证者在没有直接拥有 1000 万 Aleo Credits 的情况下激活。

在 Aleo 上质押需要认真的选择一个靠谱的验证者。在委托你的 ALEO 之前，始终要研究验证者并理解质押机制。随着 Aleo 向主网推出迈进，对最新进展保持关注非常重要。

通过遵循本指南，你可以简单地了解 Staking.xyz 上的质押过程，为网络安全做出贡献并在此过程中赚取奖励。

• Aleo Twitter

• Aleo Discord

• Aleo 官网

项目地址：

https://github.com/C-B-Elite/aleo-agent

安装

首先确保已经成功安装 Rust，在你的项目目录下运行以下 Cargo 命令：

cargo add aleo-agent

或者在你的 Cargo.toml 文件中添加以下行：

aleo-agent = "1.0.1"

使用

发起转账

先看一段简单的 demo

use aleo_agent::account::Account;
use aleo_agent::agent::{Agent, TransferArgs, TransferType};
use aleo_agent::{CiphertextRecord, PlaintextRecord, MICROCREDITS};
use anyhow::Result;
use std::str::FromStr;

fn main() -> Result<()> {
    
    // 私钥格式: APrivateKey1zkp...
    let alice_key = "Alice PRIVATE KEY";
    let alice_account = Account::from_private_key(alice_key)?;
    let alice_agent = Agent::builder().with_account(alice_account).build();

    let bob_key = "Bob PRIVATE KEY";
    let bob_account = Account::from_private_key(bob_key)?;
    let bob_address = bob_account.address();
    
    // 获取 Alice 的公共余额
    let public_balance = alice_agent.get_public_balance()?;
    println!("Alice Public Balance : {}", public_balance);
    
    // 公共转账到公共账户
    let transfer_args = TransferArgs::from(
        MICROCREDITS, // 1 微信用
        bob_address.to_owned(),
        1,
        None,
        TransferType::Public,
    );
    let tx_hash = alice_agent.transfer(transfer_args)?;
    println!("tx_hash: {tx_hash}");

    // 公共转账到私有账户
    let transfer_args = TransferArgs::from(
        MICROCREDITS, // 1 微信用
        bob_address.to_owned(),
        1,
        None,
        TransferType::PublicToPrivate,
    );
    let tx_hash = alice_agent.transfer(transfer_args)?;
    println!("tx_hash: {tx_hash}");

    // 私有转账到公共账户
    // 明文记录格式: "{owner: aleo1xxxxx.private,microcredits: 1u64.private,_nonce: xxxxxgroup.public}"
    let record = PlaintextRecord::from_str("PLAINTEXT RECORD")?;

    // 从密文记录解密明文记录
    // 格式: record1xxxxxxxxxx
    let ciphertext_record = CiphertextRecord::from_str("CIPHERTEXT RECORD")?;
    let fee_record = alice_agent.decrypt_ciphertext_record(&ciphertext_record)?;

    let transfer_args = TransferArgs::from(
        MICROCREDITS, // 1 微信用
        bob_address.to_owned(),
        10,
        Some(fee_record),
        TransferType::PrivateToPublic(record),
    );
    let tx_hash = alice_agent.transfer(transfer_args)?;
    println!("tx_hash: {tx_hash}");

    // 私有转账到私有账户
    let encrypted_fee_record = CiphertextRecord::from_str("record1xxxxxxx")?;
    let record = alice_agent.decrypt_ciphertext_record(&encrypted_fee_record)?;

    let transfer_args = TransferArgs::from(
        MICROCREDITS,
        bob_address.to_owned(),
        1,
        None,
        TransferType::Private(record),
    );
    let tx_hash = alice_agent.transfer(transfer_args)?;
    println!("tx_hash: {tx_hash}");

    Ok(())
}

这段代码展示了如何使用 aleo_agent 库进行不同类型的资产转移操作。具体步骤如下：

主要流程

1. 账户初始化：使用私钥创建账户对象。

2. 账户代理初始化：使用账户对象创建代理对象，用于执行转移操作。

3. 获取公共余额：查询账户的公共余额。

4. 公共转账到公共账户：从Alice账户向Bob账户进行公共转账。

5. 公共转账到私有账户：从Alice账户向Bob账户进行公共到私有的转账。

6. 私有转账到公共账户：从Alice账户向Bob账户进行私有到公共的转账。

7. 私有转账到私有账户：从Alice账户向Bob账户进行私有到私有的转账。

代码详细介绍

use aleo_agent::account::Account;
use aleo_agent::agent::{Agent, TransferArgs, TransferType};
use aleo_agent::{CiphertextRecord, PlaintextRecord, MICROCREDITS};
use anyhow::Result;
use std::str::FromStr;

fn main() -> Result<()> {

• 导入依赖库：导入aleo_agent库中所需的模块和类型，以及anyhow库用于错误处理。

• 定义主函数：main函数用于执行代码逻辑。

    // private key format: APrivateKey1zkp...
    let alice_key = "Alice PRIVATE KEY";
    let alice_account = Account::from_private_key(alice_key)?;
    let alice_agent = Agent::builder().with_account(alice_account).build();

    let bob_key = "Bob PRIVATE KEY";
    let bob_account = Account::from_private_key(bob_key)?;
    let bob_address = bob_account.address();

• 创建Alice账户：从私钥创建Alice的账户对象，并使用该账户对象创建代理对象。

• 创建Bob账户：从私钥创建Bob的账户对象，并获取其地址。

    // get alice public balance
    let public_balance = alice_agent.get_public_balance()?;
    println!("Alice Public Balance : {}", public_balance);

• 获取Alice的公共余额：查询并打印Alice账户的公共余额。

    // public transfer to public account
    let transfer_args = TransferArgs::from(
        MICROCREDITS, // 1 credit
        bob_address.to_owned(),
        1,
        None,
        TransferType::Public,
    );
    let tx_hash = alice_agent.transfer(transfer_args)?;
    println!("tx_hash: {tx_hash}");

• 公共转账到公共账户：创建转账参数，从Alice账户向Bob账户进行公共转账，并打印交易哈希。

    // public transfer to private
    let transfer_args = TransferArgs::from(
        MICROCREDITS, // 1 credit
        bob_address.to_owned(),
        1,
        None,
        TransferType::PublicToPrivate,
    );
    let tx_hash = alice_agent.transfer(transfer_args)?;
    println!("tx_hash: {tx_hash}");

• 公共转账到私有账户：创建转账参数，从Alice账户向Bob账户进行公共到私有的转账，并打印交易哈希。

    // private transfer to public
    // plaintext record format : "{owner: aleo1xxxxx.private,microcredits: 1u64.private,_nonce: xxxxxgroup.public}"
    let record = PlaintextRecord::from_str("PLAINTEXT RECORD")?;

    //  decrypt plaintext record from ciphertext record
    //  format: record1xxxxxxxxxx
    let ciphertext_record = CiphertextRecord::from_str("CIPHERTEXT RECORD")?;
    let fee_record = alice_agent.decrypt_ciphertext_record(&ciphertext_record)?;

    let transfer_args = TransferArgs::from(
        MICROCREDITS, // 1 credit
        bob_address.to_owned(),
        10,
        Some(fee_record),
        TransferType::PrivateToPublic(record),
    );
    let tx_hash = alice_agent.transfer(transfer_args)?;
    println!("tx_hash: {tx_hash}");

• 私有转账到公共账户：从字符串解析出明文记录和密文记录，解密密文记录，创建转账参数，并执行转账操作，打印交易哈希。

    // private transfer to private
    let encrypted_fee_record = CiphertextRecord::from_str("record1xxxxxxx")?;
    let record = alice_agent.decrypt_ciphertext_record(&encrypted_fee_record)?;

    let transfer_args = TransferArgs::from(
        MICROCREDITS,
        bob_address.to_owned(),
        1,
        None,
        TransferType::Private(record),
    );
    let tx_hash = alice_agent.transfer(transfer_args)?;
    println!("tx_hash: {tx_hash}");

    Ok(())
}

• 私有转账到私有账户：从字符串解析出密文记录，解密密文记录，创建转账参数，并执行转账操作，打印交易哈希。

部署和执行程序

use aleo_agent::account::Account;
use aleo_agent::agent::Agent;
use aleo_agent::program::ProgramManager;
use anyhow::Result;
use std::path::Path;
use std::thread::sleep;
use std::time::Duration;

fn main() -> Result<()> {
    // 使用私钥构建代理
    let private_key = "YOUR PRIVATE KEY"; // APrivateKey1zkp...
    let account = Account::from_private_key(private_key)?;
    let agent = Agent::builder().with_account(account).build();

    // 使用 Leo 项目中的 leo build 命令生成的 build 文件夹
    let path = Path::new("/contract/build"); // 必须是绝对路径
    let local_program = ProgramManager::load_program_from_path(path)?;
    
    // 部署程序
    let deploy_tx_id = agent.deploy_program(&local_program, 1, None)?;
    println!("已部署程序，交易ID: {}", deploy_tx_id);

    // 等待广播和确认
    sleep(Duration::from_secs(60));

    // 获取交易状态
    let status = agent.get_confirmed_transaction(&deploy_tx_id)?;
    println!("部署交易状态: \n {status:?}");

    // 获取程序ID
    let program_id = local_program.id();
    let pm = agent.program(program_id.to_string().as_ref())?;

    // 执行程序
    let inputs = vec!["1u32", "2u32"];
    let exec_tx_id = pm.execute_program("main", inputs.into_iter(), 1, None)?;
    println!("执行程序，交易ID: {exec_tx_id}");

    // 等待广播和确认
    sleep(Duration::from_secs(60));
    
    // 获取交易状态
    let status = agent.get_confirmed_transaction(&exec_tx_id)?;
    println!("执行交易状态: \n{:#?}", status);

    Ok(())
}

这段代码展示了如何使用 aleo_agent 库构建一个代理(agent)，并通过该代理来部署和执行一个程序。以下是代码的详细介绍：

导入必要的库和模块

use aleo_agent::account::Account;
use aleo_agent::agent::Agent;
use aleo_agent::program::ProgramManager;
use anyhow::Result;
use std::path::Path;
use std::thread::sleep;
use std::time::Duration;

• aleo_agent::account::Account: 用于管理账户信息。

• aleo_agent::agent::Agent: 代理对象，用于与区块链交互。

• aleo_agent::program::ProgramManager: 用于管理程序的部署和执行。

• anyhow::Result: 用于处理可能出现的错误。

• std::path::Path: 处理文件路径。

• std::thread::sleep 和 std::time::Duration: 用于设置程序暂停的时间。

主函数

fn main() -> Result<()> {
    // build an agent with private key
    let private_key = "YOUR PRIVATE KEY"; // APrivateKey1zkp...
    let account = Account::from_private_key(private_key)?;
    let agent = Agent::builder().with_account(account).build();

• 创建账户: 使用私钥创建账户对象 Account。

• 创建代理: 使用账户对象创建代理对象 Agent，用于后续的区块链操作。

    // The build folder is generated by using leo build in the Leo project.
    let path = Path::new("/contract/build"); // must be an absolute path
    let local_program = ProgramManager::load_program_from_path(path)?;

• 加载程序: 使用 ProgramManager 从指定路径加载已经编译好的 Leo 程序。路径必须是绝对路径。

    // deploy program
    let deploy_tx_id = agent.deploy_program(&local_program, 1, None)?;
    println!("Deployed program with tx id: {}", deploy_tx_id);

• 部署程序: 使用代理对象 agent 部署程序 local_program，并获取部署交易的ID。

    // waiting for broadcast and confirmation
    sleep(Duration::from_secs(60));

• 等待交易确认: 暂停程序60秒，以等待交易的广播和确认。

    // get transaction status
    let status = agent.get_confirmed_transaction(&deploy_tx_id)?;
    println!("Deployment tx status: \n {status:?}");

• 获取交易状态: 使用代理对象 agent 获取部署交易的确认状态，并打印出来。

    // get program id
    let program_id = local_program.id();
    let pm = agent.program(program_id.to_string().as_ref())?;

• 获取程序ID: 从已加载的程序 local_program 获取程序ID。

• 创建程序管理对象: 使用代理对象 agent 创建程序管理对象 pm。

    // execute program
    let inputs = vec!["1u32", "2u32"];
    let exec_tx_id = pm.execute_program("main", inputs.into_iter(), 1, None)?;
    println!("Execute program with tx id : {exec_tx_id}");

• 执行程序: 使用程序管理对象 pm 执行程序的 main 函数，传入输入参数 1u32 和 2u32，并获取执行交易的ID。

    // waiting for broadcast and confirmation
    sleep(Duration::from_secs(60));

• 等待交易确认: 暂停程序60秒，以等待交易的广播和确认。

    // get transaction status
    let status = agent.get_confirmed_transaction(&exec_tx_id)?;
    println!("Execution tx status: \n{:#?}", status);

• 获取交易状态: 使用代理对象 agent 获取执行交易的确认状态，并打印出来。

    Ok(())
}

• 结束程序: 如果所有操作成功，程序返回 Ok(())。

总结

通过以上的使用方式学习，我门可以学会在区块链上发起转账和部署执行自定义的 Leo 程序，实现去中心化的应用。

Aleo 官方链接：

• Aleo Twitter

• Aleo Discord

• Aleo Website

• Aleo Github

https://github.com/zkportal/aleo-oracle-sdk-js

这个 SDK 不使用默认导出。

在内部，这个 API 使用 Fetch API。只要你提供 Fetch API 的实现，它可能在任何 JS 环境中使用。

由于客户端允许配置自定义的公证和验证后端，它还允许提供 Fetch 选项的覆盖，用于与这些后端通信 - 详见 OracleClient 构造函数。

目录

• 安装

• 常量:

  • DEFAULT_FETCH_OPTIONS

  • DEFAULT_NOTARIZATION_BACKENDS

  • DEFAULT_NOTARIZATION_HEADERS

  • DEFAULT_NOTARIZATION_OPTIONS

  • DEFAULT_VERIFICATION_BACKEND

• 类型:

  • class AttestationError

  • class AttestationIntegrityError

  • class DebugAttestationError

  • class OracleClient

    • constructor

    • notarize

    • testSelector

    • enclavesInfo

  • 类型 AttestationRequest

  • 类型 AttestationResponse

  • 类型 ClientConfig

  • 类型 CustomBackendAllowedFetchOptions

  • 类型 CustomBackendConfig

  • 类型 DebugRequestResponse

  • 类型 EnclaveInfo

  • 类型 EncodingOptions

  • 类型 InfoOptions

  • 类型 NotarizationOptions

  • 类型 OracleData

  • 类型 PositionInfo

  • 类型 ProofPositionalInfo

  • 类型 SgxInfo

安装

通过运行 npm install @zkportal/aleo-oracle-sdk 安装 SDK。

常量

DEFAULT_FETCH_OPTIONS

默认的 Fetch API 选项，应用于所有发往公证和验证后端的请求。

{
  cache: 'no-store',
  mode: 'cors',
  redirect: 'follow',
  referrer: '',
  keepalive: false,
}

DEFAULT_NOTARIZATION_BACKENDS

如果没有向客户端提供 notarizer 配置，将使用的公证后端配置列表。

类型：[CustomBackendConfig[]](#类型 custombackendconfig)。

[
  {
    address: 'sgx.aleooracle.xyz',
    port: 443,
    https: true,
    apiPrefix: '',
    resolve: true,
    init: DEFAULT_FETCH_OPTIONS,
  },
]

DEFAULT_NOTARIZATION_HEADERS

添加到所有发往证明目标的请求的默认 HTTP 请求头。

{
  'Accept': '*/*',
  'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36',
  'Upgrade-Insecure-Requests': '1',
  'DNT': '1',
}

DEFAULT_NOTARIZATION_OPTIONS

类型：`NotarizationOptions`\

{
  dataShouldMatch: true,
  timeout: 5000,
  maxTimeDeviation: undefined,
}

DEFAULT_VERIFICATION_BACKEND

如果没有向客户端提供 verifier 配置，将使用的公证后端配置列表。

类型：`CustomBackendConfig`\。

{
  address: 'verifier.aleooracle.xyz',
  port: 443,
  https: true,
  apiPrefix: '',
  resolve: true,
  init: DEFAULT_FETCH_OPTIONS,
}

类型

class AttestationError

扩展自：Error

class AttestationIntegrityError

扩展自：Error

class DebugAttestationError

扩展自：Error

class OracleClient

constructor

notarize

testSelector

enclavesInfo

类型 AttestationRequest

对 HTTPS 资源的公证和证明请求，并使用数据选择器从响应中提取证明数据。还描述了预期的响应格式，以及如何为 Aleo 程序编码提取的证明数据。

类型 AttestationResponse

公证后端对证明请求的响应。

类型 ClientConfig

Oracle 客户端配置对象。

类型 CustomBackendAllowedFetchOptions

Omit<RequestInit, 'body' | 'integrity' | 'method'>

类型 CustomBackendConfig

Oracle 客户端将用于公证/验证的后端配置。

类型 DebugRequestResponse

用于调试选择器的公证响应。

类型 EnclaveInfo

关于公证后端运行的 TEE 的信息。

类型 EncodingOptions

描述解释提取的证明数据以编码为 Aleo 程序兼容格式的方法。

参见 Aleo 编码指南。

类型 InfoOptions

获取安全区信息请求的选项。

类型 NotarizationOptions

公证客户端选项。参见 公证和证明指南。

类型 OracleData

直接用于 Aleo 程序中的证明相关信息。参见 Aleo 编码指南 和 编码文档 以了解这些值的创建方式。

类型 PositionInfo

描述编码为 Aleo 程序格式的属性的位置和长度。

类型 ProofPositionalInfo

关于 Aleo 编码的证明响应中不同属性位置的信息。计数在 Aleo 的 u128 属性上进行，计数从 0 开始。

位置不考虑嵌套结构，并且可能会超出 Aleo 允许的类型属性数量限制。

请参阅编码文档。

类型 SgxInfo

关于运行公证后端的 Intel SGX 安全区的信息。包括一些为了方便在 Aleo 程序中使用而编码的额外属性。

Aleo 官方链接：

• Aleo Twitter

• Aleo Discord

• Aleo Website

• Aleo Github

第一步：识别数据

首先，您需要识别要在 Aleo 程序中使用的数据。通常，Oracle SDK 支持任何可以公开访问的静态 HTTPS 网站，或通过提供正确的头部、cookies 和/或请求体来访问。

关于认证动态渲染的内容

您想使用的数据必须是“静态渲染”的，这意味着它必须存在于原始 HTTP 响应中。

这意味着您不能使用在网站加载后渲染的数据，例如通过 XHR 或 WebSocket 获取的数据。

但是，您可能可以直接使用网站用来获取数据的 API。

一些您可能想在程序中使用的数据示例：

• 法币/加密货币的价格数据

• 银行对账单

• 发票、收据

• 与身份相关的信息，例如年龄或国籍

• 媒体资源

在本示例中，我们将使用阿姆斯特丹的天气数据，并将降水量放入 Aleo 程序中。

https://archive-api.open-meteo.com/v1/archive?latitude=42.93869&longitude=-74.18819&start_date=2024-02-28&end_date=2024-02-28&daily=rain_sum

强烈建议使用对时间不敏感的历史数据。如果使用实时数据，其他人可能会在使用相同参数请求相同 URL 时看到不同的结果。

白名单

公证员维护一个允许认证的主机列表。您可以在 https://sgx.aleooracle.xyz/whitelist 查询该列表。如果您希望将某个主机列入白名单，请联系我们。

当前白名单（该列表可能已过时，请始终从 URL 查询列表）:

[    "google.com",    "api-testnet.bybit.com",    "verifier.aleooracle.xyz",    "api.bitfinex.com",    "api.coinbasecloud.net",    "api-pub.bitfinex.com",    "sgx.aleooracle.xyz",    "api.international.coinbase.com",    "api.bybit.com",    "www.kraken.com",    "pro-api.coinmarketcap.com",    "docs.aleooracle.xyz",    "api.exchange.coinbase.com",    "www.okx.com",    "data-api.binance.vision",    "testnet.binance.vision",    "www.coinbase.com",    "api.kraken.com",    "archive-api.open-meteo.com",    "public.bybit.com",    "api.prime.coinbase.com",    "www.bitstamp.net",    "www.bitfinex.com",    "api.kucoin.com",    "www.kucoin.com",    "api.binance.com",    "api-futures.kucoin.com",    "iapi.kraken.com",    "www.bybit.com"]

第二步：创建 HTTP 请求获取数据

现在您需要创建一个 HTTP 请求，以获取包含您所需数据的返回。

在我们的示例中，请求非常简单。我们执行一个 GET 请求并期望得到一个 JSON 返回数据。

$ curl "https://archive-api.open-meteo.com/v1/archive?latitude=42.93869&longitude=-74.18819&start_date=2024-02-28&end_date=2024-02-28&daily=rain_sum"

响应：

{
  "latitude": 42.917397,
  "longitude": -74.37686,
  "generationtime_ms": 3.921985626220703,
  "utc_offset_seconds": 0,
  "timezone": "GMT",
  "timezone_abbreviation": "GMT",
  "elevation": 117.0,
  "daily_units": {
    "time": "iso8601",
    "rain_sum": "mm"
  },
  "daily": {
    "time": [
      "2024-02-28"
    ],
    "rain_sum": [
      9.90
    ]
  }
}

第三步：从返回数据中选择数据

现在我们已经得到了返回数据，并且知道它的样子，是时候从中提取我们在合约中需要的数据，或称为认证数据。

该 SDK 使用选择器来应用于响应。

对于 HTML 响应，它使用 XPath。

对于 JSON，它使用类似于 JQ 查询语法的 JSON 键路径。

有关示例，请参见 选择器部分。

第四步：构建认证请求

现在您可以将我们到目前为止所做的一切放入源代码中。

认证请求描述了对认证目标的公证请求，认证目标应如何响应以及如何解析其响应以提取目标数据。

认证请求中的所有属性并非都是必需的。

下面我们将描述每个属性并给出示例。

您也可以跳转到 认证请求示例 查看我们的天气示例。

URL

待认证资源的 URL - 认证目标。URL 应不包含方案，假定为 HTTPS。

例子

archive-api.open-meteo.com/v1/archive?latitude=42.93869&longitude=-74.18819&start_date=2024-02-28&end_date=2024-02-28&daily=rain_sum

请求方法

用于向认证目标发送请求的 HTTP 方法。

支持以下方法：

• GET

• POST

选择器

可选的元素选择器，用于从认证资源中提取数据 - HTML 的 XPath，JSON 的 JSON 键路径。 如果未提供或为空，oracle 将对整个响应进行认证，除非响应大小超过 {{ variables.constants.attestation_text_size_limit }} 的限制。

响应格式

预期的认证目标响应格式。

支持的值：

• JSON

• HTML

在我们的示例中，响应格式是 JSON。

HTML 结果类型

当响应格式为 HTML 时，您还需要指明应用选择器后响应的提取类型。

支持的值：

• element

• value

如果应用选择器后的数据是 <a href="/test">Nice link</a>

• 使用 element 将使 <a href="/test">Nice link</a> 成为认证数据

• 使用 value 将使 Nice link 成为认证数据

请求体

可用于提供认证目标请求的 POST 请求体。最大允许大小为 {{ variables.constants.attestation_text_size_limit }}。仅当请求方法为 POST 时生效。

例子

任何 HTTP 请求体

{"userName": "user","firstName": "first","lastName": "last"}

请求内容类型

可用于为认证目标请求提供 Content-Type 请求头。 仅当请求方法为 POST 时生效。

例子

application/json

请求头

可选的 HTTP 请求头字典，用于添加到认证目标请求中。 可能包含敏感信息（如 Authorization、X-Auth-Token 或 Cookie）的头部值以及认证目标使用的任何非标准头部值将在认证报告中被替换为 *****。注意，这些头部将按原样用于认证请求。

SDK 将使用一些默认头部，可以被覆盖。

编码选项

编码选项包含公证后端应如何解释证明数据并将其编码为 Aleo 格式的信息。数据将被编码为 Aleo u128，以便在 Aleo 程序内部使用。

有关编码的更多信息，请参阅 理解证明响应的指南。

编码选项包含两个属性：

• 值类型

• 精度

值类型

定义公证后端如何解释证明数据并将其编码为与 Aleo 兼容的格式。

支持的值类型：

• string - 提取的值是一个字符串

• int - 提取的值是一个无符号十进制整数，最大为 64 位

• float - 提取的值是一个无符号浮点数，最大为 64 位

精度

此属性仅在值类型为 float 时有效。

由于 Aleo 不支持浮点数，因此需要将其表示为整数。

定义提取的证明数据的小数部分应有多少位数字。支持的最大精度为 {{ variables.constants.attestation_precision_limit }}。当值类型为 float 时为必填项。

精度应始终大于或等于提取数字的小数部分的位数。如果数字的小数部分位数多于提供的精度，则将按提供的精度进行切片。

例子

精度：3

- 123.45 -> 123.45
- 123.456 -> 123.456
- 123.4567 -> 123.456

精度：0

- 123.4 -> 123
- 123.456 -> 123

要了解其对 Aleo 编码的证明数据的影响，请参阅《理解证明响应指南》中的“将证明数据作为浮点数”部分。

证明请求示例

现在我们已经涵盖了所有属性，可以看到天气示例的请求是什么样的。

例子

const req = {
    url: 'archive-api.open-meteo.com/v1/archive?latitude=42.93869&longitude=-74.18819&start_date=2024-02-28&end_date=2024-02-28&daily=rain_sum',
    requestMethod: 'GET',
    selector: 'daily.rain_sum.[0]',
    responseFormat: 'json',
    encodingOptions: {
        value: 'float',
        precision: 2
    },
}

第五步：请求证明

一旦我们有了证明请求，我们就可以在客户端上调用 Notarize。

它接受请求和公证选项。

您可以使用所选 SDK 中的测试选择器方法来执行无需证明的公证。

公证后端将尝试请求证明目标并使用提供的选择器提取数据。您可以使用与公证方法相同的请求来查看公证后端是否能够获取您的数据并正确提取数据。您将能够看到完整的响应主体、提取的数据、响应状态代码和错误（如果有）。

Test Selector 和 Notarize 的区别是，如果提取失败，Notarize 将不会返回响应主体。

公证后端将向证明目标发送请求，使用选择器提取数据，然后创建证明报告。

结果将返回到 SDK。然后它将结果发送到验证后端，这将确保公证后端正在运行所需的源代码修订，并且信任链没有被破坏。只有这样，SDK 才会返回来自公证调用的证明结果。

公证选项

数据应匹配

如果使用多个证明者，客户端将检查所有证明响应中的证明数据是否完全相同。

如果所有公证后端的证明都成功但结果不匹配，SDK 将返回错误。

超时

证明请求超时（以毫秒为单位）。如果未设置，将使用默认值（取决于环境）。

最大时间偏差

如果使用多个证明者，此选项可控制证明时间戳之间的最大偏差（以毫秒为单位）。

• 如果设置为 0，则要求所有证明同时完成（不推荐）。请注意，证明时间戳由证明服务器使用服务器时间设置。

• 如果未设置，则不执行时间偏差检查。

• 如果将时间偏差设置为小于一秒，由于 Oracle SDK、公证后端和证明目标之间自然发生的网络延迟，证明可能会失败。

• 如果偏差设置为超过 10 秒（10 * 1000 毫秒），如果其中一个请求花费的时间太长，并且请求的信息已发生更改或不再可用，则证明目标响应可能会彼此不同。

Aleo 官方链接：

• Aleo Twitter

• Aleo Discord

• Aleo Website

• Aleo Github

区块链中的 Oracle 是什么？

"区块链 Oracle 是将区块链与外部系统连接的实体，从而使智能合约能够根据现实世界的输入和输出执行。"

Chainlink: 什么是区块链 Oracle?

在区块链领域，信任具有极大的重要性。由于区块链的问题在于达成共识，外部信息不能与交易数据一起提供，因为其他节点会检测到来自“不可信”来源的信息。因此，来自现实世界的信息应该来自一个单一的第三方来源，其可靠性是所有节点都无可争议的：这就是 Oracle。不幸的是，使用 Oracle 引入了一个被称为区块链 Oracle 问题的问题。

区块链 Oracle 问题

"区块链 Oracle 问题指的是：无法确认 Oracle 收集的数据的真实性。此外，根据类型的不同，发生故障和故意篡改的可能性也存在。"

"由于 Oracle 不是分布式的，它们重新引入了单点故障。此外，由于它们处理的是非确定性数据，其可靠性需要被信任，这取消了信任最小化的点对点交互。通过智能合约将其实现到区块链中，也可能损害用户对区块链的信任，他们认为区块链比传统系统更可靠。"

"即使数据是可信和经过验证的，Oracle 也可能由于故障或故意篡改而在智能合约上操作不正确。"

学术社区百科全书: 区块链 Oracle 问题

Aleo Oracle 解决方案

Aleo Oracle 通过使用以下组件组合来尽量减少上述问题：

• 完全透明；

• 使用 TEE 进行 TLS 响应公证；

• Aleo 零知识证明；

环境

"可信执行环境（TEE）是主处理器的一个安全区域。它有助于保护加载其中的代码和数据的机密性和完整性。数据完整性防止未经授权的实体从 TEE 外部篡改数据，而代码完整性防止 TEE 内的代码被未经授权的实体替换或修改..."

"... 允许用户级代码分配私有内存区域，称为飞地，这些区域被设计为受到在更高特权级别运行的进程的保护。作为一个隔离的执行环境，TEE 提供了安全功能，如隔离执行、在 TEE 内执行的应用程序的完整性以及它们资产的机密性。"

维基百科: 可信执行环境

为了透明，使用 TEE 仍然涉及一定程度的信任，特别是在 TEE 提供者实现隔离计算环境的过程中。 历史上，TEE，如 Intel 的 SGX，曾面临挑战和漏洞，但它们已被随后解决。

使用 TEE 解决了许多已知的区块链 Oracle 问题。

通过拥有开源代码、可重现的构建和源代码签名，用户可以验证数据的真实性，并确保 Oracle 正常运行并执行其预期功能。

Oracle 客户端支持在不同 TEE 中的多个公证后端，从而消除了单点故障。

Aleo Oracle 架构

在高层次上，Oracle 架构由以下部分组成：

• Oracle 客户端

• 一个或多个运行在 TEE 内的 Oracle 公证后端

• Oracle 验证后端

• Oracle Aleo 程序

架构图

以下图表展示了当应用程序使用 Oracle 客户端获取和验证数据时发生的事情，然后展示了应用程序如何在 Aleo 区块链中使用这些数据。

获取和验证数据的 Oracle 客户端序列图

客户端获取数据后的 Aleo 程序序列图

Oracle 客户端

Oracle 客户端是一个需要以安全方式从 web2.0 获取数据的 dApp。这很可能是你——开发者！

通过使用 Oracle SDK，你可以集成请求 web2.0 资源并在 Aleo 区块链和你的 dApp 中使用它们的功能。

根据具体的使用案例，你可以使用已部署的特定应用程序的 Oracle 程序，也可以开发自己的程序。

如果你只需要消费已提交到现有 Oracle 程序的数据，则不需要客户端。

请参阅使用 Oracle获取关于使用 Oracle SDK 和示例的教程。

Oracle 后端

Oracle 后端接收来自客户端的公证请求。请求包含有关需要公证的 web2.0 资源的信息、如何访问它、如何从资源中提取相关数据并对其进行编码以供后续使用。

后端执行对指定资源的 HTTPS 请求，接收响应，然后将选择器应用于响应正文，从资源中生成相关信息。

结果由 TEE 飞地签名和验证。

Oracle 验证后端

Oracle 验证后端接收公证响应并验证公证报告。步骤之一是验证公证飞地的唯一 ID 是否与预期的匹配。这是通过 Oracle 公证后端的可重现构建完成的。

该后端还能够解码 Aleo 编码的报告数据，解码和验证 Aleo 编码的公证报告，例如，如果你想验证他人的报告/数据。

你可以按照本指南自行托管此后端。

Oracle 程序

一个能够接受 Oracle 公证报告和公证数据的 Aleo 程序。有关其工作原理的更多信息，请参阅关于 Oracle 程序的指南。

Aleo 官方链接：

• Aleo Twitter

• Aleo Discord

• Aleo Website

• Aleo Github

证明者在 Aleo 网络中扮演关键角色，他们通过解决 coinbase 谜题并生成 zkProofs 来获得奖励。

本教程适用于在 7 月 1 日至 15 日进行 Testnet Beta 的测试激励活动，但是该激励活动到目前已经截止，但是这个教程和后面主网的挖矿教程类似，不会有太大变化，可以作为后期主网证明者节点部署的参考。

snarkOS 是 zk 应用程序的去中心化操作系统。它构成了 Aleo 网络的基础，验证交易并以可公开验证的方式存储应用程序的加密状态。

构建 snarkOS 的指南：

要求：

• 操作系统：仅 64 位架构，更新到最新版本以确保安全

• CPU：32 核（证明者和验证者首选 64 核）

• 内存：客户端 32GB，验证者 64GB（首选 128GB）

• 存储：客户端 300GB，验证者 2TB（首选 4TB）

• 网络：理论上越快越好

• GPU：支持 CUDA（证明者可选）

安装步骤：

确保已安装 Rust v1.79+。安装说明可以在 这里 找到。

克隆 GitHub 仓库：

git clone --branch mainnet --single-branch https://github.com/AleoNet/snarkOS.git

进入 snarkOS 目录：

cd snarkOS
git checkout tags/testnet-beta

[对于 Ubuntu 用户] 运行帮助脚本：

./build_ubuntu.sh

安装 snarkOS：

cargo install --locked --path .

确保路由器和操作系统防火墙上打开端口 4130/tcp 和 3030/tcp。

运行 Aleo 节点：

运行 Aleo 客户端：

按照安装说明进行操作。

启动客户端节点：

./run-client.sh

运行 Aleo 证明者：

按照安装说明进行操作。

生成 Aleo 账户地址：

snarkos account new

保存私钥、查看密钥和地址。

启动证明节点：

./run-prover.sh

在提示时输入您的 Aleo 私钥。

命令行界面：

要使用自定义设置运行节点，请参考 snarkOS CLI 中可用的选项和标志。

使用 snarkos --help 查看完整的 CLI 标志和选项列表：

snarkOS
The Aleo Team <hello@aleo.org>

USAGE:
    snarkos [OPTIONS] <SUBCOMMAND>

OPTIONS:
    -h, --help                     打印帮助信息
    -v, --verbosity <VERBOSITY>    指定详细程度 [选项: 0, 1, 2, 3] [默认: 2]

SUBCOMMANDS:
    account    管理 Aleo 账户的命令
    clean      清理 snarkOS 节点存储
    help       打印此消息或给定子命令的帮助信息
    start      启动 snarkOS 节点
    update     更新 snarkOS

以下是 snarkos start 命令的选项：

USAGE:
    snarkos start [OPTIONS]

OPTIONS:
        --network <NETWORK_ID>                  指定此节点的网络 ID [默认: 3]
        
        --validator                             指定此节点为验证者
        --prover                                指定此节点为证明者
        --client                                指定此节点为客户端
        
        --private-key <PRIVATE_KEY>             指定节点账户的私钥
        --private-key-file <PRIVATE_KEY_FILE>   指定包含节点账户私钥的文件路径
        
        --node <IP:PORT>                        指定节点服务器的 IP 地址和端口 [默认: 0.0.0.0:4130]
        --connect <IP:PORT>                     指定要连接的对等节点的 IP 地址和端口
 
        --rest <REST>                           指定 REST 服务器的 IP 地址和端口 [默认: 0.0.0.0:3030]
        --norest                                如果设置此标志，节点将不会初始化 REST 服务器
        
        --nodisplay                             如果设置此标志，节点将不会渲染显示
        --verbosity <VERBOSITY_LEVEL>           指定节点的详细程度 [选项: 0, 1, 2, 3] [默认: 2]
        --logfile <PATH>                        指定日志存储的文件路径 [默认: /tmp/snarkos.log]
        
        --dev <NODE_ID>                         启用开发模式，指定此节点的唯一 ID

开发指南：

快速开始。 在第一个终端中，运行以下命令启动第一个验证者：

cargo run --release -- start --nodisplay --dev 0 --validator

在第二个终端中，运行以下命令启动第二个验证者：

cargo run --release -- start --nodisplay --dev 1 --validator

在第三个终端中，运行以下命令启动第三个验证者：

cargo run --release -- start --nodisplay --dev 2 --validator

在第四个终端中，运行以下命令启动第四个验证者：

cargo run --release -- start --nodisplay --dev 3 --validator

从这里开始，可以使用此过程进一步启动证明者和客户端。

操作：

从 0 开始初始化节点，并为每个新节点递增 1 是很重要的。 以下是初始化节点的选项列表（将 替换为从 0 开始的数字）： cargo run --release -- start --nodisplay --dev <NODE_ID> --validator cargo run --release -- start --nodisplay --dev <NODE_ID> --prover cargo run --release -- start --nodisplay --dev <NODE_ID> --client cargo run --release -- start --nodisplay --dev <NODE_ID> 当未指定节点类型时，节点将默认为 --client。 本地开发网络： 安装 tmux。要使用脚本运行本地开发网络，请先安装 tmux。 启动本地开发网络。要启动本地开发网络，请运行： ./devnet.sh 按照终端中的说明启动开发网络。 查看本地开发网络。切换节点（前进）。要切换到本地开发网络中的下一个节点，请运行： Ctrl+b n 切换节点（向后）。要切换到本地开发网络中的上一个节点，请运行： Ctrl+b p 选择节点（选择树）。要在本地开发网络中选择一个节点，请运行： Ctrl+b w 手动选择节点。要在本地开发网络中手动选择节点，请运行： Ctrl+b :select-window -t {NODE_ID} 停止本地开发网络。要停止本地开发网络，请运行： Ctrl+b :kill-session 然后，按 Enter。 清理。要清理节点存储，请运行： cargo run --release -- clean --dev <NODE_ID> 本指南涵盖了安装和使用 snarkOS 以参与 Aleo 测试网 Beta 证明者激励计划的基本步骤。按照提供的详细说明，您可以设置并运行 Aleo 节点，无论是作为客户端还是证明者，并为验证 coinbase 奖励机制做出贡献。 注意：以上的方式是作为 Solo 模式参与的证明者，从目前的测试网运行结果来看，参与的挖矿难度特别高，如果不是持有大量机器，可以考虑加入矿池确保能够获得奖励。 Aleo 官方链接： Aleo Twitter Aleo Discord Aleo Website Aleo Github

在 Leo 编程语言中，Finalize 是一种机制，用于在智能合约执行结束时对合约状态进行最终的处理和清理。这种方法确保合约在完成所有操作后，能够正确地更新和持久化状态，并执行任何必要的清理工作。

但是在最新的 Leo 代码中 Finalize 语法已经废弃了，这里在最新的 Testbeta 网络中得到了验证。Async/Await 机制用于替代传统的 Finalize 方法，以简化和优化智能合约的状态更新和清理过程。这种方式通过异步编程模型，使代码更易读、更高效，并且避免了传统 Finalize 方法中的一些局限性。

Leo 中的 Async/Await

概念介绍

• Async：定义一个异步函数，该函数可以包含异步操作。异步函数不会立即执行，而是返回一个 Future 对象，当需要结果时，可以等待该 Future 完成。

• Await：用于等待异步函数的执行，直到异步操作完成，并返回结果。

主要优点

1. 简化代码结构：Async/Await 使异步代码看起来像同步代码一样，减少了回调地狱和复杂的状态管理。

2. 提高性能：通过异步编程模型，可以在等待异步操作完成时，执行其他任务，提高合约的执行效率。

3. 避免 Finalize 局限：直接在合约执行过程中处理状态更新和清理，避免了 Finalize 方法的额外复杂性。

Finalize 和 Async/Await 在实际使用中的区别

• 旧版本的 Finalize 语法

program test1.aleo {

    // 示例映射数据以存储全局状态
    mapping data: u32 => u32; 

    // 执行链上逻辑的异步过渡
    transition main(public x: u32) -> u32 {
    
        // 链下逻辑：根据输入 x 计算一个值
        let off_chain_result: u32 = compute_off_chain(x);

        // 链上逻辑：使用链下结果更新全局状态
        return off_chain_result then finalize (off_chain_result));
        
    }

    // 异步函数以 finalize 更新链上的全局状态
    finalize main (off_chain_result: u32) {
    
        // 将 off_chain_result 值加到 x_1
        let x_1: u32 = off_chain_result + 2u32;

        // 将 off_chain_result 值加到 x_2
        let x_2: u32 = off_chain_result + 5u32;

        // 条件语句：检查 x_1 是否大于 x_2
        // 如果是，则将 x_1 输出，否则将 x_2 输出到映射 (data)
        let final_value: u32 = (x_1 > x_2) ? x_1 : x_2;

        // 设置映射中的值
        Mapping::set(data, 0u32, final_value);
    }

    // 链下函数，根据输入 x 计算一个值
    function compute_off_chain(x: u32) -> u32 {
    
        // 简单计算：将输入值加倍
        return x * 2u32;
        
    }
}

• 最新的 Async/Await 语法

program test1.aleo {

    // 示例映射数据以存储全局状态
    mapping data: u32 => u32; 

    // 执行链上逻辑的异步过渡
    async transition main(public x: u32) -> (u32, Future) {
    
        // 链下逻辑：根据输入 x 计算一个值
        let off_chain_result: u32 = compute_off_chain(x);

        // 链上逻辑：使用链下结果更新全局状态
        return (off_chain_result, finalize_update(off_chain_result));
        
    }

    // 异步函数以 finalize 更新链上的全局状态
    async function finalize_update(off_chain_result: u32) {
    
        // 将 off_chain_result 值加到 x_1
        let x_1: u32 = off_chain_result + 2u32;

        // 将 off_chain_result 值加到 x_2
        let x_2: u32 = off_chain_result + 5u32;

        // 条件语句：检查 x_1 是否大于 x_2
        // 如果是，则将 x_1 输出，否则将 x_2 输出到映射 (data)
        let final_value: u32 = (x_1 > x_2) ? x_1 : x_2;

        // 设置映射中的值
        Mapping::set(data, 0u32, final_value);
        
    }

    // 链下函数，根据输入 x 计算一个值
    function compute_off_chain(x: u32) -> u32 {
    
        // 简单计算：将输入值加倍
        return x * 2u32;
        
    }
}

关键概念

1. 异步函数和过渡：

   • 异步函数可以定义为异步运行。这些函数返回一个 Future，表示将来某个时间点将执行的代码。

   • 异步过渡是特殊类型的异步函数，可以调用它们来在区块链上执行状态更改。

2. Futures：

   • Future 是表示将来某个时间点可用值的对象。在 async/await 语法中，函数不直接返回值；它们返回 Futures。

Async/Await 语法规则

1. 调用异步函数：

   • 只能在异步过渡内部调用异步函数。

   • 异步函数不能直接返回值；它们返回一个 Future。

2. 异步过渡：

   • 不能在条件块内调用异步过渡。

   • 异步过渡调用返回一个可选值，并且必须返回一个单一的 Future。

   • 异步过渡调用生成的 Future 不能被返回。

3. 处理 Futures：

   • Future 可以传递给异步函数调用，必须等待它。

   • 所有 Futures 必须由异步函数调用消费或作为输出返回。

总结

Leo 语言通过引入 Async/Await 机制，简化了智能合约中异步操作的编写和管理过程。相比传统的 Finalize 方法，Async/Await 提供了一种更自然、更高效的方式来处理状态更新和清理，提高了代码的可读性和执行效率。

希望这些解释和示例能够帮助你更好地理解和使用 Leo 中的 Async/Await 特性。如果有具体问题或需求，请随时进一步讨论或提供详细信息。

Aleo 官方链接：

• Aleo Twitter

• Aleo Discord

• Aleo Website

• Aleo Github

核心概念

1. 零知识证明（Zero-Knowledge Proof）： 零知识证明是一种密码学技术，允许证明者（Prover）向验证者（Verifier）证明某个声明是真实的，而无需提供任何除了声明真实性以外的额外信息。验证者可以确信声明的真实性，但不会得到任何其他的信息。

2. 凭证（Credential）： 凭证是一种包含用户身份信息的数据结构。在 Zpass 协议中，凭证通常由一个可信的签发机构（Issuer）签发，并包含用户的某些属性（如出生日期、国籍等）。

3. 签发机构（Issuer）： 签发机构是一个可信的实体，如政府、公司等，负责签发凭证。凭证包含签发机构的签名，以证明其真实性。

4. 验证者（Verifier）： 验证者是需要验证用户身份信息的实体。在 Zpass 协议中，验证者通过验证凭证的签名和零知识证明来确认用户的身份信息，而不需要知道具体的细节。

典型应用场景

1. 年龄验证： 用户可以通过 Zpass 协议向验证者证明自己超过某个年龄（如18岁），而无需透露具体的出生日期。

2. 访问控制： 用户可以证明自己拥有某些权限（如会员资格、访问权限等），而无需透露具体的权限细节或身份信息。

3. 资格证明： 用户可以证明自己具有某些资格（如学历、证书等），而无需透露具体的资格细节。

Zpass 的优势

1. 隐私保护： 用户不需要透露具体的身份信息，只需提供零知识证明，验证者就可以确认用户身份的真实性。

2. 安全性： 凭证由可信的签发机构签发，并使用加密技术保护，确保凭证的真实性和完整性。

3. 灵活性： Zpass 可以应用于多种场景，包括年龄验证、访问控制、资格证明等，具有广泛的适用性。

例子

假设有一个年龄验证的例子，如前面的代码所示，Zpass 协议可以如下工作：

1. 签发凭证： 签发机构签发包含用户出生日期的凭证，并用自己的私钥对凭证进行签名。

2. 生成零知识证明： 用户根据自己的出生日期生成零知识证明，证明自己年满18岁，但不透露具体的出生日期。

3. 验证零知识证明： 验证者接收到用户提供的零知识证明和凭证，验证凭证的签名和零知识证明的有效性，从而确认用户年满18岁。

以下是具体的代码实现：

program age_verification.aleo {

    // 时间戳辅助函数
    struct date_time {
        seconds: u8,        // 秒
        minutes: u8,        // 分钟
        hours: u8,          // 小时
        day: u8,            // 日
        month: u32,         // 月
        year: u32,          // 年
    }

    function timestamp_to_datetime(t: u32) -> date_time {
        let seconds: u32 = t % 60u32;
        t /= 60u32;

        let minutes: u32 = t % 60u32;
        t /= 60u32;

        let hours: u32 = t % 24u32;
        t /= 24u32;

        let a: u32 = (4u32 * t + 102032u32) / 146097u32 + 15u32;
        let b: u32 = t + 2442113u32 + a - (a / 4u32);
        let c: u32 = (20u32 * b - 2442u32) / 7305u32;
        let d: u32 = b - 365u32 * c - (c / 4u32);
        let e: u32 = d * 1000u32 / 30601u32;
        let f: u32 = d - e * 30u32 - e * 601u32 / 1000u32;
        let g: u32 = 4716u32;
        let h: u32 = 1u32;

        if (e > 13u32) {
            g = 4715u32;
            h = 13u32;
        }

        c -= g;
        e -= h;

        let dt: date_time = date_time {
            seconds: seconds as u8,
            minutes: minutes as u8,
            hours: hours as u8,
            day: f as u8,
            month: e as u32,
            year: c as u32,
        };

        return dt;
    }

    function datetime_to_timestamp(dt: date_time) -> u32 {
        let y: u32 = dt.year as u32;
        let m: u32 = dt.month as u32;
        let d: u32 = dt.day as u32;

        if (m <= 2u32) {
            m += 12u32;
            y -= 1u32;
        }

        let t: u32 = (365u32 * y) + (y / 4u32) - (y / 100u32) + (y / 400u32);
        t += (30u32 * m) + (3u32 * (m + 1u32) / 5u32) + d;
        t -= 719561u32;
        t *= 86400u32;
        t += (3600u32 * dt.hours as u32) + (60u32 * dt.minutes as u32) + dt.seconds as u32;

        return t;
    }

    struct Credentials {
        issuer: address,
        subject: address,
        dob: u32,
        nationality: field,
        expiry: u32
    }

    inline get_psd_hash(msg: Credentials) -> field {
        return Poseidon2::hash_to_field(msg);
    }

    inline get_bhp_hash(msg: Credentials) -> field {
        return BHP1024::hash_to_field(msg);
    }

    function get_hash(hash_type: u8, msg: Credentials) -> field {
        if (hash_type.eq(1u8)) {
            return get_bhp_hash(msg);
        }
        return get_psd_hash(msg);
    }

    function signature_verification(msg_hash: field, sig: signature, issuer: address) -> bool {
        return signature::verify(sig, issuer, msg_hash);
    }

    transition verify(
        sig: signature,
        hash_type: u8,
        currentDate: u32,
        msg: Credentials,
    ) -> bool {
        let dob: date_time = timestamp_to_datetime(msg.dob);
        let current: date_time = timestamp_to_datetime(currentDate);
        let age: u32 = current.year - dob.year;

        return ( age.gte(18u32) &&
            signature_verification(get_hash(hash_type, msg), sig, msg.issuer));
    }
}

上面这段代码是一个基于 aleo 的零知识证明程序，用于验证用户是否超过特定年龄（例如18岁）。这个程序假设由一个受信任的机构签发了包含用户信息的凭证，并且验证者可以使用这些凭证来验证用户的年龄，而无需知道用户的实际出生日期。

主要组件

1. 凭证结构（Credential Structure）

2. 验证逻辑（Verification Logic）

3. 辅助函数（Helper Functions）

具体解释

凭证结构

struct Credentials {
    issuer: address,
    subject: address,
    dob: u32,
    nationality: field,
    expiry: u32
}

Credentials 结构包含以下字段：

• issuer: 签发机构的地址。

• subject: 持有人的地址。

• dob: 出生日期，以时间戳表示。

• nationality: 国籍。

• expiry: 过期日期，以时间戳表示。

辅助函数

这些函数用于日期和时间戳之间的转换。

struct date_time {
    seconds: u8,
    minutes: u8,
    hours: u8,
    day: u8,
    month: u32,
    year: u32,
}

function timestamp_to_datetime(t: u32) -> date_time {
    // 省略的代码：将时间戳转换为日期时间结构
}

function datetime_to_timestamp(dt: date_time) -> u32 {
    // 省略的代码：将日期时间结构转换为时间戳
}

这些函数将 UNIX 时间戳转换为日期时间结构，反之亦然。

哈希函数

用于计算凭证的哈希值。Poseidon 和 BHP1024 是两种不同的哈希算法。

inline get_psd_hash(msg: Credentials) -> field {
    return Poseidon2::hash_to_field(msg);
}

inline get_bhp_hash(msg: Credentials) -> field {
    return BHP1024::hash_to_field(msg);
}

function get_hash(hash_type: u8, msg: Credentials) -> field {
    if (hash_type.eq(1u8)) {
        return get_bhp_hash(msg);
    }
    return get_psd_hash(msg);
}

签名验证

用于验证凭证的签名。

function signature_verification(msg_hash: field, sig: signature, issuer: address) -> bool {
    return signature::verify(sig, issuer, msg_hash);
}

验证函数

主要的验证逻辑，检查用户是否年满18岁，并验证凭证签名。

transition verify(
    sig: signature,
    hash_type: u8,
    currentDate: u32,
    msg: Credentials,
) -> bool {
    let dob: date_time = timestamp_to_datetime(msg.dob);
    let current: date_time = timestamp_to_datetime(currentDate);
    let age: u32 = current.year - dob.year;

    return (age.gte(18u32) &&
        signature_verification(get_hash(hash_type, msg), sig, msg.issuer));
}

验证过程

1. 时间戳转换：将出生日期和当前日期的时间戳转换为日期时间结构。

2. 年龄计算：计算当前年份与出生年份的差值。

3. 年龄检查：检查年龄是否大于等于18。

4. 签名验证：使用选择的哈希算法验证凭证的签名是否正确。

通过以上步骤，可以在零知识的情况下验证用户是否超过特定年龄，而无需透露实际的出生日期或其他个人信息。

Aleo 官方链接：

• Aleo Twitter

• Aleo Discord

• Aleo Website

• Aleo Github

1. 用户敏感信息泄露

2. 用户无法控制私钥导致资产丢失

3. 非透明和链下交易过程

4. 易受网络攻击

为了解决这些问题，去中心化交易所（DEX）提供了隐私、透明度、安全性和自主性的替代方案：

1. 用户可以管理和控制自己的钱包和私钥

2. 链上交易透明且可追踪

3. 相比 CEX 更高的安全性和抗风险能力

PrivX 是一个基于 Aleo 的去中心化交易所，将为生态系统带来巨大价值。通过利用 Aleo 的隐私特性，PrivX 确保了加密交易的匿名性和安全性，消除了中心化的担忧。它提升了流动性，吸引了注重隐私的用户，将 Aleo 打造成私密和安全交易的领先区块链平台。此外，PrivX 还将为 Aleo 生态系统带来以下好处：

1. 吸引新用户：PrivX 的隐私特性可以吸引那些寻找安全和私密交易方式的新用户加入 Aleo 生态系统。

2. 增加采用率：通过隐私保护 DEX 的存在，可以提高 Aleo 的采用率，因为 PrivX 将使用户更容易访问和交易基于 Aleo 的资产。

3. 促进新隐私应用的开发：PrivX 的存在可以促进新隐私应用的开发，我们的团队将与这些新项目合作，共同推动生态系统的发展。

PrivX 选择 Aleo 作为其创新 DEX 的开发平台，主要是因为 Aleo 卓越的链上隐私保护。Aleo 的零知识证明技术允许用户在进行交易时隐藏账户余额、交易活动等敏感信息，从而确保强大的隐私保护。

尽管 DEX 有其优势，但在交易性能和流动性方面，仍存在一些不足。为了解决这些问题，PrivX 开发了一种独特的机制，将 CEX 的流动性和用户体验与 DEX 的透明性相结合。推出了首个隐私订单簿 DEX，在 Aleo 平台上具备无与伦比的链上隐私保护机制。

您可以在这里找到项目的源码。

构建 要编译这个 Aleo 程序，请运行：

介绍

在 PrivX 进行交易，可以保护您的隐私，下面介绍 PrivX 核心合约的结构和提供的方法：

数据映射

• credits_balance: 存储用户的余额

• credits_deposited: 存储用户的存款，可用于购买其他代币

• credits_locked: 存储用户锁定的余额，用于买单

• token_balances: 存储用户的代币余额

• token_deposited: 存储用户的代币存款，可用于购买其他代币

• token_locked: 存储用户锁定的代币，用于卖单

• sequence: 生成序列 ID 的解决方法

结构

• Order: 订单所需的数据

功能

1. mint_credits

   • 参数：

     • address: 接收余额的地址

     • amount: 铸造的余额数量

   • 描述：铸造指定数量的余额到指定地址。

2. deposit_credits

   • 参数：

     • amount: 从 credits_balance 转移到 credits_deposited 的余额数量

   • 描述：从 credits_balance 中转移指定数量的余额到 credits_deposited。

3. withdraw_credits

   • 参数：

     • amount: 从 credits_deposited 转移到 credits_balance 的余额数量

   • 描述：从 credits_deposited 中转移指定数量的余额到 credits_balance。

4. mint_token

   • 参数：

     • address: 接收代币的地址

     • amount: 铸造的代币数量

   • 描述：铸造指定数量的 ARC20 代币到指定地址。

5. deposit_token

   • 参数：

     • amount: 从 token_balance 转移到 token_deposited 的代币数量

   • 描述：从 token_balance 中转移指定数量的代币到 token_deposited。

6. withdraw_token

   • 参数：

     • amount: 从 token_deposited 转移到 token_balance 的代币数量

   • 描述：从 token_deposited 中转移指定数量的代币到 token_balance。

7. buy

   • 参数：

     • quantity: 订单数量

     • price: 单个代币愿意支付的价格

   • 描述：减少 credits_deposited，增加 credits_locked，并生成一个带有序列 ID 的新买单。

8. sell

   • 参数：

     • quantity: 订单数量

     • price: 单个代币愿意出售的价格

   • 描述：减少 token_deposited，增加 token_locked，并生成一个带有序列 ID 的新卖单。

9. knockdown

   • 参数：

     • sell_order_id: 交易的卖单 ID

     • buy_order_id: 交易的买单 ID

   • 描述：指定一个卖单 ID 和一个买单 ID，检查交易条件是否满足，如果满足，则完成交易。

10. cancel

    • 参数：

      • order_id: 需要取消的订单 ID

    • 描述：取消属于调用者的订单，将锁定的金额返回到存款金额中。

总结

PrivX 作为 Aleo 上的去中心化交易所，不仅解决了传统中心化交易所的诸多问题，还为用户提供了高度隐私保护的交易平台。Aleo 的零知识证明技术确保了交易的隐私性，用户可以安全、匿名地进行加密货币交易。此外，PrivX 的独特机制结合了 CEX 的流动性和用户体验，同时保持了 DEX 的透明性。相信 PrivX 将吸引更多注重隐私的用户，促进 Aleo 生态系统的进一步发展。

Aleo 官方链接：

• Aleo Twitter

• Aleo Discord

• Aleo Website

• Aleo Github

功能

创建代币

• 功能: create_token

• 参数: info: TokenInfo (包括代币名称、符号、小数位和总供应量)

• 命令示例:

  snarkos developer execute -q $rpc_url -b $broadcast_url -p $private_key -r $fee_record \
    $program_id create_token "{name: 1431520340field, symbol: 1431520340field, decimals: 6u8, total_supply: 100000000000000u128, admin: $admin_addr}"
  

转账

• 功能: transfer

• 参数: token_id: field, to: address, amount: u128

• 命令示例:

  snarkos developer execute -q $rpc_url -b $broadcast_url -p $private_key -r $fee_record \
    $program_id transfer 1field $to_address 100000000u128
  

授权

• 功能: approve

• 参数: token_id: field, spender: address, amount: u128

• 命令示例:

  snarkos developer execute -q $rpc_url -b $broadcast_url -p $private_key -r $fee_record \
    $program_id approve 1field $spender 10000000000u128
  

从账户转账

• 功能: transfer_from

• 参数: token_id: field, from: address, to: address, amount: u128

• 命令示例:

  snarkos developer execute -q $rpc_url -b $broadcast_url -p $private_key -r $fee_record \
    $program_id transfer_from 1field $from_addr $to_addr 100000000u128
  

转为私有

• 功能: transfer_to_private

• 参数: token_id: field, to: address, amount: u128

• 命令示例:

  snarkos developer execute -q $rpc_url -b $broadcast_url -p $private_key -r $fee_record \
    $program_id transfer_to_private 1field $to_addr 100000000u128
  

转为公共

• 功能: transfer_to_public

• 参数: pt_in: PrivateToken, to: address, amount: u128

• 命令示例:

  snarkos developer execute -q $rpc_url -b $broadcast_url -p $private_key -r $fee_record \
    $program_id transfer_to_public $private_token_record $to_addr 10000000u128
  

私有转账

• 功能: transfer_privately

• 参数: pt_in: PrivateToken, to: address, amount: u128

• 命令示例:

  snarkos developer execute -q $rpc_url -b $broadcast_url -p $private_key -r $fee_record \
    $program_id transfer_privately $private_token_record $to_addr 50000000u128
  

合并代币

• 功能: join

• 参数: pt1: PrivateToken, pt2: PrivateToken

• 命令示例:

  snarkos developer execute -q $rpc_url -b $broadcast_url -p $private_key -r $fee_record \
    $program_id join $private_token_record_1 $private_token_record_2
  

创建交易对

• 功能: create_pair

• 参数: token_a: field, token_b: field, amount_a: u128, amount_b: u128, to: address

• 命令示例:

  snarkos developer execute -q $rpc_url -b $broadcast_url -p $private_key -r $fee_record \
    $program_id create_pair 1field 2field 100000000u128 10000000000u128 $to_addr
  

私密创建交易对

• 功能: create_pair_privately

• 参数: pt_a: PrivateToken, pt_b: PrivateToken, amount_a: u128, amount_b: u128, to: address, liquidity: u128

• 命令示例:

  snarkos developer execute -q $rpc_url -b $broadcast_url -p $private_key -r $fee_record \
    $program_id create_pair_privately $private_token_record_1 $private_token_record_2 $to_addr $liquidity
  

增加流动性

• 功能: add_liquidity

• 参数: token_a: field, token_b: field, amount_a: u128, amount_b: u128, min_a: u128, min_b: u128, to: address

• 命令示例:

  snarkos developer execute -q $rpc_url -b $broadcast_url -p $private_key -r $fee_record \
    $program_id add_liquidity 1field 2field 100000000u128 10000000000u128 0u128 0u128 $to_addr
  

私密增加流动性

• 功能: add_liquidity_privately

• 参数: pt_a: PrivateToken, pt_b: PrivateToken, amount_a: u128, amount_b: u128, min_a: u128, min_b: u128, min_liquidity: u128, to: address, refund_to: address

• 命令示例:

  snarkos developer execute -q $rpc_url -b $broadcast_url -p $private_key -r $fee_record \
    $program_id add_liquidity_privately $private_token_record_1 $private_token_record_2 $to_addr $refund_to
  

移除流动性

• 功能: remove_liquidity

• 参数: token_a: field, token_b: field, liquidity: u128, min_a: u128, min_b: u128, to: address

• 命令示例:

  snarkos developer execute -q $rpc_url -b $broadcast_url -p $private_key -r $fee_record \
    $program_id remove_liquidity 1field 2field 1000000000u128 0u128 0u128 $to_addr
  

私密移除流动性

• 功能: remove_liquidity_privately

• 参数: token_a: field, token_b: field, pt_lp: PrivateToken, liquidity: u128, min_a: u128, min_b: u128, to: address, refund_to: address

• 命令示例:

  snarkos developer execute -q $rpc_url -b $broadcast_url -p $private_key -r $fee_record \
    $program_id remove_liquidity_privately $private_token_record $to_addr $refund_to
  

包装私有积分

• 功能: wrap_private_credits

• 参数: input: credits.leo/credits, to: address, amount: field, holder: address

• 命令示例:

  snarkos developer execute -q $rpc_url -b $broadcast_url -p $private_key -r $fee_record \
    $program_id wrap_private_credits $input_record $to_addr 10000000field $holder_addr
  

包装公共积分

• 功能: wrap_public_credits

• 参数: to: address, amount: field, holder: address

• 命令示例:

  snarkos developer execute -q $rpc_url -b $broadcast_url -p $private_key -r $fee_record \
    $program_id wrap_public_credits $to_addr 10000000field $holder_addr
  

解包

• 功能: unwrap

• 参数: to: address, amount: field, into_private: bool

• 命令示例:

  snarkos developer execute -q $rpc_url -b $broadcast_url -p $private_key -r $fee_record \
    $program_id unwrap $to_addr 10000000field true
  

处理私有解包

• 功能: handle_unwrap_to_private

• 参数: index: u64, to: address, amount: field

• 命令示例:

  snarkos developer execute -q $rpc_url -b $broadcast_url -p $private_key -r $fee_record \
    $program_id handle_unwrap_to_private 0u64 $to_addr 10000000field
  

处理公共解包

• 功能: handle_unwrap_to_public

• 参数: index: u64, to: address, amount: field

• 命令示例:

  snarkos developer execute -q $rpc_url -b $broadcast_url -p $private_key -r $fee_record \
    $program_id handle_unwrap_to_public 1u64 $to_addr 10000000field
  

固定数量代币换取代币

• 功能: swap_exact_tokens_for_tokens

• 参数: token_in: field, token_out: field, amount_in: u128, amount_out_min: u128, to: address

• 命令示例:

  snarkos developer execute -q $rpc_url -b $broadcast_url -p $private_key -r $fee_record \
    $program_id swap_exact_tokens_for_tokens 1field 2field 1000000u128 98000000u128 $to_addr
  

私有代币换取公共代币

• 功能: swap_exact_private_for_public

• 参数: pt_in: PrivateToken, token_out: field, amount_in: u128, amount_out_min: u128, to: address

• 命令示例:

  snarkos developer execute -q $rpc_url -b $broadcast_url -p $private_key -r $fee_record \
    $program_id swap_exact_private_for_public $private_token_record $to_addr 98000000u128
  

私有代币换取私有代币

• 功能: swap_exact_private_for_private

• 参数: pt_in: PrivateToken, token_out: field, amount_in: u128, amount_out_min: u128, to_pri: address, to_pub: address

• 命令示例:

  snarkos developer execute -q $rpc_url -b $broadcast_url -p $private_key -r $fee_record \
    $program_id swap_exact_private_for_private $private_token_record $to_pri $to_pub 98000000u128
  

公共代币换取私有代币

• 功能: swap_exact_public_for_private

• 参数: token_in: field, token_out: field, amount_in: u128, amount_out_min: u128, to_pri: address, to_pub: address

• 命令示例:

  snarkos developer execute -q $rpc_url -b $broadcast_url -p $private_key -r $fee_record \
    $program_id swap_exact_public_for_private 1field 2field 1000000u128 98000000u128 $to_pri $to_pub
  

浮动输入换取固定输出

• 功能: swap_tokens_for_exact_tokens

• 参数: token_in: field, token_out: field, amount_in_max: u128, amount_out: u128, to: address

• 命令示例:

  snarkos developer execute -q $rpc_url -b $broadcast_url -p $private_key -r $fee_record \
    $program_id swap_tokens_for_exact_tokens 2field 1field 50000000u128 500000u128 $to_addr
  

私有代币换取固定数量的公共代币

• 功能: swap_private_for_exact_public

• 参数: pt_in: PrivateToken, token_out: field, amount_in_max: u128, amount_out: u128, to: address, refund_to: address

• 命令示例:

  snarkos developer execute -q $rpc_url -b $broadcast_url -p $private_key -r $fee_record \
    $program_id swap_private_for_exact_public $private_token_record $to_addr $refund_to 98000000u128
  

私有代币换取固定数量的私有代币

• 功能: swap_private_for_exact_private

• 参数: pt_in: PrivateToken, token_out: field, amount_in_max: u128, amount_out: u128, to_pri: address, refund_to: address

• 命令示例:

  snarkos developer execute -q $rpc_url -b $broadcast_url -p $private_key -r $fee_record \
    $program_id swap_private_for_exact_private $private_token_record $to_pri $refund_to 98000000u128
  

公共代币换取固定数量的私有代币

• 功能: swap_public_for_exact_private

• 参数: token_in: field, token_out: field, amount_in_max: u128, amount_out: u128, to_pri: address

• 命令示例:

  snarkos developer execute -q $rpc_url -b $broadcast_url -p $private_key -r $fee_record \
    $program_id swap_public_for_exact_private 1field 2field 1000000u128 98000000u128 $to_pri
  

代币水龙头

• 功能: token_faucet

• 参数: token_id: field, to: address

• 命令示例:

  snarkos developer execute -q $rpc_url -b $broadcast_url -p $private_key -r $fee_record \
    $program_id token_faucet 1field $to_addr
  

设置代币水龙头

• 功能: set_token_faucet

• 参数: token_id: field, amount: u128

• 命令示例:

  snarkos developer execute -q $rpc_url -b $broadcast_url -p $private_key -r $fee_record \
    $program_id set_token_faucet 1field 1000u128
  

更改代币管理员

• 功能: change_token_admin

• 参数: token_id: field, admin: address

• 命令示例:

  snarkos developer execute -q $rpc_url -b $broadcast_url -p $private_key -r $fee_record \
    $program_id change_token_admin 1field $new_admin_addr
  

公共状态

余额

• 描述: 存储所有代币和所有账户的余额。

• 查询命令:

  curl $aleoRpc/testnet3/program/swap.aleo/mapping/balances/$key
  

授权

• 描述: 存储所有代币和所有账户的授权数据。

• 查询命令:

  curl $aleoRpc/testnet3/program/swap.aleo/mapping/allowance/$key
  

代币信息

• 描述: 存储所有代币的元信息。

• 查询命令:

  curl $aleoRpc/testnet3/program/swap.aleo/mapping/tokens/$token_id
  

水龙头配置

• 描述: 存储所有代币的水龙头配置。

• 查询命令:

  curl $aleoRpc/testnet3/program/swap.aleo/mapping/faucets/$token_id
  

交易对信息

• 描述: 存储所有交易对的信息。

• 查询命令:

  curl $aleoRpc/testnet3/program/swap.aleo/mapping/pairs/$pair_id
  

全局状态

• 描述: 存储全局状态。

• 查询命令:

  curl $aleoRpc/testnet3/program/swap.aleo/mapping/global_state/true
  

包装状态

• 描述: 存储 WALEO（Wrapped Aleo）功能的状态。

• 查询命令:

  curl $aleoRpc/testnet3/program/swap.aleo/mapping/wrap_state/true
  

解包历史

• 描述: 存储所有 WALEO 的解包历史（包括待处理和已处理的）。

• 查询命令:

  curl $aleoRpc/testnet3/program/swap.aleo/mapping/unwraps/$index
  

以上就是 AleoSwap 技术架构的详细介绍。通过利用 Aleo 区块链的独特功能，AleoSwap 提供了更高的隐私性和灵活性，适应了去中心化交易所和用户的多种需求。如果你有任何疑问或需要进一步的信息，可以随时访问我们的官方文档或加入我们的社区讨论。

总结

AleoSwap 作为基于 Aleo 区块链的去中心化交易所，通过集成 Uniswap 机制和 Aleo 区块链的独特隐私功能，极大地提升了交易所的隐私保护和功能多样性。无论是代币的创建、转账、流动性管理还是代币交换，AleoSwap 都提供了全面且安全的解决方案，为用户带来了更加自由和隐私的交易体验。期待在社区的共同努力下，AleoSwap 能够不断发展壮大，为更多用户提供优质的去中心化金融服务。

Aleo 官方链接：

• Aleo Twitter

• Aleo Discord

• Aleo Website

• Aleo Github

规范

import credits.aleo;

// 定义MTSP程序
program mtsp.aleo {

  // 代币记录结构
  record Token {
    owner: address,
    amount: u128,
    token_id: field,
    authorized: bool,
    authorized_until: u32
  }

  // 代币元数据结构
  struct TokenMetadata {
    token_id: field,
    name: u128, // 代币名称，使用ASCII编码表示的比特串
    symbol: u128, // 代币符号，使用ASCII编码表示的比特串
    decimals: u8, // 小数位数
    supply: u128, // 代币供应量
    max_supply: u128, // 最大供应量
    admin: address, // 管理员地址
    external_authorization_required: bool // 是否需要外部程序授权
  }

  // 代币所有者结构
  struct TokenOwner {
    account: address,
    token_id: field
  }

  // 余额结构
  struct Balance {
    token_id: field,
    account: address,
    balance: u128,
    authorized_until: u32
  }

  // 授权结构
  struct Allowance {
    account: address,
    spender: address,
    token_id: field
  }

  // 映射
  mapping registered_tokens: field => TokenMetadata;
  mapping balances: field => Balance; // 余额映射
  mapping authorized_balances: field => Balance; // 授权余额映射
  mapping allowances: field => u128; // 授权映射

  // 代币管理员调用的方法

  // 注册代币
  transition register_token(token_id: field, name: u128, symbol: u128, decimals: u8, max_supply: u128, external_authorization_required: bool) {
    let token: TokenMetadata = TokenMetadata {
      token_id: token_id,
      name: name,
      symbol: symbol,
      decimals: decimals,
      supply: 0u128,
      max_supply: max_supply,
      admin: self.caller,
      external_authorization_required: external_authorization_required
    };
    return then finalize(token);
  }

  // 完成代币注册
  finalize register_token(token: TokenMetadata) {
    let token_exists: bool = registered_tokens.contains(token.token_id);
    assert_eq(token_exists, false); // 确保代币不存在
    registered_tokens.set(token.token_id, token); // 设置新代币
  }

  // 公开铸造代币
  transition mint_public(token_id: field, recipient: address, amount: u128, authorized_until: u32) {
    return then finalize(token_id, recipient, amount, authorized_until, self.caller);
  }

  // 完成公开铸造代币
  finalize mint_public(token_id: field, recipient: address, amount: u128, authorized_until: u32, token_admin: address) {
    let token: TokenMetadata = registered_tokens.get(token_id);
    assert_eq(token.admin, token_admin); // 检查调用者是否为代币管理员
    let new_supply: u128 = token.supply + amount;
    assert(new_supply <= token.max_supply); // 确保供应量不超过最大供应量

    let token_owner: TokenOwner = TokenOwner {
      account: recipient,
      token_id: token_id
    };
    let balance_key: field = BHP256::hash_to_field(token_owner);
    let default_balance: Balance = Balance {
      token_id: token_id,
      account: recipient,
      balance: 0u128,
      authorized_until: authorized_until
    };
    let authorization_required: bool = token.external_authorization_required;
    let balance: Balance = authorization_required ? balances.get_or_use(balance_key, default_balance) : authorized_balances.get_or_use(balance_key, default_balance);
    let new_balance: Balance = Balance {
      token_id: token_id,
      account: recipient,
      balance: balance.balance + amount,
      authorized_until: balance.authorized_until
    };
    if (authorization_required) {
      balances.set(balance_key, new_balance); // 更新授权余额
    } else {
      authorized_balances.set(balance_key, new_balance); // 更新非授权余额
    }

    let new_metadata: TokenMetadata = TokenMetadata {
      token_id: token_id,
      name: token.name,
      symbol: token.symbol,
      decimals: token.decimals,
      supply: new_supply,
      max_supply: token.max_supply,
      admin: token.admin,
      external_authorization_required: token.external_authorization_required
    };
    registered_tokens.set(token_id, new_metadata); // 更新代币元数据
  }

  // 私有铸造代币
  transition mint_private(token_id: field, recipient: address, amount: u128, authorized: bool, authorized_until: u32) -> Token {
    let token: Token = Token {
      owner: recipient,
      amount: amount,
      token_id: token_id,
      authorized: authorized,
      authorized_until: authorized_until
    };

    return token then finalize(token_id, recipient, amount, authorized, self.caller);
  }

  // 完成私有铸造代币
  finalize mint_private(token_id: field, recipient: address, amount: u128, authorized: bool, token_admin: address) {
    let token: TokenMetadata = registered_tokens.get(token_id);
    assert_eq(token.admin, token_admin); // 检查调用者是否为代币管理员
    let new_supply: u128 = token.supply + amount;
    assert(new_supply <= token.max_supply); // 确保供应量不超过最大供应量
    assert_eq(token.external_authorization_required, authorized); // 检查授权状态

    let new_metadata: TokenMetadata = TokenMetadata {
      token_id: token_id,
      name: token.name,
      symbol: token.symbol,
      decimals: token.decimals,
      supply: new_supply,
      max_supply: token.max_supply,
      admin: token.admin,
      external_authorization_required: token.external_authorization_required
    };
    registered_tokens.set(token_id, new_metadata); // 更新代币元数据
  }

  // 公开销毁代币
  transition burn_public(owner: TokenOwner, amount: u128) {
    return then finalize(owner, amount, self.caller);
  }

  // 完成公开销毁代币
  finalize burn_public(owner: TokenOwner, amount: u128, token_admin: address) {
    let token: TokenMetadata = registered_tokens.get(owner.token_id);
    assert_eq(token.admin, token_admin); // 检查调用者是否为代币管理员
    let new_supply: u128 = token.supply - amount; // 更新供应量

    let balance_key: field = BHP256::hash_to_field(owner);
    let balance: Balance = balances.get(balance_key);
    let new_balance: Balance = Balance {
      token_id: owner.token_id,
      account: owner.account,
      balance: balance.balance - amount,
      authorized_until: balance.authorized_until
    };
    balances.set(balance_key, new_balance); // 更新余额

    let new_metadata: TokenMetadata = TokenMetadata {
      token_id: owner.token_id,
      name: token.name,
      symbol: token.symbol,
      decimals: token.decimals,
      supply: new_supply,
      max_supply: token.max_supply,
      admin: token.admin,
      external_authorization_required: token.external_authorization_required
    };
    registered_tokens.set(owner.token_id, new_metadata); // 更新代币元数据
  }

  // 私有销毁代币
  transition burn_private(input_record: Token, amount: u128) -> Token {
    let output_record: Token = Token {
        owner: input_record.owner,
        amount: input_record.amount - amount,
        token_id: input_record.token_id,
        authorized: input_record.authorized,
        authorized_until: input_record.authorized_until
    };
    return output_record then finalize(input_record.token_id, amount, self.caller);
  }

  // 完成私有销毁代币
  finalize burn_private(token_id: field, amount: u128, token_admin: address) {
    let token: TokenMetadata = registered_tokens.get(token_id);
    assert_eq(token.admin, token_admin); // 检查调用者是否为代币管理员
    let new_supply: u128 = token.supply - amount; // 更新供应量

    let new_metadata: TokenMetadata = TokenMetadata {
      token_id: token_id,
      name: token.name,
      symbol: token.symbol,
      decimals: token.decimals,
      supply: new_supply,
      max_supply: token.max_supply,
      admin: token.admin

Aleo 官方链接：

• Aleo Twitter

• Aleo Discord

• Aleo Website

• Aleo Github

规范

程序结构

program token.aleo;

mapping account:
    key as address.public;
    value as u64.public;

record token:
    owner as address.private;
    amount as u64.private;

struct approval:
    approver as address;
    spender as address;

struct metadata:
    name as u128; // 16 bytes -> 16 characters with ASCII encoding
    symbol as u64; // 8 bytes -> 8 characters with ASCII encoding
    decimals as u8;
    total_supply as u64;

mapping approvals:
    key as field.public;
    value as u64.public;

核心功能介绍

1. 获取元数据

function get_metadata:
    cast [name] [symbol] [decimals] [total_supply] into r0 as metadata;
    output r0 as metadata.public;

此函数返回代币的元数据，包括名称、符号、小数位和总供应量。这些信息有助于钱包和dApp正确显示代币信息。

2. 授权公共代币使用

function approve_public:
    input r0 as address.public; // 授权的地址
    input r1 as u64.public; // 授权的代币数量

    cast self.caller r0 into r2 as approval;
    hash.bhp256 r2 into r3 as field;

    async approve_public r3 r1 into r4;
    output r4 as token.aleo/approve_public.future;

finalize approve_public:
    input r0 as field.public;
    input r1 as u64.public; // 增加授权的代币数量

    get.or_use approvals[r0] 0u64 into r2;
    add r1 r2 into r3;
    set r3 into approvals[r0];

此函数允许代币持有者授权某个地址使用一定数量的代币。这个功能对于允许智能合约代表用户执行代币操作至关重要。

3. 取消授权

function unapprove_public:
    input r0 as address.public; // 被取消授权的地址
    input r1 as u64.public; // 取消的代币数量

    cast self.caller r0 into r2 as approval;
    hash.bhp256 r2 into r3 as field;

    async unapprove_public r3 r1 into r4;
    output r4 as token.aleo/unapprove_public.future;

finalize unapprove_public:
    input r0 as field.public;
    input r1 as u64.public; // 减少授权的代币数量

    get approvals[r0] into r2;
    sub r2 r1 into r3;
    set r3 into approvals[r0];

此函数撤销之前授权的代币数量，用于减少或完全撤销对某个地址的授权。

4. 从公共账户转账

function transfer_from_public:
    input r0 as address.public; // 授权者
    input r1 as address.public; // 接收者
    input r2 as u64.public; // 转账数量

    cast r0 self.caller into r3 as approval;
    hash.bhp256 r3 into r4 as field;

    async transfer_from_public r4 r0 r1 r2 into r5;
    output r5 as token.aleo/transfer_from_public.future;

finalize transfer_from_public:
    input r0 as field.public;
    input r1 as address.public;
    input r2 as address.public;
    input r3 as u64.public;

    get approvals[r0] into r4;
    sub r4 r3 into r5;
    set r5 into approvals[r0];
    get account[r1] into r6;
    sub r6 r3 into r7;
    set r7 into account[r1];
    get.or_use account[r2] 0u64 into r8;
    add r8 r3 into r9;
    set r9 into account[r2];

此函数实现从授权者账户向接收者账户的代币转账，用于实现代币的自动化管理和支付。

5. 公共代币转账

function transfer_public:
    input r0 as address.public; // 接收者地址
    input r1 as u64.public; // 转账数量

    async transfer_public self.caller r0 r1 into r2;
    output r2 as token.aleo/transfer_public.future;

finalize transfer_public:
    input r0 as address.public;
    input r1 as address.public;
    input r2 as u64.public;

    get.or_use account[r0] 0u64 into r3;
    sub r3 r2 into r4;
    set r4 into account[r0];
    get.or_use account[r1] 0u64 into r5;
    add r5 r2 into r6;
    set r6 into account[r1];

此函数将代币从调用者账户转移到指定的公共账户，实现简单的代币转账。

6. 私有代币转账

function transfer_private:
    input r0 as token.record; // 代币记录
    input r1 as address.private; // 接收者地址
    input r2 as u64.private; // 转账数量

    sub r0.amount r2 into r3;
    cast r0.owner r3 into r4 as token.record;
    cast r1 r2 into r5 as token.record;
    output r4 as token.record;
    output r5 as token.record;

此函数实现私有代币的转账，用于在保持交易隐私的情况下进行代币转移。

7. 私有代币转公共代币

function transfer_private_to_public:
    input r0 as token.record; // 私有代币记录
    input r1 as address.public; // 公共接收者地址
    input r2 as u64.public; // 转账数量

    sub r0.amount r2 into r3;
    cast r0.owner r3 into r4 as token.record;
    async transfer_private_to_public r1 r2 into r5;
    output r4 as token.record;
    output r5 as token.aleo/transfer_private_to_public.future;

finalize transfer_private_to_public:
    input r0 as address.public;
    input r1 as u64.public;

    get.or_use account[r0] 0u64 into r2;
    add r2 r1 into r3;
    set r3 into account[r0];

此函数将私有代币转换为公共代币，允许在公共账户中持有之前私有的代币。

8. 公共代币转私有代币

function transfer_public_to_private:
    input r0 as address.public; // 公共账户地址
    input r1 as u64.public; // 转账数量

    cast r0 r1 into r2 as token.record;
    async transfer_public_to_private self.caller r1 into r3;
    output r2 as token.record;
    output r3 as token.aleo/transfer_public_to_private.future;

finalize transfer_public_to_private:
    input r0 as address.public;
    input r1 as u64.public;

    get.or_use account[r0] 0u64 into r2;
    sub r2 r1 into r3;
    set r3 into account[r0];

此函数将公共代币转换为私有代币，以确保交易隐私和安全。

通过这些规范和示例代码，ARC-20标准在Aleo区块链上实现了兼容且安全的同质化代币管理。

Aleo 官方链接：

• Aleo Twitter

• Aleo Discord

• Aleo Website

• Aleo Github