@ic-reactor/mcp 0.0.0-stage → 0.0.0

package/examples/canister-studio/src/components/canister/MethodWorkspace.tsx

@@ -0,0 +1,187 @@
+import { Link } from "@tanstack/react-router"
+import { useEffect, useMemo, useRef, type ReactElement } from "react"
+import { callKindOf, type CallKind } from "../../calls/kinds.ts"
+import { MethodRunner } from "../../calls/MethodRunner.tsx"
+import { heuristicHints } from "../../forms/hints.ts"
+import type { CanisterInterface, MethodInfo } from "../../interface/types.ts"
+import { Badge, ModeBadge } from "../Badge.tsx"
+import { EmptyState } from "../EmptyState.tsx"
+import { Notice } from "../Notice.tsx"
+import { decodeSharedArgs, readsAtOnce } from "./shared-call.ts"
+import { registryUnits } from "./use-canister-page.ts"
+
+export interface MethodWorkspaceProps {
+  iface: CanisterInterface
+  /** The `?method=` text, even when no such method exists. */
+  methodName: string
+  method: MethodInfo | undefined
+  /** A link's argument bytes (hex): shared, a quick read, a replay. */
+  argsHex?: string
+  /** The link asks to read at once. */
+  run: boolean
+  certified: boolean
+  /**
+   * Asked once, as the workspace mounts: whether the reader just picked this
+   * method on the page. If so and its heading is out of view or low on the
+   * screen (on a phone the list sits above the workspace), the workspace
+   * scrolls the heading up and moves focus there.
+   */
+  wasPicked?(): boolean
+}
+
+/** Room left above a heading scrolled to, below the sticky header. */
+const HEADING_GAP_PX = 16
+
+/** Why a link that asks to run a method only fills its form. */
+const NOT_RUN: Readonly<Record<CallKind["kind"], string>> = {
+  read: "A composite query has no certified path, so it is not read at once from a certified link: the form holds the link’s arguments.",
+  idempotent:
+    "The form holds the link’s arguments. An idempotent update still goes through consensus as you: links never send one, so send it yourself.",
+  update:
+    "The form holds the link’s arguments. Links never send a write: review it, then send it yourself.",
+  oneway:
+    "The form holds the link’s arguments. Links never send a write: review it, then send it yourself.",
+  call: "The form holds the link’s arguments. A query without results is called, not read at once: press Call to send it.",
+}
+
+/**
+ * The selected method: its heading and docs, what a shared link brought
+ * (arguments decoded from the link, or why they could not be), and the
+ * runner with its form, call, reply and errors.
+ */
+export function MethodWorkspace({
+  iface,
+  methodName,
+  method,
+  argsHex,
+  run,
+  certified,
+  wasPicked,
+}: MethodWorkspaceProps): ReactElement {
+  const units = useMemo(() => registryUnits(iface.registry), [iface.registry])
+  const hints = useMemo(
+    () => heuristicHints(units === undefined ? undefined : { units }),
+    [units]
+  )
+  // Decoded on both sides from the same bytes, so the server's prefetch and
+  // the runner build the same arguments, and the same query key. Memoized:
+  // the runner gets the same initial values on every render.
+  const shared = useMemo(
+    () =>
+      method === undefined || argsHex === undefined
+        ? undefined
+        : decodeSharedArgs(method, argsHex),
+    [method, argsHex]
+  )
+
+  const heading = useRef<HTMLHeadingElement>(null)
+  // Once per mount, on purpose: the page keys the workspace by method.
+  useEffect(() => {
+    const picked = wasPicked?.() === true
+    const element = heading.current
+    if (!picked || element === null) return
+    // Measured, not assumed: the sticky header wraps to two rows on a phone.
+    const header =
+      document.querySelector(".app-header")?.getBoundingClientRect().bottom ?? 0
+    // Left alone in the upper half of the screen, where the form below it
+    // shows too; moved up from anywhere else, out of view included.
+    const { top } = element.getBoundingClientRect()
+    if (top >= header && top <= window.innerHeight / 2) return
+    window.scrollTo({ top: window.scrollY + top - header - HEADING_GAP_PX })
+    element.focus({ preventScroll: true })
+  }, [])
+
+  if (method === undefined) {
+    return (
+      <EmptyState title="No such method">
+        <p>
+          This canister has no method named{" "}
+          <code className="code-inline break-all">{methodName}</code>.
+        </p>
+        <p>Pick one from the list.</p>
+      </EmptyState>
+    )
+  }
+
+  const initialValues = shared?.ok === true ? shared.values : undefined
+  const kind = callKindOf(iface, method)
+  const idempotent = kind.kind === "idempotent"
+  // The same rule as the route's loader, so the runner reads at once exactly
+  // what the server prefetched: a write always waits for its sender.
+  const autoRun =
+    run && initialValues !== undefined && readsAtOnce(kind, certified)
+
+  return (
+    <div className="stack-lg">
+      <header className="method-heading">
+        <div className="row">
+          <h2
+            ref={heading}
+            className="method-heading-name mono break-all"
+            tabIndex={-1}
+          >
+            {method.name}
+          </h2>
+          <ModeBadge mode={method.mode} size="lg" />
+          {idempotent && (
+            <Badge
+              tone="info"
+              size="lg"
+              title="The registry marks this update as idempotent: it is offered as a read through { update: 'idempotent' }, and still needs you signed in."
+            >
+              idempotent
+            </Badge>
+          )}
+        </div>
+        {method.doc !== undefined && method.doc !== "" && (
+          <p className="method-heading-doc text-sm muted">{method.doc}</p>
+        )}
+      </header>
+
+      {shared !== undefined && !shared.ok && (
+        <Notice tone="warn" title="The shared arguments were not used">
+          <p className="break-all">{shared.message}</p>
+          <p>The form starts from its defaults instead.</p>
+        </Notice>
+      )}
+      {shared?.ok === true && run && !autoRun && (
+        <Notice tone="info" title="Not run from the link">
+          <p>{NOT_RUN[kind.kind]}</p>
+        </Notice>
+      )}
+      {/* The same link comes from a shared URL, a quick read or a replay, so
+          it says what happened, not where it came from. */}
+      {shared?.ok === true && autoRun && (
+        <p className="text-xs muted" role="note">
+          {method.args.length === 0 ? (
+            "Read at once: it takes no arguments."
+          ) : (
+            <>
+              Read at once with the link’s arguments.{" "}
+              <Link
+                to="/canister/$canisterId"
+                params={{ canisterId: iface.canisterId }}
+                search={{
+                  method: method.name,
+                  certified: certified ? true : undefined,
+                }}
+              >
+                Start from an empty form
+              </Link>
+            </>
+          )}
+        </p>
+      )}
+
+      <MethodRunner
+        iface={iface}
+        method={method}
+        initialValues={initialValues}
+        autoRun={autoRun}
+        certified={certified}
+        hints={hints}
+        units={units}
+      />
+    </div>
+  )
+}

package/examples/canister-studio/src/components/canister/shared-call.test.ts

@@ -0,0 +1,186 @@
+import { serviceMethods } from "@meantjs/schema"
+import { encodeArgs } from "@meantjs/schema/codec"
+import { QueryClient } from "@tanstack/react-query"
+import { describe, expect, it } from "vitest"
+import { actor, Account } from "../../canisters/icrc1.ts"
+import type { MethodInfo } from "../../interface/types.ts"
+import { toHex } from "../../lib/hex.ts"
+import {
+  decodeSharedArgs,
+  MAX_SHARED_ARGS_BYTES,
+  methodSearchSchema,
+  readsAtOnce,
+  readWithin,
+} from "./shared-call.ts"
+
+const methods = serviceMethods(actor)
+
+function method(name: string): MethodInfo {
+  const found = methods.get(name)
+  if (found === undefined) throw new Error(`no ${name}`)
+  return found
+}
+
+const NNS_GOVERNANCE = "rrkah-fqaaa-aaaaa-aaaaq-cai"
+
+function balanceArgsHex(): string {
+  const encoded = encodeArgs(
+    [Account],
+    [{ owner: NNS_GOVERNANCE, subaccount: null }]
+  )
+  if (!encoded.ok) throw new Error("does not encode")
+  return toHex(encoded.bytes)
+}
+
+describe("methodSearchSchema", () => {
+  it("reads the spellings the router's JSON parsing produces", () => {
+    expect(
+      methodSearchSchema.parse({
+        method: "icrc1_symbol",
+        args: "4449444c0000",
+        run: 1,
+        certified: "true",
+      })
+    ).toEqual({
+      method: "icrc1_symbol",
+      args: "4449444c0000",
+      run: true,
+      certified: true,
+    })
+    expect(methodSearchSchema.parse({ run: false, certified: 0 })).toEqual({
+      run: false,
+      certified: false,
+    })
+    // A method named like a number arrives as a number.
+    expect(methodSearchSchema.parse({ method: 123 }).method).toBe("123")
+  })
+
+  it("drops what does not parse instead of failing the page", () => {
+    expect(
+      methodSearchSchema.parse({
+        method: "",
+        args: "4449444c000",
+        run: "yes",
+        certified: { nested: true },
+      })
+    ).toEqual({})
+    expect(methodSearchSchema.parse({ args: "zz" }).args).toBeUndefined()
+    const tooLong = "00".repeat(MAX_SHARED_ARGS_BYTES + 1)
+    expect(methodSearchSchema.parse({ args: tooLong }).args).toBeUndefined()
+  })
+})
+
+describe("decodeSharedArgs", () => {
+  it("decodes a link's bytes into the method's argument values", () => {
+    const shared = decodeSharedArgs(
+      method("icrc1_balance_of"),
+      balanceArgsHex()
+    )
+    expect(shared).toEqual({
+      ok: true,
+      values: [{ owner: NNS_GOVERNANCE, subaccount: null }],
+    })
+  })
+
+  it("decodes the empty argument list", () => {
+    expect(decodeSharedArgs(method("icrc1_symbol"), "4449444c0000")).toEqual({
+      ok: true,
+      values: [],
+    })
+  })
+
+  it("says why bytes are unusable", () => {
+    const balance = method("icrc1_balance_of")
+    expect(decodeSharedArgs(balance, "xyz")).toMatchObject({ ok: false })
+    // Valid Candid, but no arguments where an Account is expected.
+    const empty = decodeSharedArgs(balance, "4449444c0000")
+    expect(empty.ok).toBe(false)
+    if (!empty.ok) expect(empty.message).toMatch(/do not decode/)
+    const tooLarge = decodeSharedArgs(
+      balance,
+      "00".repeat(MAX_SHARED_ARGS_BYTES + 1)
+    )
+    expect(tooLarge).toEqual({
+      ok: false,
+      message: "The arguments in the link exceed 16 KiB.",
+    })
+  })
+})
+
+describe("readsAtOnce", () => {
+  it("reads at once a query with results, and a composite one only uncertified", () => {
+    const query = { kind: "read", certifiable: true } as const
+    const composite = { kind: "read", certifiable: false } as const
+    expect(readsAtOnce(query, false)).toBe(true)
+    expect(readsAtOnce(query, true)).toBe(true)
+    expect(readsAtOnce(composite, false)).toBe(true)
+    expect(readsAtOnce(composite, true)).toBe(false)
+  })
+
+  it("never runs a write, an idempotent update or a query without results", () => {
+    for (const kind of ["update", "oneway", "idempotent", "call"] as const) {
+      expect(readsAtOnce({ kind }, false)).toBe(false)
+    }
+  })
+})
+
+describe("readWithin", () => {
+  const key = ["test", "read"] as const
+
+  it("waits for a read that settles in time", async () => {
+    const queryClient = new QueryClient()
+    await readWithin(
+      queryClient,
+      key,
+      () => queryClient.query({ queryKey: key, queryFn: async () => 42 }),
+      1_000
+    )
+    expect(queryClient.getQueryData(key)).toBe(42)
+  })
+
+  it("never throws for a failed read", async () => {
+    const queryClient = new QueryClient({
+      defaultOptions: { queries: { retry: false } },
+    })
+    await expect(
+      readWithin(
+        queryClient,
+        key,
+        () =>
+          queryClient.query({
+            queryKey: key,
+            queryFn: async () => {
+              throw new Error("rejected")
+            },
+          }),
+        1_000
+      )
+    ).resolves.toBeUndefined()
+    expect(queryClient.getQueryState(key)?.status).toBe("error")
+  })
+
+  it("cancels a read still running at the deadline", async () => {
+    const queryClient = new QueryClient()
+    await readWithin(
+      queryClient,
+      key,
+      () =>
+        queryClient.query({
+          queryKey: key,
+          queryFn: ({ signal }) =>
+            new Promise<number>((resolve, reject) => {
+              const timer = setTimeout(() => resolve(1), 5_000)
+              signal.addEventListener("abort", () => {
+                clearTimeout(timer)
+                reject(signal.reason)
+              })
+            }),
+        }),
+      20
+    )
+    const state = queryClient.getQueryState(key)
+    // Not in flight, so the server never sends it half done.
+    expect(state?.fetchStatus).toBe("idle")
+    expect(state?.data).toBeUndefined()
+  })
+})

package/examples/canister-studio/src/components/canister/shared-call.ts

@@ -0,0 +1,133 @@
+import { decodeArgs } from "@meantjs/schema/codec"
+import type { QueryClient, QueryKey } from "@tanstack/react-query"
+import { z } from "zod"
+import type { CallKind } from "../../calls/kinds.ts"
+import type { MethodInfo } from "../../interface/types.ts"
+import { fromHex } from "../../lib/hex.ts"
+
+/**
+ * Shared links are read with up to 16 KiB of argument bytes. The links this
+ * app writes carry less (`argsFitInUrl` in calls/share.ts): a URL is a
+ * request line, and Node refuses one that long.
+ */
+export const MAX_SHARED_ARGS_BYTES = 16 * 1024
+
+// The router parses each search value as JSON first, so `run=1` arrives as
+// the number 1 and a method named `123` as a number: accept those spellings
+// and turn them into what the page means.
+const flag = z
+  .union([
+    z.boolean(),
+    z.literal(1),
+    z.literal(0),
+    z.literal("1"),
+    z.literal("0"),
+    z.literal("true"),
+    z.literal("false"),
+  ])
+  .transform(
+    (value) =>
+      value === true || value === 1 || value === "1" || value === "true"
+  )
+
+const methodName = z
+  .union([z.string(), z.number(), z.boolean()])
+  .transform((value) => String(value))
+  .pipe(z.string().min(1).max(1024))
+
+const argsHex = z
+  .string()
+  .regex(/^(?:0x)?(?:[0-9a-fA-F]{2})*$/)
+  .refine(
+    (text) => text.replace(/^0x/i, "").length <= MAX_SHARED_ARGS_BYTES * 2
+  )
+
+/**
+ * The method workspace's search params. Each falls back to "absent" when
+ * it does not parse (`.catch`), so a mangled link opens the page instead of
+ * failing it.
+ */
+export const methodSearchSchema = z.object({
+  method: methodName.optional().catch(undefined),
+  args: argsHex.optional().catch(undefined),
+  run: flag.optional().catch(undefined),
+  certified: flag.optional().catch(undefined),
+})
+
+/**
+ * Whether a link's `run` reads the method at once (and the server prefetches
+ * it): only a read as `callKindOf` decides it, a query or composite query
+ * with results, and a composite query only off the certified twin, which it
+ * does not have. Anything else opens prefilled and waits for a click: a write
+ * is never sent from a link, an idempotent update needs a signed-in caller,
+ * and a query without results is called, not cached (`queryOptions` refuses
+ * it).
+ */
+export function readsAtOnce(kind: CallKind, certified: boolean): boolean {
+  return kind.kind === "read" && (kind.certifiable || !certified)
+}
+
+export type SharedArgs =
+  | { readonly ok: true; readonly values: readonly unknown[] }
+  | { readonly ok: false; readonly message: string }
+
+/**
+ * A shared link's argument bytes, decoded against the method's argument
+ * schemas: the values a form starts from. Pure and deterministic, so the
+ * server's loader and the page (on both sides) reach the same values, and so
+ * the same query key.
+ */
+export function decodeSharedArgs(method: MethodInfo, hex: string): SharedArgs {
+  const bytes = fromHex(hex)
+  if (bytes === undefined) {
+    return { ok: false, message: "The arguments in the link are not hex." }
+  }
+  if (bytes.length > MAX_SHARED_ARGS_BYTES) {
+    return { ok: false, message: "The arguments in the link exceed 16 KiB." }
+  }
+  const decoded = decodeArgs(method.args, bytes)
+  if (!decoded.ok) {
+    const first = decoded.issues[0]
+    return {
+      ok: false,
+      message:
+        first === undefined
+          ? "The arguments in the link do not decode for this method."
+          : `The arguments in the link do not decode for this method: ${first.message} (${first.path})`,
+    }
+  }
+  return { ok: true, values: decoded.values }
+}
+
+/** How long a server render waits for a shared link's read. */
+export const SHARED_READ_BUDGET_MS = 4_000
+
+/**
+ * Waits for a read (`run()`, which starts it) at most `budgetMs`. Never
+ * throws. A read still running at the deadline is cancelled, so it is not
+ * sent to the browser half done: the page reads it again itself after
+ * hydrating, and shows the real error if it fails.
+ */
+export async function readWithin(
+  queryClient: QueryClient,
+  queryKey: QueryKey,
+  run: () => Promise<unknown>,
+  budgetMs: number
+): Promise<void> {
+  let timer: ReturnType<typeof setTimeout> | undefined
+  const deadline = new Promise<"late">((resolve) => {
+    timer = setTimeout(() => resolve("late"), budgetMs)
+  })
+  try {
+    const outcome = await Promise.race([
+      run().then(
+        () => "settled" as const,
+        () => "settled" as const
+      ),
+      deadline,
+    ])
+    if (outcome === "late") await queryClient.cancelQueries({ queryKey })
+  } finally {
+    clearTimeout(timer)
+  }
+}

package/examples/canister-studio/src/components/canister/shared-link-loader.test.ts

@@ -0,0 +1,116 @@
+// @vitest-environment node
+// The method page's loader for links that ask to run a method
+// (`?method=…&args=<hex>&run=true`): shared links, quick reads and history
+// replays. It reads at once only what the runner reads at once, and nothing
+// it is given can fail the page.
+import { createTestClient } from "@ic-reactor/core/testing"
+import { afterEach, describe, expect, it } from "vitest"
+import { compileInterface } from "../../interface/compile.ts"
+import { serverCli } from "../../interface/compile.server.ts"
+import { interfaceFromPayload } from "../../interface/load.ts"
+import type { InterfacePayload } from "../../interface/types.ts"
+import { sha256Hex } from "../../lib/hex.ts"
+import { Route } from "../../routes/canister.$canisterId.index.tsx"
+
+const ID = "qoctq-giaaa-aaaaa-aaaea-cai"
+const DID = `service : {
+  ping : () -> () query;
+  greet : (text) -> (text) query;
+  peers : () -> (vec text) composite_query;
+  bump : () -> (nat);
+}`
+// DIDL, an empty type table and no values: the arguments of `ping`.
+const NO_ARGS = "4449444c0000"
+// "DIDL", the type `text`, and the value "bob".
+const GREET_BOB = "4449444c00017103626f62"
+
+type Payload = Extract<InterfacePayload, { ok: true }>
+
+async function payloadOf(did: string): Promise<Payload> {
+  const compiled = await compileInterface(serverCli, did)
+  if (!compiled.ok) throw new Error(`does not compile: ${compiled.message}`)
+  return {
+    ok: true,
+    canisterId: ID,
+    source: { kind: "metadata", certified: true, moduleHash: null },
+    did,
+    didSha256: await sha256Hex(new TextEncoder().encode(did)),
+    envelopeJson: compiled.envelopeJson,
+    docs: {},
+    fetchedAt: 0,
+    cache: "miss",
+  }
+}
+
+type Loader = (ctx: unknown) => Promise<unknown>
+const loader = (Route.options as unknown as { loader: Loader }).loader
+
+let test: ReturnType<typeof createTestClient> | undefined
+afterEach(() => {
+  test?.client.dispose()
+  test = undefined
+})
+
+async function open(deps: {
+  method: string
+  args: string
+  certified?: boolean
+}): Promise<{ result: unknown; methods: string[] }> {
+  const payload = await payloadOf(DID)
+  const iface = interfaceFromPayload(payload)
+  test = createTestClient({ network: "ic", signedIn: false })
+  test.mock<Record<string, (...args: never[]) => Promise<unknown>>>(
+    iface.actor,
+    ID,
+    {
+      ping: () => undefined,
+      greet: (name: string) => `hello ${name}`,
+      peers: () => [],
+      bump: () => 1n,
+    } as never
+  )
+  const { client } = test
+  const result = await loader({
+    context: { reactor: client, queryClient: client.queryClient },
+    params: { canisterId: ID },
+    deps: { run: true, certified: false, ...deps },
+    parentMatchPromise: Promise.resolve({ loaderData: { payload } }),
+  })
+  const methods = test.requests.flatMap((r) =>
+    r.endpoint === "query" || r.endpoint === "call" ? [r.methodName ?? ""] : []
+  )
+  return { result, methods }
+}
+
+describe("the method page's loader, for a link with run=true", () => {
+  it("opens a query without results without failing the page or calling it", async () => {
+    // What a history Replay of `ping` (run as a call, kept as a query) links to.
+    const { result, methods } = await open({ method: "ping", args: NO_ARGS })
+    expect(result).toBeUndefined()
+    expect(methods).toEqual([])
+  })
+
+  it("never sends an update from a link", async () => {
+    const { methods } = await open({ method: "bump", args: NO_ARGS })
+    expect(methods).toEqual([])
+  })
+
+  it("never reads a composite query certified", async () => {
+    const { methods } = await open({
+      method: "peers",
+      args: NO_ARGS,
+      certified: true,
+    })
+    expect(methods).toEqual([])
+  })
+
+  it("reads a query with results, under the key the runner asks for", async () => {
+    const { methods } = await open({ method: "greet", args: GREET_BOB })
+    expect(methods).toEqual(["greet"])
+    const cached = test?.client.queryClient
+      .getQueryCache()
+      .getAll()
+      .map((q) => q.state.data)
+    expect(cached).toEqual(["hello bob"])
+  })
+})

package/examples/canister-studio/src/components/canister/use-canister-page.ts

@@ -0,0 +1,44 @@
+import { getRouteApi } from "@tanstack/react-router"
+import type { TokenUnits } from "../../lib/format.ts"
+import type { RegistryEntry } from "../../lib/registry.ts"
+import { useCanisterInterface } from "../../interface/load.ts"
+import type {
+  CanisterInterface,
+  InterfacePayload,
+} from "../../interface/types.ts"
+
+const canisterRoute = getRouteApi("/canister/$canisterId")
+
+/**
+ * The canister layout's interface, for its child pages: the payload its
+ * loader returned and the interface rebuilt from it (the same object as the
+ * layout's, memoized by the interface's hash).
+ */
+export function useCanisterPage(): {
+  canisterId: string
+  payload: InterfacePayload
+  iface: CanisterInterface | undefined
+} {
+  const { canisterId } = canisterRoute.useParams()
+  const { payload } = canisterRoute.useLoaderData()
+  const iface = useCanisterInterface(payload)
+  return { canisterId, payload, iface }
+}
+
+// Bitcoin amounts on the ckBTC minter are satoshis.
+const MINTER_UNITS: TokenUnits = { decimals: 8, symbol: "BTC" }
+
+/**
+ * How amounts read on a typed canister: the ledger's token, or bitcoin on
+ * the minter. `undefined` for any other canister (its amounts stay raw).
+ */
+export function registryUnits(
+  entry: RegistryEntry | undefined
+): TokenUnits | undefined {
+  if (entry === undefined) return undefined
+  if (entry.kind === "ckbtc-minter") return MINTER_UNITS
+  if (entry.decimals === undefined || entry.symbol === undefined) {
+    return undefined
+  }
+  return { decimals: entry.decimals, symbol: entry.symbol }
+}

package/examples/canister-studio/src/components/canister/workspace-key.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it } from "vitest"
+import { pickMountsWorkspace } from "./workspace-key.ts"
+
+describe("pickMountsWorkspace", () => {
+  it("is false for the method already open, which nothing remounts to take the flag", () => {
+    expect(
+      pickMountsWorkspace(
+        { method: "get_neuron_info", certified: true },
+        { method: "get_neuron_info", certified: true }
+      )
+    ).toBe(false)
+  })
+
+  it("is true for another method, the overview's quick reads, or the open method from a link", () => {
+    expect(pickMountsWorkspace({ method: "a" }, { method: "b" })).toBe(true)
+    expect(
+      pickMountsWorkspace({}, { method: "icrc1_fee", args: "4449444c0000" })
+    ).toBe(true)
+    // A shared link's arguments are dropped by the list's link: a new runner.
+    expect(
+      pickMountsWorkspace(
+        { method: "a", args: "4449444c0000" },
+        { method: "a" }
+      )
+    ).toBe(true)
+  })
+})