@ic-reactor/mcp 0.0.0-stage → 0.0.0

package/examples/canister-studio/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "jsx": "react-jsx",
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": true,
+    "erasableSyntaxOnly": true,
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "types": ["vite/client", "node"]
+  },
+  "include": ["src", "scripts", "vite.config.ts", "vitest.config.ts"]
+}

package/examples/canister-studio/vite.config.ts

@@ -0,0 +1,50 @@
+import { icReactor } from "@ic-reactor/vite-plugin"
+import { tanstackStart } from "@tanstack/react-start/plugin/vite"
+import react from "@vitejs/plugin-react"
+import { defineConfig } from "vite"
+
+export default defineConfig({
+  server: { port: 3410 },
+  plugins: [
+    // Writes src/canisters/<name>.ts (and its envelope) from each .did when
+    // `vite dev` or `vite build` starts, and again when a .did changes. The
+    // files are committed too, so `pnpm gen:check` fails a stale copy and
+    // `tsc` runs before any build.
+    icReactor({
+      canisters: {
+        // Any ICRC-1 ledger: ckBTC, ckETH, or a pasted id.
+        icrc1: { didFile: "did/icrc1.did", outDir: "src/canisters" },
+        // The ICP ledger's full interface, as its candid:service metadata
+        // published it.
+        icp_ledger: { didFile: "did/icp_ledger.did", outDir: "src/canisters" },
+        // The ckBTC minter's full interface, from its candid:service metadata.
+        ckbtc_minter: {
+          didFile: "did/ckbtc_minter.did",
+          outDir: "src/canisters",
+        },
+      },
+      // Mainnet only: there is no local `icp` network to ask for the ic_env
+      // cookie, and the plugin's /api proxy would only get in the way.
+      injectEnvironment: false,
+    }),
+    tanstackStart(),
+    // Must come after tanstackStart().
+    react(),
+  ],
+  // Imported only lazily (the Safety lab's @ic-reactor/core/testing, the
+  // interface loaders): without them here, `vite dev` discovers them on the
+  // first click and reloads the page, losing that click.
+  optimizeDeps: {
+    include: [
+      "@icp-sdk/core/identity",
+      "@noble/curves/bls12-381.js",
+      "@noble/curves/ed25519.js",
+      "@noble/curves/nist.js",
+      "@noble/curves/secp256k1.js",
+      "@meantjs/schema/contract",
+      "zod",
+    ],
+  },
+  // The IC agent, with its BLS certificate check, is most of the main chunk.
+  build: { chunkSizeWarningLimit: 900 },
+})

package/examples/canister-studio/vitest.config.ts

@@ -0,0 +1,20 @@
+import { defineConfig } from "vitest/config"
+
+// The tests run over the committed generated modules (`pnpm gen:check` keeps
+// them current), so they need neither the Start and React plugins nor the
+// generator, and never mainnet: every client in them is a `createTestClient()`
+// over an in-memory replica, and the live interface loader takes an injected
+// fetcher.
+//
+// package.json pins jsdom to 30.0.1: jsdom 30.1 subclasses the global
+// `Iterator`, which StackBlitz's WebContainer does not define, so there a jsdom
+// test fails to start with "ReferenceError: Iterator is not defined".
+export default defineConfig({
+  test: {
+    environment: "jsdom",
+    include: ["src/**/*.test.{ts,tsx}"],
+    // Every read signs and verifies a reply on the in-memory replica; 5 s,
+    // Vitest's default, is short for a loaded CI runner.
+    testTimeout: 20_000,
+  },
+})

package/examples/icrc-ledger/.stackblitzrc

@@ -0,0 +1,4 @@
+{
+  "installDependencies": true,
+  "startCommand": "npm run dev"
+}

package/examples/icrc-ledger/README.md

@@ -0,0 +1,100 @@
+# ICRC-1 ledger on ic-reactor 4
+
+An ICRC-1 ledger app on `@ic-reactor/core` and `@ic-reactor/react`, with two
+tabs:
+
+- **Mainnet** reads the real ICP ledger (or ckBTC, or any ledger id you paste)
+  with `createClient({ network: "ic", identity: "anonymous" })`: name, symbol,
+  decimals, fee, total supply, minting account, metadata, and the balance of a
+  principal you type. The balance is `skipToken` until `isPrincipal()` accepts
+  the owner. "Not a ledger" shows the error panel, which names the failure's
+  `kind` and says whether the call may have executed. "Certified reads" makes
+  the ledger `{ id, certified: true }`. For the ICP ledger, **Blocks** pages
+  through `query_blocks`: the ledger holds only its newest blocks, and for
+  older ranges its reply carries a callback (an archive canister and a
+  method) that `client.func(QueryArchiveFn, range.callback)` calls
+  (`src/blocks.ts`). "Genesis" reads the 2021 mints from the first archive.
+  `client.func()` has no certified path, so archived blocks come from a plain
+  query even with "Certified reads" on, and are cached without the
+  `'certified'` key segment.
+- **Sandbox** runs `createTestClient()` from `@ic-reactor/core/testing` in the
+  page: a real client (it signs, sends and checks certificates) over the
+  in-memory replica, with a mocked ICRC-1 ledger (`src/sandbox.ts`) that keeps
+  a balance per account, burns the fee and answers with the standard's `Err`
+  arms. Sign in as seed 1, switch to seed 2, sign out, and send transfers
+  (`useMutation(client.mutationOptions(ledger, "icrc1_transfer"))`, amounts
+  read with `parseUnits`). Arm a fault for the next transfer and watch the
+  request log:
+
+| Fault                  | What the client does                                                                                    |
+| ---------------------- | ------------------------------------------------------------------------------------------------------- |
+| reject code 4          | `rejected`, may have executed: it re-reads the balance, which shows nothing moved                       |
+| lost reply             | `outcome_unknown`, may have executed: the re-read shows the debit; sending it again answers `Duplicate` |
+| status 429 once        | re-sends once by itself (the request log shows two calls), and the transfer goes through                |
+| reject code 2 once     | the same single re-send                                                                                 |
+| status 429 three times | gives up after two re-sends: `not_delivered`, certainly not executed                                    |
+| (signed out)           | `unauthenticated`, refused before anything is sent                                                      |
+
+When a transfer may have executed, "Send the same transfer again" is offered
+only while its sender is the caller. ICRC-1 deduplicates per sender account,
+so the same argument signed by another account (after a switch to seed 2) is
+a new transfer, paid in full. Each press of Send gives its transfer a `memo`
+of its own (16 random bytes, `src/transfer-form.ts`), and the re-send sends
+that transfer's argument, memo and `created_at_time` included: the ledger
+deduplicates on the whole argument, so two transfers of the same amount made
+in the same millisecond are two transfers, and neither is taken for the
+other's `Duplicate`.
+
+The Sandbox also has a mocked ckBTC minter. `get_btc_address` is an update
+method, which `client.queryOptions` refuses (the call does not compile)
+unless told it is idempotent:
+`client.queryOptions(minter, "get_btc_address", arg, { update: "idempotent" })`
+fetches each caller's deposit address once and keeps it (hide and show it, or
+send a transfer: no new call reaches the minter). The smoke script asks
+the real minter on mainnet the same way, signing with a throwaway key.
+
+## Run it
+
+From the repository root, after `pnpm install` and `pnpm build`:
+
+```sh
+pnpm --filter icrc-ledger dev        # http://localhost:5173
+pnpm --filter icrc-ledger test       # the sandbox ledger, the form, the Sandbox page
+pnpm --filter icrc-ledger smoke      # ledger, blocks and ckBTC minter on mainnet, Node 22.18+
+pnpm --filter icrc-ledger gen:check  # fails if src/canisters/ is stale
+```
+
+`src/canisters/` is generated from the `.did` files (`icrc1.did`; the ICP
+ledger's block reads, `icp_ledger.did`; the minter's `ckbtc_minter.did`) by
+`@ic-reactor/vite-plugin` on every `vite dev` and `vite build` (`pnpm gen` runs
+`meant gen` by hand). It is committed, and never edited.
+`icp_ledger.did` and `ckbtc_minter.did` are projections of the mainnet
+canisters' interfaces to the methods the app calls (`methods` in
+`vite.config.ts`), as the plugin wrote them from the live canisters. They are
+committed, so builds read them and make no request. `IC_REACTOR_FETCH=<name>`
+writes one again, and `IC_REACTOR_VERIFY=1 pnpm build` checks both against the
+live canisters.
+
+## Before and after
+
+The same explorer written on `@meantjs/schema` alone needed a 176-line
+`src/ledger.ts` (look the method up, encode, `agent.query`, decode, a query key
+from the encoded bytes, and its own error union) and a 53-line `useQuery`
+wrapper, and could only read. Here `src/ledger.ts` is 15 lines, 7 of them code:
+a client and `client.canister<Actor>(actor, { id })`. Reads are
+`useQuery(client.queryOptions(ledger, method, arg))` and the transfer is
+`useMutation(client.mutationOptions(ledger, "icrc1_transfer"))`, with caller
+keys, retries, invalidation and `ReactorError` coming from the client.
+
+## Files
+
+- `src/ledger.ts`: the mainnet client and the ledger on it.
+- `src/MainnetTab.tsx`, `src/ErrorPanel.tsx`: the Mainnet tab.
+- `src/blocks.ts`: `query_blocks` and its archive callbacks
+  (`icp_ledger.did`), tested over a mocked ledger and archive by
+  `src/blocks.test.ts`.
+- `src/minter.ts`: the ckBTC minter's id and canister.
+- `src/sandbox.ts`: the test client, the mocked ledger and minter, tested in
+  Node by `src/sandbox.test.ts`; `src/SandboxTab.tsx` is its page, rendered in
+  jsdom by `src/SandboxTab.test.tsx`.
+- `src/transfer-form.ts`: typed text to an `icrc1_transfer` argument, or a refusal.

package/examples/icrc-ledger/ckbtc_minter.did

@@ -0,0 +1,12 @@
+service : {
+  // Returns the Bitcoin address to which the owner should send BTC
+  // before converting the amount to ckBTC using the [update_balance]
+  // endpoint.
+  //
+  // If the owner is not set, it defaults to the caller's principal.
+  // The resolved owner must be a non-anonymous principal.
+  get_btc_address : (record {
+    owner : opt principal;
+    subaccount : opt blob;
+  }) -> (text);
+}

package/examples/icrc-ledger/icp_ledger.did

@@ -0,0 +1,147 @@
+// Amount of tokens, measured in 10^-8 of a token.
+type Tokens = record {
+  e8s : nat64;
+};
+// Number of nanoseconds from the UNIX epoch in UTC timezone.
+type TimeStamp = record {
+  timestamp_nanos : nat64;
+};
+// AccountIdentifier is a 32-byte array.
+// The first 4 bytes is big-endian encoding of a CRC32 checksum of the last 28 bytes.
+type AccountIdentifier = blob;
+// Sequence number of a block produced by the ledger.
+type BlockIndex = nat64;
+type Transaction = record {
+  memo : Memo;
+  icrc1_memo : opt blob;
+  operation : opt Operation;
+  created_at_time : TimeStamp;
+};
+// An arbitrary number associated with a transaction.
+// The caller can set it in a `transfer` call as a correlation identifier.
+type Memo = nat64;
+type GetBlocksArgs = record {
+  // The index of the first block to fetch.
+  start : BlockIndex;
+  // Max number of blocks to fetch.
+  length : nat64;
+};
+type Operation = variant {
+  Approve : record {
+    fee : Tokens;
+    from : AccountIdentifier;
+    // This field is deprecated and should not be used.
+    allowance_e8s : int;
+    allowance : Tokens;
+    expected_allowance : opt Tokens;
+    expires_at : opt TimeStamp;
+    spender : AccountIdentifier;
+  };
+  Burn : record {
+    from : AccountIdentifier;
+    amount : Tokens;
+    spender : opt AccountIdentifier;
+  };
+  Mint : record {
+    to : AccountIdentifier;
+    amount : Tokens;
+  };
+  Transfer : record {
+    to : AccountIdentifier;
+    fee : Tokens;
+    from : AccountIdentifier;
+    amount : Tokens;
+    spender : opt blob;
+  };
+};
+type Block = record {
+  transaction : Transaction;
+  timestamp : TimeStamp;
+  parent_hash : opt blob;
+};
+// A prefix of the block range specified in the [GetBlocksArgs] request.
+type BlockRange = record {
+  // A prefix of the requested block range.
+  // The index of the first block is equal to [GetBlocksArgs.from].
+  //
+  // Note that the number of blocks might be less than the requested
+  // [GetBlocksArgs.len] for various reasons, for example:
+  //
+  // 1. The query might have hit the replica with an outdated state
+  // that doesn't have the full block range yet.
+  // 2. The requested range is too large to fit into a single reply.
+  //
+  // NOTE: the list of blocks can be empty if:
+  // 1. [GetBlocksArgs.len] was zero.
+  // 2. [GetBlocksArgs.from] was larger than the last block known to the canister.
+  blocks : vec Block;
+};
+// An error indicating that the arguments passed to [QueryArchiveFn] were invalid.
+type QueryArchiveError = variant {
+  // [GetBlocksArgs.from] argument was smaller than the first block
+  // served by the canister that received the request.
+  BadFirstBlockIndex : record {
+    requested_index : BlockIndex;
+    first_valid_index : BlockIndex;
+  };
+  // Reserved for future use.
+  Other : record {
+    error_message : text;
+    error_code : nat64;
+  };
+};
+type QueryArchiveResult = variant {
+  // Successfully fetched zero or more blocks.
+  Ok : BlockRange;
+  // The [GetBlocksArgs] request was invalid.
+  Err : QueryArchiveError;
+};
+// A function that is used for fetching archived ledger blocks.
+type QueryArchiveFn = func (GetBlocksArgs) -> (QueryArchiveResult) query;
+// The result of a "query_blocks" call.
+//
+// The structure of the result is somewhat complicated because the main ledger canister might
+// not have all the blocks that the caller requested: One or more "archive" canisters might
+// store some of the requested blocks.
+//
+// Note: as of Q4 2021 when this interface is authored, the IC doesn't support making nested
+// query calls within a query call.
+type QueryBlocksResponse = record {
+  // System certificate for the hash of the latest block in the chain.
+  // Only present if `query_blocks` is called in a non-replicated query context.
+  certificate : opt blob;
+  // List of blocks that were available in the ledger when it processed the call.
+  //
+  // The blocks form a contiguous range, with the first block having index
+  // [first_block_index] (see below), and the last block having index
+  // [first_block_index] + len(blocks) - 1.
+  //
+  // The block range can be an arbitrary sub-range of the originally requested range.
+  blocks : vec Block;
+  // The total number of blocks in the chain.
+  // If the chain length is positive, the index of the last block is `chain_len - 1`.
+  chain_length : nat64;
+  // The index of the first block in "blocks".
+  // If the blocks vector is empty, the exact value of this field is not specified.
+  first_block_index : BlockIndex;
+  // Encoding of instructions for fetching archived blocks whose indices fall into the
+  // requested range.
+  //
+  // For each entry `e` in [archived_blocks], `[e.from, e.from + len)` is a sub-range
+  // of the originally requested block range.
+  archived_blocks : vec ArchivedBlocksRange;
+};
+type ArchivedBlocksRange = record {
+  // The function that should be called to fetch the archived blocks.
+  // The range of the blocks accessible using this function is given by [from]
+  // and [len] fields above.
+  callback : QueryArchiveFn;
+  // The index of the first archived block that can be fetched using the callback.
+  start : BlockIndex;
+  // The number of blocks that can be fetch using the callback.
+  length : nat64;
+};
+service : {
+  // Queries blocks in the specified range.
+  query_blocks : (GetBlocksArgs) -> (QueryBlocksResponse) query;
+}

package/examples/icrc-ledger/icrc1.did

@@ -0,0 +1,88 @@
+type BlockIndex = nat;
+type Subaccount = blob;
+// Number of nanoseconds since the UNIX epoch in UTC timezone.
+type Timestamp = nat64;
+// Number of nanoseconds between two [Timestamp]s.
+type Duration = nat64;
+type Tokens = nat;
+
+type Account = record {
+    owner : principal;
+    subaccount : opt Subaccount;
+};
+
+type TransferArg = record {
+    from_subaccount : opt Subaccount;
+    to : Account;
+    amount : Tokens;
+    fee : opt Tokens;
+    memo : opt blob;
+    created_at_time: opt Timestamp;
+};
+
+type TransferError = variant {
+    BadFee : record { expected_fee : Tokens };
+    BadBurn : record { min_burn_amount : Tokens };
+    InsufficientFunds : record { balance : Tokens };
+    TooOld;
+    CreatedInFuture : record { ledger_time : nat64 };
+    TemporarilyUnavailable;
+    Duplicate : record { duplicate_of : BlockIndex };
+    GenericError : record { error_code : nat; message : text };
+};
+
+type TransferResult = variant {
+    Ok : BlockIndex;
+    Err : TransferError;
+};
+
+// The value returned from the [icrc1_metadata] endpoint.
+type Value = variant {
+    Nat : nat;
+    Int : int;
+    Text : text;
+    Blob : blob;
+};
+
+// The initialization parameters of the Ledger
+type InitArgs = record {
+    minting_account : Account;
+    transfer_fee : nat64;
+    token_symbol : text;
+    token_name : text;
+    metadata : vec record { text; Value };
+    initial_balances : vec record { Account; nat64 };
+    archive_options : record {
+        num_blocks_to_archive : nat64;
+        trigger_threshold : nat64;
+        max_message_size_bytes : opt nat64;
+        cycles_for_archive_creation : opt nat64;
+        node_max_memory_size_bytes : opt nat64;
+        controller_id : principal;
+    };
+};
+
+type UpgradeArgs = record {
+    metadata : opt vec record { text; Value };
+    token_symbol : opt text;
+    token_name : opt text;
+    transfer_fee : opt nat64;
+};
+
+type LedgerArg = variant {
+    Init: InitArgs;
+    Upgrade: opt UpgradeArgs;
+};
+
+service : (ledger_arg : LedgerArg) -> {
+    icrc1_name : () -> (text) query;
+    icrc1_symbol : () -> (text) query;
+    icrc1_decimals : () -> (nat8) query;
+    icrc1_metadata : () -> (vec record { text; Value }) query;
+    icrc1_total_supply : () -> (Tokens) query;
+    icrc1_fee : () -> (Tokens) query;
+    icrc1_minting_account : () -> (opt Account) query;
+    icrc1_balance_of : (Account) -> (Tokens) query;
+    icrc1_transfer : (TransferArg) -> (TransferResult);
+    icrc1_supported_standards : () -> (vec record { name : text; url : text }) query;
+}

package/examples/icrc-ledger/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="color-scheme" content="light dark" />
+    <title>ICRC-1 ledger on ic-reactor 4</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package/examples/icrc-ledger/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "icrc-ledger",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc --noEmit && vite build",
+    "preview": "vite preview",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "gen": "meant gen icrc1.did icp_ledger.did ckbtc_minter.did -o src/canisters",
+    "gen:check": "meant gen icrc1.did icp_ledger.did ckbtc_minter.did -o src/canisters --check",
+    "smoke": "node scripts/smoke.ts"
+  },
+  "dependencies": {
+    "@meantjs/schema": "0.6.0",
+    "@ic-reactor/core": "^4.1.1",
+    "@ic-reactor/react": "^4.1.1",
+    "@icp-sdk/core": "^6.1.0",
+    "@noble/curves": "^2.2.0",
+    "@tanstack/react-query": "^5.102.8",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0"
+  },
+  "devDependencies": {
+    "@meantjs/cli": "0.5.1",
+    "@ic-reactor/vite-plugin": "^4.1.1",
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/react": "^16.3.3",
+    "@types/node": "^26.5.1",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "@vitejs/plugin-react": "^6.1.1",
+    "jsdom": "30.0.1",
+    "typescript": "^6.0.3",
+    "vite": "^8.3.4",
+    "vitest": "^5.0.0"
+  }
+}

package/examples/icrc-ledger/scripts/smoke.ts

@@ -0,0 +1,151 @@
+// Reads the real ICP ledger on mainnet through the same src/ledger.ts the page
+// uses. Node strips the types itself (22.18 or newer): no bundler, no loader.
+import assert from "node:assert/strict"
+import { principal } from "@meantjs/schema"
+import { createClient, formatUnits, isReactorError } from "@ic-reactor/core"
+import { Ed25519KeyIdentity } from "@icp-sdk/core/identity"
+import {
+  archivedRangeOptions,
+  blockRows,
+  blocksLedgerOn,
+  blockTime,
+  operationOf,
+} from "../src/blocks.ts"
+import { ICP_LEDGER, ledgerOn, mainnetClient } from "../src/ledger.ts"
+import { minterOn } from "../src/minter.ts"
+
+const NNS_GOVERNANCE = principal("rrkah-fqaaa-aaaaa-aaaaq-cai")
+// The cycles minting canister holds some ICP.
+const CYCLES_MINTING = principal("rkp4c-7iaaa-aaaaa-aaaca-cai")
+
+const client = mainnetClient()
+const ledger = ledgerOn(client, ICP_LEDGER)
+
+const [name, symbol, decimals, fee, supply, minter, metadata] =
+  await Promise.all([
+    ledger.icrc1_name(),
+    ledger.icrc1_symbol(),
+    ledger.icrc1_decimals(),
+    ledger.icrc1_fee(),
+    ledger.icrc1_total_supply(),
+    ledger.icrc1_minting_account(),
+    ledger.icrc1_metadata(),
+  ])
+const tokens = (units: bigint) => `${formatUnits(units, decimals)} ${symbol}`
+
+// Through the cache, as the page reads it.
+const cmc = await client.queryClient.fetchQuery(
+  client.queryOptions(ledger, "icrc1_balance_of", {
+    owner: CYCLES_MINTING,
+    subaccount: null,
+  })
+)
+// Replicated, so the reply is certified.
+const certifiedFee = await ledgerOn(client, ICP_LEDGER, true).icrc1_fee()
+
+console.log("name          ", name)
+console.log("symbol        ", symbol)
+console.log("decimals      ", decimals)
+console.log("fee           ", fee, `(${tokens(fee)})`)
+console.log("certified fee ", certifiedFee)
+console.log("total supply  ", supply, `(${tokens(supply)})`)
+console.log("minting acct  ", minter?.owner ?? "none")
+console.log("metadata      ", metadata.map(([key]) => key).join(", "))
+console.log("CMC balance   ", cmc, `(${tokens(cmc)})`)
+
+// The first blocks live in an archive canister: the ledger's reply names it
+// and its method, and client.func() calls it, through the cache as the page.
+const blocks = blocksLedgerOn(client)
+const genesis = { start: 0n, length: 3n }
+const page = await client.queryClient.fetchQuery(
+  client.queryOptions(blocks, "query_blocks", genesis)
+)
+const archived = await Promise.all(
+  page.archived_blocks.map((range) =>
+    client.queryClient.fetchQuery(archivedRangeOptions(client, genesis, range))
+  )
+)
+const rows = blockRows(page, archived)
+// The newest blocks the ledger still holds itself.
+const latest = await blocks.query_blocks({
+  start: page.chain_length - 2n,
+  length: 2n,
+})
+console.log("chain length  ", page.chain_length)
+for (const row of [...rows, ...blockRows(latest, [])]) {
+  const { kind, e8s } = operationOf(row.block)
+  console.log(
+    `block ${row.index}`.padEnd(14),
+    blockTime(row.block),
+    kind,
+    e8s === undefined ? "" : tokens(e8s),
+    row.from === ICP_LEDGER ? "(the ledger)" : `(archive ${row.from})`
+  )
+}
+
+// get_btc_address is an update, so the anonymous client would refuse it. Any
+// caller that signs may ask the minter for anyone's address: a throwaway key.
+const signer = createClient({
+  network: "ic",
+  identity: Ed25519KeyIdentity.generate(),
+})
+const deposit = signer.queryOptions(
+  minterOn(signer),
+  "get_btc_address",
+  { owner: CYCLES_MINTING, subaccount: null },
+  { update: "idempotent" }
+)
+const btcAddress = await signer.queryClient.fetchQuery(deposit)
+// Kept for good (staleTime: Infinity): a second fetch is the cached answer.
+const updates = () =>
+  signer.queryClient.getQueryState(deposit.queryKey)?.dataUpdateCount
+const fetchedOnce = updates()
+assert.equal(await signer.queryClient.fetchQuery(deposit), btcAddress)
+assert.equal(updates(), fetchedOnce)
+assert.match(btcAddress, /^bc1q[02-9ac-hj-np-z]{38}$/)
+console.log("ckBTC address ", btcAddress, "(the CMC's deposit address)")
+signer.dispose()
+
+// The client is anonymous: it refuses a transfer before sending anything.
+try {
+  await ledger.icrc1_transfer({
+    to: { owner: NNS_GOVERNANCE, subaccount: null },
+    amount: 1n,
+    fee: null,
+    memo: null,
+    from_subaccount: null,
+    created_at_time: null,
+  })
+  assert.fail("an anonymous client sent a transfer")
+} catch (error) {
+  assert.ok(isReactorError(error))
+  console.log(
+    "transfer      ",
+    error.kind,
+    `(mayHaveExecuted: ${error.mayHaveExecuted})`
+  )
+  assert.equal(error.kind, "unauthenticated")
+}
+
+// A canister that is not a ledger answers with a reject.
+try {
+  await ledgerOn(client, NNS_GOVERNANCE).icrc1_name()
+  assert.fail("governance answered icrc1_name")
+} catch (error) {
+  assert.ok(isReactorError(error))
+  console.log("not a ledger  ", error.kind, `(reject code ${error.rejectCode})`)
+}
+
+assert.equal(symbol, "ICP")
+assert.equal(decimals, 8)
+assert.equal(certifiedFee, fee)
+assert.equal(typeof cmc, "bigint")
+assert.deepEqual(
+  rows.map((row) => row.index),
+  [0n, 1n, 2n]
+)
+assert.ok(rows.every((row) => row.from !== ICP_LEDGER))
+assert.equal(operationOf(rows[0]!.block).kind, "Mint")
+assert.equal(latest.archived_blocks.length, 0)
+client.dispose()
+console.log("ok")