@ic-reactor/mcp 0.0.0-stage → 0.0.0

package/examples/canister-studio/src/calls/dedupe.ts

@@ -0,0 +1,189 @@
+import { resolveSchema, type AnyFieldSchema } from "@meantjs/schema"
+import { isReactorError } from "@ic-reactor/core"
+import type { HintResolver } from "../forms/hints.ts"
+import type { CanisterInterface, MethodInfo } from "../interface/types.ts"
+import { prepareCall, type PreparedCall } from "./prepare.ts"
+
+// ICRC-1 ledgers (and the ICP ledger's own `transfer`) run a transaction at
+// most once per sender within their window when it carries
+// `created_at_time`: the same bytes from the same sender answer `Duplicate`.
+// That is the only thing that makes re-sending a write with an unknown
+// outcome safe, so the studio fills the field by default and offers
+// `client.resendOf()` only through it. The field's shape only says a
+// canister may deduplicate: the registry names the methods known to.
+
+const FIELD = "created_at_time"
+
+/** The argument path of the dedupe field, in the codec's grammar (what hints and issues use). */
+export const DEDUPE_PATH = `$args[0].${FIELD}`
+
+/**
+ * How a method's one argument carries `created_at_time`:
+ * `nat64` (`opt nat64`, ICRC-1 and ICRC-2) or `timestamp`
+ * (`opt record { timestamp_nanos : nat64 }`, the ICP ledger's `transfer`).
+ */
+export type DedupeShape = "nat64" | "timestamp"
+
+const isNat64 = (schema: AnyFieldSchema): boolean => {
+  const node = resolveSchema(schema)
+  return node.kind === "primitive" && node.primitive === "nat64"
+}
+
+/**
+ * The shape of the method's dedupe field, or `undefined` when its argument
+ * is not a single record with `created_at_time : opt nat64` (or the ICP
+ * ledger's timestamp record).
+ */
+export function dedupeShapeOf(method: MethodInfo): DedupeShape | undefined {
+  const [arg] = method.args
+  if (method.args.length !== 1 || arg === undefined) return undefined
+  const record = resolveSchema(arg)
+  if (record.kind !== "record" || !Object.hasOwn(record.fields, FIELD)) {
+    return undefined
+  }
+  const field = record.fields[FIELD]
+  if (field === undefined) return undefined
+  const opt = resolveSchema(field)
+  if (opt.kind !== "opt") return undefined
+  if (isNat64(opt.inner)) return "nat64"
+  const inner = resolveSchema(opt.inner)
+  if (
+    inner.kind === "record" &&
+    Object.keys(inner.fields).length === 1 &&
+    Object.hasOwn(inner.fields, "timestamp_nanos") &&
+    inner.fields.timestamp_nanos !== undefined &&
+    isNat64(inner.fields.timestamp_nanos)
+  ) {
+    return "timestamp"
+  }
+  return undefined
+}
+
+const isObject = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null
+
+/**
+ * The `dedupedBy` of `client.resendOf()` for these methods: the argument's
+ * `created_at_time`, or `null` when it has none (nothing is offered then).
+ */
+export function createdAtTimeOf(arg: unknown): unknown {
+  return isObject(arg) && Object.hasOwn(arg, FIELD)
+    ? (arg[FIELD] ?? null)
+    : null
+}
+
+/** The nanoseconds a `created_at_time` value stands for, either shape. */
+export function createdAtNanos(value: unknown): bigint | undefined {
+  if (typeof value === "bigint") return value
+  if (isObject(value) && typeof value.timestamp_nanos === "bigint") {
+    return value.timestamp_nanos
+  }
+  return undefined
+}
+
+/** Whether prefilled values already carry a `created_at_time` (a replayed call). */
+export function hasCreatedAtTime(
+  values: readonly unknown[] | undefined
+): boolean {
+  return values !== undefined && createdAtTimeOf(values[0]) !== null
+}
+
+/**
+ * The call with `created_at_time` set to `nanos`, re-encoded. A new argument
+ * object every time: an argument that was sent must never change, or
+ * `resendOf` would stop offering it (and a held one is refused `arg_changed`).
+ * Returns `undefined` when the stamped arguments do not encode.
+ */
+export function stampCreatedAtTime(
+  method: MethodInfo,
+  shape: DedupeShape,
+  call: PreparedCall,
+  nanos: bigint
+): PreparedCall | undefined {
+  const [first, ...rest] = call.values
+  if (!isObject(first)) return undefined
+  // A spread copies own keys as data properties, so a field named
+  // "__proto__" stays a field.
+  const stamped: Record<string, unknown> = {
+    ...first,
+    [FIELD]: shape === "nat64" ? nanos : { timestamp_nanos: nanos },
+  }
+  return prepareCall(method, [stamped, ...rest])
+}
+
+/**
+ * Hides the `created_at_time` field while the runner stamps it, so the form
+ * never shows a time that is not the one sent. The form's own "now" default
+ * stays off: the field starts empty, so turning the runner's switch off
+ * really sends no deduplication key until the user sets one.
+ */
+export const hideDedupeField: HintResolver = (ctx) =>
+  ctx.path === DEDUPE_PATH ? { hidden: true, nowByDefault: false } : undefined
+
+/**
+ * Whether the canister is known to run this method at most once per sender
+ * and argument carrying `created_at_time` (the registry's `dedupedMethods`).
+ * A runtime or pasted interface never is: on those the studio words the
+ * re-send as conditional, since nothing proves the canister deduplicates.
+ */
+export function knownDeduplicating(
+  iface: CanisterInterface,
+  method: MethodInfo
+): boolean {
+  return (
+    dedupeShapeOf(method) !== undefined &&
+    iface.registry?.dedupedMethods?.includes(method.name) === true
+  )
+}
+
+/**
+ * The Err tag a deduplicating canister answers to the same bytes again:
+ * ICRC-1 and ICRC-2 say `Duplicate`; the ICP ledger's own `transfer`, the
+ * timestamp shape, says `TxDuplicate`.
+ */
+export function duplicateTagOf(
+  shape: DedupeShape
+): "Duplicate" | "TxDuplicate" {
+  return shape === "timestamp" ? "TxDuplicate" : "Duplicate"
+}
+
+/**
+ * The tag of a canister_err payload that says the write had already run:
+ * `Duplicate` (ICRC-1, ICRC-2) or `TxDuplicate` (the ICP ledger's
+ * `transfer`); `undefined` for any other payload.
+ */
+export function duplicateTagIn(
+  err: unknown
+): "Duplicate" | "TxDuplicate" | undefined {
+  if (!isObject(err)) return undefined
+  return err.tag === "Duplicate" || err.tag === "TxDuplicate"
+    ? err.tag
+    : undefined
+}
+
+/** Whether a canister_err payload says the write had already run. */
+export const isDuplicateErr = (err: unknown): boolean =>
+  duplicateTagIn(err) !== undefined
+
+/**
+ * Why a re-send that failed leaves the first send's outcome unknown, as a
+ * clause. An Err other than a duplicate answers only the re-send: an ICRC-1
+ * ledger checks the fee and the time window (`BadFee`, `TooOld`) before it
+ * looks for a duplicate. A re-send that never ran says nothing either.
+ */
+export function resendLeftOpen(error: unknown): string {
+  if (!isReactorError(error)) {
+    return "the re-send failed, which says nothing about the first send"
+  }
+  if (error.kind === "canister_err" && isDuplicateErr(error.err)) {
+    return `the canister answered the re-send ${String(duplicateTagIn(error.err))}, but it is not known to deduplicate, so that answer does not prove the first send ran`
+  }
+  if (error.kind === "canister_err") {
+    const err: unknown = error.err
+    const tag = isObject(err) && typeof err.tag === "string" ? err.tag : "Err"
+    return `the canister answered the re-send ${tag}, which says nothing about the first send: a ledger checks the fee and the time window before it looks for a duplicate`
+  }
+  const kind =
+    error.code === undefined ? error.kind : `${error.kind}/${error.code}`
+  return `the re-send did not run (${kind}), so it says nothing about the first send`
+}

package/examples/canister-studio/src/calls/error-info.ts

@@ -0,0 +1,168 @@
+import {
+  isReactorError,
+  type ReactorError,
+  type ReactorErrorKind,
+} from "@ic-reactor/core"
+
+/** What each kind means, from the Errors table of `@ic-reactor/core`'s guide. */
+export const KIND_INFO: Readonly<
+  Record<ReactorErrorKind, { readonly title: string; readonly meaning: string }>
+> = {
+  invalid_args: {
+    title: "Refused before sending",
+    meaning:
+      "The arguments do not encode as the method's Candid types. Nothing was sent.",
+  },
+  unauthenticated: {
+    title: "Refused before sending",
+    meaning:
+      "A write needs a signed-in caller, and the caller is anonymous. Nothing was sent.",
+  },
+  not_delivered: {
+    title: "Not delivered",
+    meaning:
+      "The replica or a boundary node refused the request (HTTP 4xx other than 408, 429 included), the IC could not take it in (reject code 2), or a read got no answer. Nothing ran.",
+  },
+  outcome_unknown: {
+    title: "Outcome unknown",
+    meaning:
+      "The call went out and no trustworthy answer came back (a network drop, a timeout, HTTP 5xx or 408), or a held re-send did not run while the write it re-sends may have. It may or may not have run.",
+  },
+  rejected: {
+    title: "Rejected",
+    meaning: "The IC or the canister rejected the call.",
+  },
+  invalid_reply: {
+    title: "Reply did not decode",
+    meaning:
+      "A reply came back, but not as the method's result type. A write may have run anyway.",
+  },
+  canister_err: {
+    title: "The canister answered Err",
+    meaning:
+      "The method ran and answered with the Err arm of its result: that is the outcome. Sending again is a new decision, not a retry.",
+  },
+  cancelled: {
+    title: "Cancelled",
+    meaning: "The caller changed or the call was aborted.",
+  },
+}
+
+/** The sub-reasons a `ReactorError` can carry, in plain words. */
+const CODE_INFO: ReadonlyMap<string, string> = new Map(
+  Object.entries({
+    anonymous_write:
+      "Nobody is signed in, and the client never sends a write as the anonymous principal.",
+    identity_unavailable: "The signed-in identity could not be loaded.",
+    caller_changed:
+      "Someone else is signed in now: a call is made as the principal it was built for, or not at all.",
+    target_changed:
+      "A held re-send may go only to the method and canister its first send went to.",
+    arg_changed:
+      "The held re-send's argument no longer encodes to the bytes first sent.",
+    client_disposed: "The client was disposed: nothing was sent.",
+    canister_not_found: "The IC answered that no canister exists at this id.",
+    canister_id_unresolved: "The canister's id could not be resolved.",
+    no_certified_path:
+      "A composite query has no certified path: read it without certification.",
+    effective_canister_id_unknown:
+      "The management canister call names no canister to route it by.",
+  })
+)
+
+/** A `ReactorError` code in plain words, or `undefined` for a code this app does not know. */
+export const codeMeaning = (code: string): string | undefined =>
+  CODE_INFO.get(code)
+
+/** The reject codes of the IC interface specification. */
+const REJECT_NAMES: readonly string[] = [
+  "",
+  "SYS_FATAL",
+  "SYS_TRANSIENT",
+  "DESTINATION_INVALID",
+  "CANISTER_REJECT",
+  "CANISTER_ERROR",
+  "SYS_UNKNOWN",
+]
+
+/** The name of a reject code (`5` → `CANISTER_ERROR`), or `undefined` for any other number. */
+export const rejectName = (code: number): string | undefined =>
+  Number.isInteger(code) && code >= 1 ? REJECT_NAMES[code] : undefined
+
+/**
+ * What a reject code says about whether canister code ran. On the
+ * management canister (`aaaaa-aa`) the codes prove nothing: it may have
+ * acted before rejecting.
+ */
+export function rejectMeaning(
+  code: number,
+  write: boolean,
+  canisterId?: string
+): string {
+  if (canisterId === "aaaaa-aa") {
+    return "On the management canister, a reject code proves nothing about what ran."
+  }
+  if (code === 1 || code === 3) {
+    return "Rejected before any canister code ran."
+  }
+  if (code === 2) return "The IC could not take the request in (transient)."
+  if (code === 4 || code === 5) {
+    return write
+      ? "The canister rejected or trapped, maybe after changing state."
+      : "The canister rejected or trapped."
+  }
+  return "The IC could not say what happened."
+}
+
+const text = (value: unknown): string | undefined =>
+  typeof value === "string" && value !== "" ? value : undefined
+
+/**
+ * What the agent's own error adds to a `ReactorError`. The client cuts its
+ * `message` to 160 characters, and keeps the agent's error as a
+ * non-enumerable `cause`: the full reject text and the IC error code
+ * (`IC0536`) are read from `cause.code`.
+ */
+export interface CauseDetails {
+  readonly name?: string
+  readonly rejectMessage?: string
+  readonly rejectErrorCode?: string
+  readonly bodyText?: string
+}
+
+export function causeDetails(error: {
+  readonly cause?: unknown
+}): CauseDetails {
+  const cause = error.cause
+  if (typeof cause !== "object" || cause === null) return {}
+  const code = (cause as { code?: unknown }).code
+  const fields =
+    typeof code === "object" && code !== null
+      ? (code as Record<string, unknown>)
+      : {}
+  return {
+    name: text(fields.name) ?? text((cause as { name?: unknown }).name),
+    rejectMessage: text(fields.rejectMessage),
+    rejectErrorCode: text(fields.rejectErrorCode),
+    bodyText: text(fields.bodyText),
+  }
+}
+
+/** The three answers to "did it happen?" a failed call can give. */
+export type Verdict = "may_have_executed" | "answered_err" | "not_executed"
+
+export function verdictOf(error: ReactorError<unknown>): Verdict {
+  if (error.mayHaveExecuted) return "may_have_executed"
+  if (error.kind === "canister_err") return "answered_err"
+  return "not_executed"
+}
+
+/** A short line for the history list and logs: `kind/code: …`. */
+export function errorSummary(error: unknown): string {
+  if (!isReactorError(error)) {
+    return error instanceof Error ? error.message : String(error)
+  }
+  const head =
+    error.code === undefined ? error.kind : `${error.kind}/${error.code}`
+  return error.mayHaveExecuted ? `${head} (may have executed)` : head
+}

package/examples/canister-studio/src/calls/history.test.ts

@@ -0,0 +1,284 @@
+import { principal } from "@meantjs/schema"
+import { decodeArgs } from "@meantjs/schema/codec"
+import { createTestClient } from "@ic-reactor/core/testing"
+import { act, renderHook } from "@testing-library/react"
+import { defaultParseSearch } from "@tanstack/react-router"
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
+import { fromHex, toHex } from "../lib/hex.ts"
+import {
+  HISTORY_LIMIT,
+  HISTORY_STORAGE_KEY,
+  addHistoryEntry,
+  clearHistory,
+  parseHistory,
+  useCallHistory,
+  type HistoryEntry,
+} from "./history.ts"
+import { prepareCall } from "./prepare.ts"
+import { HISTORY_ARGS_MAX_BYTES, historyEntryOf } from "./record.ts"
+import { SHARED_ARGS_MAX_HEX, sharedCallUrl } from "./share.ts"
+import { canisterOf } from "./useCanisterHandle.ts"
+import {
+  CKBTC_LEDGER,
+  SEED_1,
+  methodOf,
+  transferArg,
+  typedInterface,
+} from "./testing/fixtures.ts"
+
+const iface = typedInterface(CKBTC_LEDGER)
+const transfer = methodOf(iface, "icrc1_transfer")
+const balanceOf = methodOf(iface, "icrc1_balance_of")
+
+function entry(
+  id: string,
+  overrides: Partial<HistoryEntry> = {}
+): HistoryEntry {
+  return {
+    id,
+    at: 1_760_000_000_000,
+    canisterId: CKBTC_LEDGER,
+    canisterName: "ckBTC ledger",
+    method: "icrc1_balance_of",
+    mode: "query",
+    caller: SEED_1,
+    argsHex: "4449444c0000",
+    outcome: "ok",
+    summary: "ok: 1",
+    ...overrides,
+  }
+}
+
+beforeEach(() => {
+  localStorage.clear()
+  clearHistory()
+})
+afterEach(() => {
+  vi.restoreAllMocks()
+})
+
+describe("history", () => {
+  it("stores a call's arguments as the hex of its encoded bytes, never JSON", () => {
+    const call = prepareCall(transfer, [transferArg(principal("aaaaa-aa"), 5n)])
+    if (call === undefined) throw new Error("transfer does not encode")
+    const made = historyEntryOf(
+      {
+        iface,
+        method: transfer,
+        caller: SEED_1,
+        bytes: call.bytes,
+        result: { ok: true, reply: 12n },
+      },
+      1_760_000_000_000,
+      "a"
+    )
+    addHistoryEntry(made)
+    const stored = parseHistory(localStorage.getItem(HISTORY_STORAGE_KEY))
+    expect(stored).toHaveLength(1)
+    expect(stored[0]?.argsHex).toBe(toHex(call.bytes))
+    expect(stored[0]?.argsHex.startsWith("4449444c")).toBe(true)
+    expect(fromHex(stored[0]?.argsHex ?? "")).toEqual(call.bytes)
+    expect(stored[0]).toMatchObject({
+      outcome: "ok",
+      summary: "ok: 12",
+      mode: "update",
+    })
+  })
+
+  it("records a failure's kind and whether it may have executed", async () => {
+    const test = createTestClient({ network: "ic", signedIn: false })
+    const call = prepareCall(transfer, [transferArg(principal("aaaaa-aa"), 5n)])
+    if (call === undefined) throw new Error("transfer does not encode")
+    let error: unknown
+    try {
+      await test.client
+        .mutationOptions(canisterOf(test.client, iface), "icrc1_transfer")
+        .mutationFn(call.vars)
+    } catch (caught) {
+      error = caught
+    }
+    test.client.dispose()
+    const made = historyEntryOf(
+      {
+        iface,
+        method: transfer,
+        caller: "2vxsx-fae",
+        bytes: call.bytes,
+        result: { ok: false, error },
+      },
+      1,
+      "b"
+    )
+    expect(made).toMatchObject({
+      outcome: "error",
+      kind: "unauthenticated",
+      mayHaveExecuted: false,
+      summary: "unauthenticated/anonymous_write",
+    })
+  })
+
+  it("keeps no arguments past the size cap", () => {
+    const made = historyEntryOf(
+      {
+        iface,
+        method: transfer,
+        caller: SEED_1,
+        bytes: new Uint8Array(HISTORY_ARGS_MAX_BYTES + 1),
+        result: { ok: true, reply: 1n },
+      },
+      1,
+      "c"
+    )
+    expect(made.argsHex).toBe("")
+    expect(made.summary).toContain("too large")
+  })
+
+  it("drops entries that are not entries, and keeps the newest", () => {
+    localStorage.setItem(
+      HISTORY_STORAGE_KEY,
+      JSON.stringify([
+        entry("ok"),
+        { ...entry("bad-hex"), argsHex: "zz" },
+        { id: 1 },
+        "x",
+      ])
+    )
+    expect(
+      parseHistory(localStorage.getItem(HISTORY_STORAGE_KEY)).map((e) => e.id)
+    ).toEqual(["ok"])
+    expect(parseHistory("not json")).toEqual([])
+    for (let i = 0; i < HISTORY_LIMIT + 5; i++) addHistoryEntry(entry(`e${i}`))
+    const kept = parseHistory(localStorage.getItem(HISTORY_STORAGE_KEY))
+    expect(kept).toHaveLength(HISTORY_LIMIT)
+    expect(kept[0]?.id).toBe(`e${HISTORY_LIMIT + 4}`)
+  })
+
+  it("serves the hook's entries, and keeps working in memory when storage throws", () => {
+    const { result } = renderHook(() => useCallHistory())
+    expect(result.current.entries).toEqual([])
+    act(() => result.current.add(entry("one")))
+    expect(result.current.entries.map((e) => e.id)).toEqual(["one"])
+
+    vi.spyOn(Storage.prototype, "setItem").mockImplementation(() => {
+      throw new DOMException("quota", "QuotaExceededError")
+    })
+    act(() => result.current.add(entry("two")))
+    expect(result.current.entries.map((e) => e.id)).toEqual(["two", "one"])
+    act(() => result.current.clear())
+    expect(result.current.entries).toEqual([])
+  })
+})
+
+describe("a oneway call in the history", () => {
+  it("is recorded as sent, never as an Ok outcome", () => {
+    const oneway = { ...transfer, mode: "oneway" as const }
+    const e = historyEntryOf(
+      {
+        iface,
+        method: oneway,
+        caller: SEED_1,
+        bytes: new Uint8Array([0x44, 0x49, 0x44, 0x4c]),
+        result: { ok: true, reply: undefined },
+      },
+      1,
+      "oneway-1"
+    )
+    expect(e.outcome).toBe("sent")
+    expect(e.summary).not.toMatch(/^ok/)
+    // It survives a round trip through storage.
+    expect(parseHistory(JSON.stringify([e]))).toEqual([e])
+  })
+})
+
+describe("history shared by tabs", () => {
+  // A fresh module per test: an earlier test leaves this one's copy in its
+  // storage-failed mode.
+  const fresh = async () => {
+    vi.resetModules()
+    return import("./history.ts")
+  }
+
+  it("puts back an entry of this tab that another tab's stale write dropped", async () => {
+    const { addHistoryEntry } = await fresh()
+    addHistoryEntry(entry("mine", { at: 2, mayHaveExecuted: true }))
+    // Another tab read the store before "mine" landed and wrote its own.
+    const theirs = JSON.stringify([entry("theirs", { at: 3 })])
+    localStorage.setItem(HISTORY_STORAGE_KEY, theirs)
+    window.dispatchEvent(
+      new StorageEvent("storage", {
+        key: HISTORY_STORAGE_KEY,
+        newValue: theirs,
+      })
+    )
+    const ids = parseHistory(localStorage.getItem(HISTORY_STORAGE_KEY)).map(
+      (e) => e.id
+    )
+    expect(ids).toEqual(["theirs", "mine"])
+  })
+
+  it("does not bring entries back after another tab cleared the history", async () => {
+    const { addHistoryEntry } = await fresh()
+    addHistoryEntry(entry("mine"))
+    localStorage.setItem(HISTORY_STORAGE_KEY, "[]")
+    window.dispatchEvent(
+      new StorageEvent("storage", { key: HISTORY_STORAGE_KEY, newValue: "[]" })
+    )
+    expect(parseHistory(localStorage.getItem(HISTORY_STORAGE_KEY))).toEqual([])
+  })
+})
+
+describe("shared call links", () => {
+  const account = { owner: principal(SEED_1), subaccount: null }
+  const call = prepareCall(balanceOf, [account])
+  if (call === undefined) throw new Error("account does not encode")
+
+  it("writes the search as the router reads it back: run a boolean, args the exact bytes", () => {
+    const url = sharedCallUrl(
+      CKBTC_LEDGER,
+      "icrc1_balance_of",
+      call.bytes,
+      true
+    )
+    expect(url).toBe(
+      `/canister/${CKBTC_LEDGER}?method=icrc1_balance_of&args=${toHex(call.bytes)}&run=true`
+    )
+    const search: Record<string, unknown> = defaultParseSearch(
+      new URL(url, "http://localhost").search
+    )
+    expect(search).toEqual({
+      method: "icrc1_balance_of",
+      args: toHex(call.bytes),
+      run: true,
+    })
+    const decoded = decodeArgs(
+      balanceOf.args,
+      fromHex(String(search.args)) ?? new Uint8Array()
+    )
+    expect(decoded.ok && decoded.values).toEqual([account])
+    expect(
+      sharedCallUrl(CKBTC_LEDGER, "icrc1_balance_of", call.bytes, false, {
+        certified: true,
+      })
+    ).toBe(
+      `/canister/${CKBTC_LEDGER}?method=icrc1_balance_of&args=${toHex(call.bytes)}&certified=true`
+    )
+  })
+
+  it("quotes a method name the router would read as JSON", () => {
+    const url = sharedCallUrl(CKBTC_LEDGER, "123", call.bytes, false)
+    const search: Record<string, unknown> = defaultParseSearch(
+      new URL(url, "http://localhost").search
+    )
+    expect(search.method).toBe("123")
+  })
+
+  it("leaves arguments too large for a URL (or unknown) out, and does not run", () => {
+    const big = new Uint8Array(SHARED_ARGS_MAX_HEX / 2 + 1)
+    expect(sharedCallUrl(CKBTC_LEDGER, "icrc1_balance_of", big, true)).toBe(
+      `/canister/${CKBTC_LEDGER}?method=icrc1_balance_of`
+    )
+    expect(
+      sharedCallUrl(CKBTC_LEDGER, "icrc1_balance_of", new Uint8Array(), true)
+    ).toBe(`/canister/${CKBTC_LEDGER}?method=icrc1_balance_of`)
+  })
+})