Add wrapped_token_registry and tests

Author: vicsn

arc-0020-2026/tests/contracts/wrapped-token-registry.js

@@ -0,0 +1,19 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import * as AleoUtils from "../lib/aleo-test-utils.js";
+
+export const PROGRAM_ID = "wrapped_token_registry.aleo";
+export const WRAPPED_TOKEN_ID = "99999field";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export const PROGRAM_PATH = path.join(__dirname, "..", "..", "wrapped_token_registry");
+
+export async function transferPublic(account, recipient, amountU128) {
+  const privateKey = account.privateKey().to_string();
+  return await AleoUtils.leoExecute(PROGRAM_PATH, "transfer_public", [recipient, amountU128], {
+    privateKey,
+  });
+}

arc-0020-2026/tests/lib/aleo-test-utils.js

@@ -175,7 +175,10 @@ export async function startDevnode(opts = {}) {
   const leoDevnodeBin = opts.leoDevnodeBin || LEO_BIN;
   const privateKey = opts.privateKey || DEFAULT_PRIVATE_KEYS[0];
 
-  const logPath = opts.logPath || path.join(__dirname, "..", "snarkos-devnet.log");
+  const logsDir = path.join(__dirname, "..", "logs");
+  fs.mkdirSync(logsDir, { recursive: true });
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const logPath = opts.logPath || path.join(logsDir, `snarkos-devnet-${timestamp}.log`);
   const storageRoot =
     opts.storageRoot || path.join(__dirname, "..", ".snarkos-devnet");
 
@@ -308,26 +311,29 @@ export async function leoBuild(programPath, opts = {}) {
 export async function leoDeploy(programPath, opts = {}) {
   const privateKey = opts.privateKey || DEFAULT_PRIVATE_KEYS[0];
 
-  return await run(
-    LEO_BIN,
-    [
-      "deploy",
-      "--network",
-      "testnet",
-      "--endpoint",
-      NETWORK_URL,
-      "--private-key",
-      privateKey,
-      "--broadcast",
-      "--yes",
-      "--devnet",
-      "--max-wait",
-      String(opts.maxWait ?? 15),
-      "--blocks-to-check",
-      String(opts.blocksToCheck ?? 15),
-    ],
-    { cwd: programPath, label: "leo deploy" },
-  );
+  const args = [
+    "deploy",
+    "--network",
+    "testnet",
+    "--endpoint",
+    NETWORK_URL,
+    "--private-key",
+    privateKey,
+    "--broadcast",
+    "--yes",
+    "--devnet",
+    "--max-wait",
+    String(opts.maxWait ?? 15),
+    "--blocks-to-check",
+    String(opts.blocksToCheck ?? 15),
+  ];
+  if (opts.skip?.length) {
+    for (const s of opts.skip) {
+      args.push("--skip", s);
+    }
+  }
+
+  return await run(LEO_BIN, args, { cwd: programPath, label: "leo deploy" });
 }
 
 export async function leoExecute(programPath, fnName, inputs, opts = {}) {
@@ -384,33 +390,38 @@ export async function leoMappingValue(programName, mappingName, key, opts = {})
 
 export async function leoProgramExists(programName, opts = {}) {
   try {
-    await run(
-      LEO_BIN,
-      [
-        "query",
-        "program",
-        programName,
-        "--network",
-        "testnet",
-        "--endpoint",
-        NETWORK_URL,
-      ],
-      { label: "leo query program" },
-    );
+    const args = [
+      "query",
+      "program",
+      programName,
+      "--network",
+      "testnet",
+      "--endpoint",
+      NETWORK_URL,
+    ];
+    const isLocalEndpoint =
+      NETWORK_URL.includes("127.0.0.1") || NETWORK_URL.includes("localhost");
+    if (opts.devnet !== false && isLocalEndpoint) {
+      args.push("--devnet");
+    }
+    await run(LEO_BIN, args, { label: "leo query program" });
     return true;
   } catch {
     return false;
   }
 }
 
 export async function deployProgramFromFile(opts) {
-  const { programId, programPath } = opts;
+  const { programId, programPath, skip } = opts;
   if (!programId) throw new Error("deployProgramFromFile requires programId");
   if (!programPath) throw new Error("deployProgramFromFile requires programPath");
 
   await leoBuild(programPath, opts);
   try {
-    await leoDeploy(programPath, { privateKey: DEFAULT_PRIVATE_KEYS[0] });
+    await leoDeploy(programPath, {
+      privateKey: DEFAULT_PRIVATE_KEYS[0],
+      skip,
+    });
   } catch (e) {
     const msg = String(e?.message || e);
     if (!msg.includes("already exists on the network")) throw e;

arc-0020-2026/tests/token-registry.test.js

@@ -3,18 +3,22 @@ import { fileURLToPath } from "node:url";
 
 import * as AleoUtils from "./lib/aleo-test-utils.js";
 import * as TokenRegistry from "./contracts/token-registry.js";
+import * as WrappedTokenRegistry from "./contracts/wrapped-token-registry.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 describe("token_registry.aleo", () => {
   const programPath = path.join(__dirname, "..", "token_registry");
+  const wrappedProgramPath = path.join(__dirname, "..", "wrapped_token_registry");
   const pk0 = AleoUtils.DEFAULT_PRIVATE_KEYS[0];
   const addr0 = AleoUtils.addresses[0];
   const addr1 = AleoUtils.addresses[1];
 
   // Custom token ID (must not equal CREDITS_RESERVED_TOKEN_ID)
   const CUSTOM_TOKEN_ID = "12345field";
+  // Token ID wrapped by wrapped_token_registry.aleo
+  const WRAPPED_TOKEN_ID = WrappedTokenRegistry.WRAPPED_TOKEN_ID;
   const MAX_SUPPLY = "1000000u128";
   const MINT_AMOUNT = "1000u128";
   const TRANSFER_AMOUNT = "200u128";
@@ -28,6 +32,8 @@ describe("token_registry.aleo", () => {
     await expect(p).rejects.toThrow(/Transaction rejected|failed \(code/i);
   }
 
+  let wrappedTokenRegistryDeployed = false;
+
   beforeAll(async () => {
     try {
       await AleoUtils.startDevnode();
@@ -36,6 +42,20 @@ describe("token_registry.aleo", () => {
         programId: TokenRegistry.PROGRAM_ID,
         programPath,
       });
+
+      try {
+        const prevEndpoint = process.env.ENDPOINT;
+        process.env.ENDPOINT = AleoUtils.NETWORK_URL;
+        await AleoUtils.deployProgramFromFile({
+          programId: WrappedTokenRegistry.PROGRAM_ID,
+          programPath: wrappedProgramPath,
+        });
+        process.env.ENDPOINT = prevEndpoint;
+        wrappedTokenRegistryDeployed = true;
+      } catch (e) {
+        process.env.ENDPOINT = undefined;
+        wrappedTokenRegistryDeployed = false;
+      }
     } catch (e) {
       await AleoUtils.stopDevnode();
       throw e;
@@ -185,4 +205,53 @@ describe("token_registry.aleo", () => {
       ),
     );
   });
+
+  test("wrapped_token_registry: transfer via TransferPublic interface", async () => {
+    if (!wrappedTokenRegistryDeployed) {
+      console.warn(
+        "Skipping: wrapped_token_registry not deployed (dependency deploy skips both programs)",
+      );
+      return;
+    }
+    // Register and mint the token wrapped by wrapped_token_registry (99999field)
+    const name = "1413829460u128";
+    const symbol = "1413829460u128";
+    const decimals = "6u8";
+    const extAuthRequired = "false";
+    const extAuthParty = addr0;
+
+    const registerExec = await AleoUtils.leoExecute(
+      programPath,
+      "register_token",
+      [WRAPPED_TOKEN_ID, name, symbol, decimals, MAX_SUPPLY, extAuthRequired, extAuthParty],
+      { privateKey: pk0 },
+    );
+    await expectConfirmed(registerExec);
+
+    const mintExec = await TokenRegistry.mintPublic(
+      AleoUtils.accounts[0],
+      WRAPPED_TOKEN_ID,
+      addr0,
+      "500u128",
+      AUTHORIZED_UNTIL,
+    );
+    await expectConfirmed(mintExec);
+
+    // Transfer using wrapped_token_registry (TransferPublic interface)
+    const transferExec = await WrappedTokenRegistry.transferPublic(
+      AleoUtils.accounts[0],
+      addr1,
+      "150u128",
+    );
+    await expectConfirmed(transferExec);
+
+    // Verify: addr1 received and can transfer back via token_registry
+    const execBack = await TokenRegistry.transferPublic(
+      AleoUtils.accounts[1],
+      WRAPPED_TOKEN_ID,
+      addr0,
+      "50u128",
+    );
+    await expectConfirmed(execBack);
+  });
 });

arc-0020-2026/wrapped_token_registry/.gitignore

@@ -0,0 +1,7 @@
+.env
+*.avm
+*.prover
+*.verifier
+outputs/
+*.log
+build

arc-0020-2026/wrapped_token_registry/README.md

@@ -0,0 +1,15 @@
+# wrapped_token_registry.aleo
+
+Stateless wrapper around `token_registry.aleo` that implements the `TransferPublic` interface (same as `wrapped_credits.aleo`).
+
+## Purpose
+
+Provides a uniform `transfer_public(public recipient: address, public amount: u128) -> Final` interface for the credits-reserved token in the token registry. This allows programs that expect the `TransferPublic` interface to work with either `wrapped_credits.aleo` or `wrapped_token_registry.aleo` interchangeably.
+
+## Dependencies
+
+- `token_registry.aleo` (local, `../token_registry`)
+
+## Token
+
+Wraps the `CREDITS_RESERVED_TOKEN_ID` token in the token registry. Balances are stored in `token_registry.aleo`; this program holds no state and merely forwards calls.

arc-0020-2026/wrapped_token_registry/program.json

@@ -0,0 +1 @@
+{"program":"wrapped_token_registry.aleo","version":"0.1.0","description":"Stateless wrapper around token_registry implementing TransferPublic","license":"MIT","leo":"3.4.0","dependencies":[{"name":"token_registry.aleo","location":"network","path":null,"edition":null}],"dev_dependencies":null}

arc-0020-2026/wrapped_token_registry/src/main.leo

@@ -0,0 +1,23 @@
+import token_registry.aleo;
+
+// Interface matching compliant_token_template.aleo transfer_public signature (PR 29151)
+interface TransferPublic {
+    fn transfer_public(public recipient: address, public amount: u128) -> Final;
+}
+
+// Custom token ID wrapped by this program (distinct from CREDITS_RESERVED_TOKEN_ID)
+const WRAPPED_TOKEN_ID: field = 99999field;
+
+program wrapped_token_registry.aleo : TransferPublic {
+    @noupgrade
+    constructor() {}
+
+    fn transfer_public(public recipient: address, public amount: u128) -> Final {
+        // Use transfer_public_as_signer so the sender is the transaction signer (user),
+        // not this program's address (self.caller would be wrapped_token_registry).
+        let tr_final = token_registry.aleo/transfer_public_as_signer(WRAPPED_TOKEN_ID, recipient, amount);
+        return final {
+            tr_final.run();
+        };
+    }
+}