@metamask-previews/wallet-cli 0.0.0-preview-2dc3d26a4 → 0.0.0-preview-aa202ec10

package/dist/daemon/prompts.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.promptPassword = exports.confirmPurge = void 0;
+exports.promptPassword = exports.confirmSend = exports.confirmPurge = void 0;
 /**
  * Ask the user to confirm the destructive `daemon purge` operation.
  *
@@ -18,6 +18,24 @@ async function confirmPurge() {
     });
 }
 exports.confirmPurge = confirmPurge;
+/**
+ * Ask the user to confirm broadcasting a transaction. Used by `mm wallet send`
+ * when neither `--yes` nor `--dry-run` was passed. Same dynamic-import +
+ * ESM-interop pattern as {@link confirmPurge}. Defaults to `false` so an
+ * accidental bare Enter never broadcasts.
+ *
+ * @param summary - A human-readable description of the transaction to send
+ * (recipient, amount, network), shown above the prompt.
+ * @returns True if the user confirmed.
+ */
+async function confirmSend(summary) {
+    const { default: confirm } = await import("@inquirer/confirm");
+    return confirm({
+        message: `${summary}\nBroadcast this transaction?`,
+        default: false,
+    });
+}
+exports.confirmSend = confirmSend;
 /**
  * Prompt the user for the wallet password, with input masked. Used by
  * `mm wallet unlock` when the user did not pass `--password` or set the

package/dist/daemon/prompts.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"prompts.cjs","sourceRoot":"","sources":["../../src/daemon/prompts.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;GAQG;AACI,KAAK,UAAU,YAAY;IAChC,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,MAAM,MAAM,qBAAqB,CAAC;IAC/D,OAAO,OAAO,CAAC;QACb,OAAO,EAAE,2DAA2D;QACpE,OAAO,EAAE,KAAK;KACf,CAAC,CAAC;AACL,CAAC;AAND,oCAMC;AAED;;;;;;;GAOG;AACI,KAAK,UAAU,cAAc;IAClC,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,MAAM,MAAM,sBAAsB,CAAC;IACjE,OAAO,QAAQ,CAAC;QACd,OAAO,EAAE,kBAAkB;QAC3B,IAAI,EAAE,IAAI;KACX,CAAC,CAAC;AACL,CAAC;AAND,wCAMC","sourcesContent":["/**\n * Ask the user to confirm the destructive `daemon purge` operation.\n *\n * Wraps `@inquirer/confirm` in a dynamic import so this CommonJS-compiled\n * package can interop with that ESM-only dependency, and so tests can mock\n * the prompt without going through jest's ESM mock machinery.\n *\n * @returns True if the user confirmed.\n */\nexport async function confirmPurge(): Promise<boolean> {\n  const { default: confirm } = await import('@inquirer/confirm');\n  return confirm({\n    message: 'This will stop the daemon and delete all state. Continue?',\n    default: false,\n  });\n}\n\n/**\n * Prompt the user for the wallet password, with input masked. Used by\n * `mm wallet unlock` when the user did not pass `--password` or set the\n * `MM_WALLET_PASSWORD` env var. Same dynamic-import + ESM-interop pattern\n * as {@link confirmPurge}.\n *\n * @returns The password the user typed.\n */\nexport async function promptPassword(): Promise<string> {\n  const { default: password } = await import('@inquirer/password');\n  return password({\n    message: 'Wallet password:',\n    mask: true,\n  });\n}\n"]}
+{"version":3,"file":"prompts.cjs","sourceRoot":"","sources":["../../src/daemon/prompts.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;GAQG;AACI,KAAK,UAAU,YAAY;IAChC,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,MAAM,MAAM,qBAAqB,CAAC;IAC/D,OAAO,OAAO,CAAC;QACb,OAAO,EAAE,2DAA2D;QACpE,OAAO,EAAE,KAAK;KACf,CAAC,CAAC;AACL,CAAC;AAND,oCAMC;AAED;;;;;;;;;GASG;AACI,KAAK,UAAU,WAAW,CAAC,OAAe;IAC/C,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,MAAM,MAAM,qBAAqB,CAAC;IAC/D,OAAO,OAAO,CAAC;QACb,OAAO,EAAE,GAAG,OAAO,+BAA+B;QAClD,OAAO,EAAE,KAAK;KACf,CAAC,CAAC;AACL,CAAC;AAND,kCAMC;AAED;;;;;;;GAOG;AACI,KAAK,UAAU,cAAc;IAClC,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,MAAM,MAAM,sBAAsB,CAAC;IACjE,OAAO,QAAQ,CAAC;QACd,OAAO,EAAE,kBAAkB;QAC3B,IAAI,EAAE,IAAI;KACX,CAAC,CAAC;AACL,CAAC;AAND,wCAMC","sourcesContent":["/**\n * Ask the user to confirm the destructive `daemon purge` operation.\n *\n * Wraps `@inquirer/confirm` in a dynamic import so this CommonJS-compiled\n * package can interop with that ESM-only dependency, and so tests can mock\n * the prompt without going through jest's ESM mock machinery.\n *\n * @returns True if the user confirmed.\n */\nexport async function confirmPurge(): Promise<boolean> {\n  const { default: confirm } = await import('@inquirer/confirm');\n  return confirm({\n    message: 'This will stop the daemon and delete all state. Continue?',\n    default: false,\n  });\n}\n\n/**\n * Ask the user to confirm broadcasting a transaction. Used by `mm wallet send`\n * when neither `--yes` nor `--dry-run` was passed. Same dynamic-import +\n * ESM-interop pattern as {@link confirmPurge}. Defaults to `false` so an\n * accidental bare Enter never broadcasts.\n *\n * @param summary - A human-readable description of the transaction to send\n * (recipient, amount, network), shown above the prompt.\n * @returns True if the user confirmed.\n */\nexport async function confirmSend(summary: string): Promise<boolean> {\n  const { default: confirm } = await import('@inquirer/confirm');\n  return confirm({\n    message: `${summary}\\nBroadcast this transaction?`,\n    default: false,\n  });\n}\n\n/**\n * Prompt the user for the wallet password, with input masked. Used by\n * `mm wallet unlock` when the user did not pass `--password` or set the\n * `MM_WALLET_PASSWORD` env var. Same dynamic-import + ESM-interop pattern\n * as {@link confirmPurge}.\n *\n * @returns The password the user typed.\n */\nexport async function promptPassword(): Promise<string> {\n  const { default: password } = await import('@inquirer/password');\n  return password({\n    message: 'Wallet password:',\n    mask: true,\n  });\n}\n"]}

package/dist/daemon/prompts.d.cts

@@ -8,6 +8,17 @@
  * @returns True if the user confirmed.
  */
 export declare function confirmPurge(): Promise<boolean>;
+/**
+ * Ask the user to confirm broadcasting a transaction. Used by `mm wallet send`
+ * when neither `--yes` nor `--dry-run` was passed. Same dynamic-import +
+ * ESM-interop pattern as {@link confirmPurge}. Defaults to `false` so an
+ * accidental bare Enter never broadcasts.
+ *
+ * @param summary - A human-readable description of the transaction to send
+ * (recipient, amount, network), shown above the prompt.
+ * @returns True if the user confirmed.
+ */
+export declare function confirmSend(summary: string): Promise<boolean>;
 /**
  * Prompt the user for the wallet password, with input masked. Used by
  * `mm wallet unlock` when the user did not pass `--password` or set the

package/dist/daemon/prompts.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"prompts.d.cts","sourceRoot":"","sources":["../../src/daemon/prompts.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,wBAAsB,YAAY,IAAI,OAAO,CAAC,OAAO,CAAC,CAMrD;AAED;;;;;;;GAOG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC,CAMtD"}
+{"version":3,"file":"prompts.d.cts","sourceRoot":"","sources":["../../src/daemon/prompts.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,wBAAsB,YAAY,IAAI,OAAO,CAAC,OAAO,CAAC,CAMrD;AAED;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAMnE;AAED;;;;;;;GAOG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC,CAMtD"}

package/dist/daemon/prompts.d.mts

@@ -8,6 +8,17 @@
  * @returns True if the user confirmed.
  */
 export declare function confirmPurge(): Promise<boolean>;
+/**
+ * Ask the user to confirm broadcasting a transaction. Used by `mm wallet send`
+ * when neither `--yes` nor `--dry-run` was passed. Same dynamic-import +
+ * ESM-interop pattern as {@link confirmPurge}. Defaults to `false` so an
+ * accidental bare Enter never broadcasts.
+ *
+ * @param summary - A human-readable description of the transaction to send
+ * (recipient, amount, network), shown above the prompt.
+ * @returns True if the user confirmed.
+ */
+export declare function confirmSend(summary: string): Promise<boolean>;
 /**
  * Prompt the user for the wallet password, with input masked. Used by
  * `mm wallet unlock` when the user did not pass `--password` or set the

package/dist/daemon/prompts.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"prompts.d.mts","sourceRoot":"","sources":["../../src/daemon/prompts.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,wBAAsB,YAAY,IAAI,OAAO,CAAC,OAAO,CAAC,CAMrD;AAED;;;;;;;GAOG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC,CAMtD"}
+{"version":3,"file":"prompts.d.mts","sourceRoot":"","sources":["../../src/daemon/prompts.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,wBAAsB,YAAY,IAAI,OAAO,CAAC,OAAO,CAAC,CAMrD;AAED;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAMnE;AAED;;;;;;;GAOG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC,CAMtD"}

package/dist/daemon/prompts.mjs

@@ -14,6 +14,23 @@ export async function confirmPurge() {
         default: false,
     });
 }
+/**
+ * Ask the user to confirm broadcasting a transaction. Used by `mm wallet send`
+ * when neither `--yes` nor `--dry-run` was passed. Same dynamic-import +
+ * ESM-interop pattern as {@link confirmPurge}. Defaults to `false` so an
+ * accidental bare Enter never broadcasts.
+ *
+ * @param summary - A human-readable description of the transaction to send
+ * (recipient, amount, network), shown above the prompt.
+ * @returns True if the user confirmed.
+ */
+export async function confirmSend(summary) {
+    const { default: confirm } = await import("@inquirer/confirm");
+    return confirm({
+        message: `${summary}\nBroadcast this transaction?`,
+        default: false,
+    });
+}
 /**
  * Prompt the user for the wallet password, with input masked. Used by
  * `mm wallet unlock` when the user did not pass `--password` or set the

package/dist/daemon/prompts.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"prompts.mjs","sourceRoot":"","sources":["../../src/daemon/prompts.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY;IAChC,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,MAAM,MAAM,qBAAqB,CAAC;IAC/D,OAAO,OAAO,CAAC;QACb,OAAO,EAAE,2DAA2D;QACpE,OAAO,EAAE,KAAK;KACf,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc;IAClC,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,MAAM,MAAM,sBAAsB,CAAC;IACjE,OAAO,QAAQ,CAAC;QACd,OAAO,EAAE,kBAAkB;QAC3B,IAAI,EAAE,IAAI;KACX,CAAC,CAAC;AACL,CAAC","sourcesContent":["/**\n * Ask the user to confirm the destructive `daemon purge` operation.\n *\n * Wraps `@inquirer/confirm` in a dynamic import so this CommonJS-compiled\n * package can interop with that ESM-only dependency, and so tests can mock\n * the prompt without going through jest's ESM mock machinery.\n *\n * @returns True if the user confirmed.\n */\nexport async function confirmPurge(): Promise<boolean> {\n  const { default: confirm } = await import('@inquirer/confirm');\n  return confirm({\n    message: 'This will stop the daemon and delete all state. Continue?',\n    default: false,\n  });\n}\n\n/**\n * Prompt the user for the wallet password, with input masked. Used by\n * `mm wallet unlock` when the user did not pass `--password` or set the\n * `MM_WALLET_PASSWORD` env var. Same dynamic-import + ESM-interop pattern\n * as {@link confirmPurge}.\n *\n * @returns The password the user typed.\n */\nexport async function promptPassword(): Promise<string> {\n  const { default: password } = await import('@inquirer/password');\n  return password({\n    message: 'Wallet password:',\n    mask: true,\n  });\n}\n"]}
+{"version":3,"file":"prompts.mjs","sourceRoot":"","sources":["../../src/daemon/prompts.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY;IAChC,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,MAAM,MAAM,qBAAqB,CAAC;IAC/D,OAAO,OAAO,CAAC;QACb,OAAO,EAAE,2DAA2D;QACpE,OAAO,EAAE,KAAK;KACf,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAAC,OAAe;IAC/C,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,MAAM,MAAM,qBAAqB,CAAC;IAC/D,OAAO,OAAO,CAAC;QACb,OAAO,EAAE,GAAG,OAAO,+BAA+B;QAClD,OAAO,EAAE,KAAK;KACf,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc;IAClC,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,MAAM,MAAM,sBAAsB,CAAC;IACjE,OAAO,QAAQ,CAAC;QACd,OAAO,EAAE,kBAAkB;QAC3B,IAAI,EAAE,IAAI;KACX,CAAC,CAAC;AACL,CAAC","sourcesContent":["/**\n * Ask the user to confirm the destructive `daemon purge` operation.\n *\n * Wraps `@inquirer/confirm` in a dynamic import so this CommonJS-compiled\n * package can interop with that ESM-only dependency, and so tests can mock\n * the prompt without going through jest's ESM mock machinery.\n *\n * @returns True if the user confirmed.\n */\nexport async function confirmPurge(): Promise<boolean> {\n  const { default: confirm } = await import('@inquirer/confirm');\n  return confirm({\n    message: 'This will stop the daemon and delete all state. Continue?',\n    default: false,\n  });\n}\n\n/**\n * Ask the user to confirm broadcasting a transaction. Used by `mm wallet send`\n * when neither `--yes` nor `--dry-run` was passed. Same dynamic-import +\n * ESM-interop pattern as {@link confirmPurge}. Defaults to `false` so an\n * accidental bare Enter never broadcasts.\n *\n * @param summary - A human-readable description of the transaction to send\n * (recipient, amount, network), shown above the prompt.\n * @returns True if the user confirmed.\n */\nexport async function confirmSend(summary: string): Promise<boolean> {\n  const { default: confirm } = await import('@inquirer/confirm');\n  return confirm({\n    message: `${summary}\\nBroadcast this transaction?`,\n    default: false,\n  });\n}\n\n/**\n * Prompt the user for the wallet password, with input masked. Used by\n * `mm wallet unlock` when the user did not pass `--password` or set the\n * `MM_WALLET_PASSWORD` env var. Same dynamic-import + ESM-interop pattern\n * as {@link confirmPurge}.\n *\n * @returns The password the user typed.\n */\nexport async function promptPassword(): Promise<string> {\n  const { default: password } = await import('@inquirer/password');\n  return password({\n    message: 'Wallet password:',\n    mask: true,\n  });\n}\n"]}

package/dist/daemon/send-transaction.cjs

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSendTransaction = exports.SendTransactionBroadcastResultStruct = exports.SendTransactionDryRunResultStruct = exports.SendTransactionParamsStruct = void 0;
+const superstruct_1 = require("@metamask/superstruct");
+const utils_1 = require("@metamask/utils");
+/**
+ * Origin recorded on daemon-initiated transactions. Mirrors
+ * `ORIGIN_METAMASK` from `@metamask/controller-utils` (a single string
+ * constant, inlined here to avoid pulling that whole package in as a
+ * dependency for one value).
+ */
+const INTERNAL_ORIGIN = 'metamask';
+/**
+ * Struct for a `0x`-prefixed 20-byte hex address. `isValidHexAddress` accepts
+ * an all-lowercase address or a valid EIP-55 checksummed one, so a plain
+ * lowercase paste works while a mistyped mixed-case address is rejected.
+ */
+const AddressStruct = (0, superstruct_1.define)('Address', (value) => typeof value === 'string' && (0, utils_1.isValidHexAddress)(value)
+    ? true
+    : 'Expected a 0x-prefixed 20-byte hex address');
+/**
+ * Params struct for the `sendTransaction` RPC method.
+ *
+ * The transaction fields (`to`, `value`, `data`, gas overrides) are canonical
+ * `0x`-prefixed hex — any unit conversion (e.g. ether → wei) is the CLI
+ * command's job, so the daemon boundary stays unambiguous. Exactly one of
+ * `networkClientId` / `chainId` selects the network client; the refinement
+ * below rejects supplying both or neither. `dryRun` short-circuits before
+ * broadcast (see {@link runSendTransaction}).
+ */
+exports.SendTransactionParamsStruct = (0, superstruct_1.refine)((0, superstruct_1.object)({
+    to: AddressStruct,
+    from: (0, superstruct_1.optional)(AddressStruct),
+    value: (0, superstruct_1.optional)(utils_1.StrictHexStruct),
+    data: (0, superstruct_1.optional)(utils_1.StrictHexStruct),
+    gas: (0, superstruct_1.optional)(utils_1.StrictHexStruct),
+    maxFeePerGas: (0, superstruct_1.optional)(utils_1.StrictHexStruct),
+    maxPriorityFeePerGas: (0, superstruct_1.optional)(utils_1.StrictHexStruct),
+    gasPrice: (0, superstruct_1.optional)(utils_1.StrictHexStruct),
+    networkClientId: (0, superstruct_1.optional)((0, superstruct_1.nonempty)((0, superstruct_1.string)())),
+    chainId: (0, superstruct_1.optional)(utils_1.StrictHexStruct),
+    dryRun: (0, superstruct_1.optional)((0, superstruct_1.boolean)()),
+}), 'SendTransactionParams', (value) => {
+    if ((value.networkClientId === undefined) ===
+        (value.chainId === undefined)) {
+        return 'Exactly one of `networkClientId` or `chainId` must be provided';
+    }
+    // `gasPrice` (legacy) and the EIP-1559 fields are mutually exclusive:
+    // `TransactionController` rejects the combination at broadcast, so reject
+    // it here at the boundary instead — otherwise a dry-run and the
+    // confirmation preview would show a plan that always fails at send.
+    if (value.gasPrice !== undefined &&
+        (value.maxFeePerGas !== undefined ||
+            value.maxPriorityFeePerGas !== undefined)) {
+        return '`gasPrice` cannot be combined with `maxFeePerGas` or `maxPriorityFeePerGas`';
+    }
+    return true;
+});
+/**
+ * The resolved plan a `dryRun` returns: the network client and sender the
+ * daemon would use, without adding or broadcasting anything. Exported as a
+ * struct so the CLI can validate the payload it reads back over JSON-RPC
+ * (which erases types on the wire) rather than trusting its shape.
+ */
+exports.SendTransactionDryRunResultStruct = (0, superstruct_1.object)({
+    dryRun: (0, superstruct_1.literal)(true),
+    from: utils_1.StrictHexStruct,
+    to: utils_1.StrictHexStruct,
+    value: utils_1.StrictHexStruct,
+    networkClientId: (0, superstruct_1.string)(),
+});
+/**
+ * The outcome of a broadcast send: the on-chain hash plus the id/status the
+ * daemon tracks the transaction under. Exported as a struct for the same
+ * client-side validation reason as {@link SendTransactionDryRunResultStruct}.
+ */
+exports.SendTransactionBroadcastResultStruct = (0, superstruct_1.object)({
+    transactionHash: (0, superstruct_1.string)(),
+    transactionId: (0, superstruct_1.string)(),
+    status: (0, superstruct_1.string)(),
+});
+/**
+ * Add and broadcast a transaction through the daemon-hosted
+ * `TransactionController`, returning a serializable result.
+ *
+ * `TransactionController:addTransaction` returns `{ transactionMeta, result }`
+ * where `result` is a `Promise<hash>` that resolves once the transaction is
+ * signed and broadcast. That promise is not JSON-serializable, so it cannot
+ * travel back over the daemon's JSON-RPC socket via the generic `call`
+ * dispatch — hence this dedicated handler, which awaits the broadcast
+ * server-side and returns only the resolved hash (and id/status).
+ *
+ * The network client is resolved from `chainId` (via `NetworkController`) when
+ * `networkClientId` is not given directly, and `from` defaults to the selected
+ * account. The transaction is submitted as `isInternal` (the daemon is driven
+ * only by its owner over the `0600` same-user socket), which skips
+ * origin/permitted-account validation; its approval request is auto-accepted
+ * by the daemon's auto-approval subscription.
+ *
+ * When `dryRun` is set, the network client and sender are resolved and the
+ * params validated, but nothing is added or broadcast — the resolved plan is
+ * returned so the CLI can preview it before the user confirms.
+ *
+ * @param messenger - The wallet root messenger.
+ * @param params - Validated `sendTransaction` params.
+ * @returns The dry-run plan, or the broadcast hash with its id and status.
+ */
+async function runSendTransaction(messenger, params) {
+    const { to, value = '0x0', data, gas, maxFeePerGas, maxPriorityFeePerGas, gasPrice, networkClientId: networkClientIdParam, chainId, dryRun, } = params;
+    // The struct guarantees exactly one of `networkClientId` / `chainId`, so
+    // `chainId` is defined whenever `networkClientId` is not.
+    const networkClientId = networkClientIdParam ??
+        messenger.call('NetworkController:findNetworkClientIdByChainId', chainId);
+    const from = params.from ??
+        messenger.call('AccountsController:getSelectedAccount').address;
+    if (dryRun) {
+        return { dryRun: true, from, to, value, networkClientId };
+    }
+    const txParams = {
+        from,
+        to,
+        value,
+        ...(data === undefined ? {} : { data }),
+        ...(gas === undefined ? {} : { gas }),
+        ...(maxFeePerGas === undefined ? {} : { maxFeePerGas }),
+        ...(maxPriorityFeePerGas === undefined ? {} : { maxPriorityFeePerGas }),
+        ...(gasPrice === undefined ? {} : { gasPrice }),
+    };
+    const { result, transactionMeta } = await messenger.call('TransactionController:addTransaction', txParams, { networkClientId, origin: INTERNAL_ORIGIN, isInternal: true });
+    // `result` resolves only once the transaction is signed and broadcast (see
+    // the function JSDoc); awaiting it here is what this handler exists for.
+    const transactionHash = await result;
+    // Re-read the live record for the current status: `transactionMeta` is the
+    // creation snapshot (still `unapproved`). If the record is already gone,
+    // fall back to `submitted` — reaching this point means `result` resolved, so
+    // the transaction was broadcast, never merely `unapproved`.
+    const [current] = messenger.call('TransactionController:getTransactions', {
+        searchCriteria: { id: transactionMeta.id },
+    });
+    return {
+        transactionHash,
+        transactionId: transactionMeta.id,
+        status: current?.status ?? 'submitted',
+    };
+}
+exports.runSendTransaction = runSendTransaction;
+//# sourceMappingURL=send-transaction.cjs.map

package/dist/daemon/send-transaction.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"send-transaction.cjs","sourceRoot":"","sources":["../../src/daemon/send-transaction.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  boolean,\n  define,\n  literal,\n  nonempty,\n  object,\n  optional,\n  refine,\n  string,\n} from '@metamask/superstruct';\nimport type { Infer } from '@metamask/superstruct';\nimport { isValidHexAddress, StrictHexStruct } from '@metamask/utils';\nimport type { Hex } from '@metamask/utils';\nimport type {\n  DefaultActions,\n  DefaultEvents,\n  RootMessenger,\n} from '@metamask/wallet';\n\n/**\n * Origin recorded on daemon-initiated transactions. Mirrors\n * `ORIGIN_METAMASK` from `@metamask/controller-utils` (a single string\n * constant, inlined here to avoid pulling that whole package in as a\n * dependency for one value).\n */\nconst INTERNAL_ORIGIN = 'metamask';\n\n/**\n * Struct for a `0x`-prefixed 20-byte hex address. `isValidHexAddress` accepts\n * an all-lowercase address or a valid EIP-55 checksummed one, so a plain\n * lowercase paste works while a mistyped mixed-case address is rejected.\n */\nconst AddressStruct = define<Hex>('Address', (value) =>\n  typeof value === 'string' && isValidHexAddress(value as Hex)\n    ? true\n    : 'Expected a 0x-prefixed 20-byte hex address',\n);\n\n/**\n * Params struct for the `sendTransaction` RPC method.\n *\n * The transaction fields (`to`, `value`, `data`, gas overrides) are canonical\n * `0x`-prefixed hex — any unit conversion (e.g. ether → wei) is the CLI\n * command's job, so the daemon boundary stays unambiguous. Exactly one of\n * `networkClientId` / `chainId` selects the network client; the refinement\n * below rejects supplying both or neither. `dryRun` short-circuits before\n * broadcast (see {@link runSendTransaction}).\n */\nexport const SendTransactionParamsStruct = refine(\n  object({\n    to: AddressStruct,\n    from: optional(AddressStruct),\n    value: optional(StrictHexStruct),\n    data: optional(StrictHexStruct),\n    gas: optional(StrictHexStruct),\n    maxFeePerGas: optional(StrictHexStruct),\n    maxPriorityFeePerGas: optional(StrictHexStruct),\n    gasPrice: optional(StrictHexStruct),\n    networkClientId: optional(nonempty(string())),\n    chainId: optional(StrictHexStruct),\n    dryRun: optional(boolean()),\n  }),\n  'SendTransactionParams',\n  (value) => {\n    if (\n      (value.networkClientId === undefined) ===\n      (value.chainId === undefined)\n    ) {\n      return 'Exactly one of `networkClientId` or `chainId` must be provided';\n    }\n    // `gasPrice` (legacy) and the EIP-1559 fields are mutually exclusive:\n    // `TransactionController` rejects the combination at broadcast, so reject\n    // it here at the boundary instead — otherwise a dry-run and the\n    // confirmation preview would show a plan that always fails at send.\n    if (\n      value.gasPrice !== undefined &&\n      (value.maxFeePerGas !== undefined ||\n        value.maxPriorityFeePerGas !== undefined)\n    ) {\n      return '`gasPrice` cannot be combined with `maxFeePerGas` or `maxPriorityFeePerGas`';\n    }\n    return true;\n  },\n);\n\nexport type SendTransactionParams = Infer<typeof SendTransactionParamsStruct>;\n\n/**\n * The resolved plan a `dryRun` returns: the network client and sender the\n * daemon would use, without adding or broadcasting anything. Exported as a\n * struct so the CLI can validate the payload it reads back over JSON-RPC\n * (which erases types on the wire) rather than trusting its shape.\n */\nexport const SendTransactionDryRunResultStruct = object({\n  dryRun: literal(true),\n  from: StrictHexStruct,\n  to: StrictHexStruct,\n  value: StrictHexStruct,\n  networkClientId: string(),\n});\n\n/**\n * The outcome of a broadcast send: the on-chain hash plus the id/status the\n * daemon tracks the transaction under. Exported as a struct for the same\n * client-side validation reason as {@link SendTransactionDryRunResultStruct}.\n */\nexport const SendTransactionBroadcastResultStruct = object({\n  transactionHash: string(),\n  transactionId: string(),\n  status: string(),\n});\n\nexport type SendTransactionDryRunResult = Infer<\n  typeof SendTransactionDryRunResultStruct\n>;\n\nexport type SendTransactionBroadcastResult = Infer<\n  typeof SendTransactionBroadcastResultStruct\n>;\n\nexport type SendTransactionResult =\n  | SendTransactionDryRunResult\n  | SendTransactionBroadcastResult;\n\n/**\n * Add and broadcast a transaction through the daemon-hosted\n * `TransactionController`, returning a serializable result.\n *\n * `TransactionController:addTransaction` returns `{ transactionMeta, result }`\n * where `result` is a `Promise<hash>` that resolves once the transaction is\n * signed and broadcast. That promise is not JSON-serializable, so it cannot\n * travel back over the daemon's JSON-RPC socket via the generic `call`\n * dispatch — hence this dedicated handler, which awaits the broadcast\n * server-side and returns only the resolved hash (and id/status).\n *\n * The network client is resolved from `chainId` (via `NetworkController`) when\n * `networkClientId` is not given directly, and `from` defaults to the selected\n * account. The transaction is submitted as `isInternal` (the daemon is driven\n * only by its owner over the `0600` same-user socket), which skips\n * origin/permitted-account validation; its approval request is auto-accepted\n * by the daemon's auto-approval subscription.\n *\n * When `dryRun` is set, the network client and sender are resolved and the\n * params validated, but nothing is added or broadcast — the resolved plan is\n * returned so the CLI can preview it before the user confirms.\n *\n * @param messenger - The wallet root messenger.\n * @param params - Validated `sendTransaction` params.\n * @returns The dry-run plan, or the broadcast hash with its id and status.\n */\nexport async function runSendTransaction(\n  messenger: Readonly<RootMessenger<DefaultActions, DefaultEvents>>,\n  params: SendTransactionParams,\n): Promise<SendTransactionResult> {\n  const {\n    to,\n    value = '0x0',\n    data,\n    gas,\n    maxFeePerGas,\n    maxPriorityFeePerGas,\n    gasPrice,\n    networkClientId: networkClientIdParam,\n    chainId,\n    dryRun,\n  } = params;\n\n  // The struct guarantees exactly one of `networkClientId` / `chainId`, so\n  // `chainId` is defined whenever `networkClientId` is not.\n  const networkClientId =\n    networkClientIdParam ??\n    messenger.call(\n      'NetworkController:findNetworkClientIdByChainId',\n      chainId as Hex,\n    );\n\n  const from =\n    params.from ??\n    (messenger.call('AccountsController:getSelectedAccount').address as Hex);\n\n  if (dryRun) {\n    return { dryRun: true, from, to, value, networkClientId };\n  }\n\n  const txParams = {\n    from,\n    to,\n    value,\n    ...(data === undefined ? {} : { data }),\n    ...(gas === undefined ? {} : { gas }),\n    ...(maxFeePerGas === undefined ? {} : { maxFeePerGas }),\n    ...(maxPriorityFeePerGas === undefined ? {} : { maxPriorityFeePerGas }),\n    ...(gasPrice === undefined ? {} : { gasPrice }),\n  };\n\n  const { result, transactionMeta } = await messenger.call(\n    'TransactionController:addTransaction',\n    txParams,\n    { networkClientId, origin: INTERNAL_ORIGIN, isInternal: true },\n  );\n\n  // `result` resolves only once the transaction is signed and broadcast (see\n  // the function JSDoc); awaiting it here is what this handler exists for.\n  const transactionHash = await result;\n\n  // Re-read the live record for the current status: `transactionMeta` is the\n  // creation snapshot (still `unapproved`). If the record is already gone,\n  // fall back to `submitted` — reaching this point means `result` resolved, so\n  // the transaction was broadcast, never merely `unapproved`.\n  const [current] = messenger.call('TransactionController:getTransactions', {\n    searchCriteria: { id: transactionMeta.id },\n  });\n\n  return {\n    transactionHash,\n    transactionId: transactionMeta.id,\n    status: current?.status ?? 'submitted',\n  };\n}\n"]}

package/dist/daemon/send-transaction.d.cts

@@ -0,0 +1,102 @@
+import type { Infer } from "@metamask/superstruct";
+import type { DefaultActions, DefaultEvents, RootMessenger } from "@metamask/wallet";
+/**
+ * Params struct for the `sendTransaction` RPC method.
+ *
+ * The transaction fields (`to`, `value`, `data`, gas overrides) are canonical
+ * `0x`-prefixed hex — any unit conversion (e.g. ether → wei) is the CLI
+ * command's job, so the daemon boundary stays unambiguous. Exactly one of
+ * `networkClientId` / `chainId` selects the network client; the refinement
+ * below rejects supplying both or neither. `dryRun` short-circuits before
+ * broadcast (see {@link runSendTransaction}).
+ */
+export declare const SendTransactionParamsStruct: import("@metamask/superstruct").Struct<{
+    to: `0x${string}`;
+    data?: `0x${string}` | undefined;
+    value?: `0x${string}` | undefined;
+    from?: `0x${string}` | undefined;
+    gas?: `0x${string}` | undefined;
+    maxFeePerGas?: `0x${string}` | undefined;
+    maxPriorityFeePerGas?: `0x${string}` | undefined;
+    gasPrice?: `0x${string}` | undefined;
+    networkClientId?: string | undefined;
+    chainId?: `0x${string}` | undefined;
+    dryRun?: boolean | undefined;
+}, {
+    to: import("@metamask/superstruct").Struct<`0x${string}`, null>;
+    from: import("@metamask/superstruct").Struct<`0x${string}` | undefined, null>;
+    value: import("@metamask/superstruct").Struct<`0x${string}` | undefined, null>;
+    data: import("@metamask/superstruct").Struct<`0x${string}` | undefined, null>;
+    gas: import("@metamask/superstruct").Struct<`0x${string}` | undefined, null>;
+    maxFeePerGas: import("@metamask/superstruct").Struct<`0x${string}` | undefined, null>;
+    maxPriorityFeePerGas: import("@metamask/superstruct").Struct<`0x${string}` | undefined, null>;
+    gasPrice: import("@metamask/superstruct").Struct<`0x${string}` | undefined, null>;
+    networkClientId: import("@metamask/superstruct").Struct<string | undefined, null>;
+    chainId: import("@metamask/superstruct").Struct<`0x${string}` | undefined, null>;
+    dryRun: import("@metamask/superstruct").Struct<boolean | undefined, null>;
+}>;
+export type SendTransactionParams = Infer<typeof SendTransactionParamsStruct>;
+/**
+ * The resolved plan a `dryRun` returns: the network client and sender the
+ * daemon would use, without adding or broadcasting anything. Exported as a
+ * struct so the CLI can validate the payload it reads back over JSON-RPC
+ * (which erases types on the wire) rather than trusting its shape.
+ */
+export declare const SendTransactionDryRunResultStruct: import("@metamask/superstruct").Struct<{
+    value: `0x${string}`;
+    to: `0x${string}`;
+    from: `0x${string}`;
+    networkClientId: string;
+    dryRun: true;
+}, {
+    dryRun: import("@metamask/superstruct").Struct<true, true>;
+    from: import("@metamask/superstruct").Struct<`0x${string}`, null>;
+    to: import("@metamask/superstruct").Struct<`0x${string}`, null>;
+    value: import("@metamask/superstruct").Struct<`0x${string}`, null>;
+    networkClientId: import("@metamask/superstruct").Struct<string, null>;
+}>;
+/**
+ * The outcome of a broadcast send: the on-chain hash plus the id/status the
+ * daemon tracks the transaction under. Exported as a struct for the same
+ * client-side validation reason as {@link SendTransactionDryRunResultStruct}.
+ */
+export declare const SendTransactionBroadcastResultStruct: import("@metamask/superstruct").Struct<{
+    status: string;
+    transactionHash: string;
+    transactionId: string;
+}, {
+    transactionHash: import("@metamask/superstruct").Struct<string, null>;
+    transactionId: import("@metamask/superstruct").Struct<string, null>;
+    status: import("@metamask/superstruct").Struct<string, null>;
+}>;
+export type SendTransactionDryRunResult = Infer<typeof SendTransactionDryRunResultStruct>;
+export type SendTransactionBroadcastResult = Infer<typeof SendTransactionBroadcastResultStruct>;
+export type SendTransactionResult = SendTransactionDryRunResult | SendTransactionBroadcastResult;
+/**
+ * Add and broadcast a transaction through the daemon-hosted
+ * `TransactionController`, returning a serializable result.
+ *
+ * `TransactionController:addTransaction` returns `{ transactionMeta, result }`
+ * where `result` is a `Promise<hash>` that resolves once the transaction is
+ * signed and broadcast. That promise is not JSON-serializable, so it cannot
+ * travel back over the daemon's JSON-RPC socket via the generic `call`
+ * dispatch — hence this dedicated handler, which awaits the broadcast
+ * server-side and returns only the resolved hash (and id/status).
+ *
+ * The network client is resolved from `chainId` (via `NetworkController`) when
+ * `networkClientId` is not given directly, and `from` defaults to the selected
+ * account. The transaction is submitted as `isInternal` (the daemon is driven
+ * only by its owner over the `0600` same-user socket), which skips
+ * origin/permitted-account validation; its approval request is auto-accepted
+ * by the daemon's auto-approval subscription.
+ *
+ * When `dryRun` is set, the network client and sender are resolved and the
+ * params validated, but nothing is added or broadcast — the resolved plan is
+ * returned so the CLI can preview it before the user confirms.
+ *
+ * @param messenger - The wallet root messenger.
+ * @param params - Validated `sendTransaction` params.
+ * @returns The dry-run plan, or the broadcast hash with its id and status.
+ */
+export declare function runSendTransaction(messenger: Readonly<RootMessenger<DefaultActions, DefaultEvents>>, params: SendTransactionParams): Promise<SendTransactionResult>;
+//# sourceMappingURL=send-transaction.d.cts.map

package/dist/daemon/send-transaction.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"send-transaction.d.cts","sourceRoot":"","sources":["../../src/daemon/send-transaction.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,KAAK,EAAE,8BAA8B;AAGnD,OAAO,KAAK,EACV,cAAc,EACd,aAAa,EACb,aAAa,EACd,yBAAyB;AAqB1B;;;;;;;;;GASG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;EAmCvC,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAE9E;;;;;GAKG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;EAM5C,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,oCAAoC;;;;;;;;EAI/C,CAAC;AAEH,MAAM,MAAM,2BAA2B,GAAG,KAAK,CAC7C,OAAO,iCAAiC,CACzC,CAAC;AAEF,MAAM,MAAM,8BAA8B,GAAG,KAAK,CAChD,OAAO,oCAAoC,CAC5C,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAC7B,2BAA2B,GAC3B,8BAA8B,CAAC;AAEnC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,kBAAkB,CACtC,SAAS,EAAE,QAAQ,CAAC,aAAa,CAAC,cAAc,EAAE,aAAa,CAAC,CAAC,EACjE,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,qBAAqB,CAAC,CAiEhC"}

package/dist/daemon/send-transaction.d.mts

@@ -0,0 +1,102 @@
+import type { Infer } from "@metamask/superstruct";
+import type { DefaultActions, DefaultEvents, RootMessenger } from "@metamask/wallet";
+/**
+ * Params struct for the `sendTransaction` RPC method.
+ *
+ * The transaction fields (`to`, `value`, `data`, gas overrides) are canonical
+ * `0x`-prefixed hex — any unit conversion (e.g. ether → wei) is the CLI
+ * command's job, so the daemon boundary stays unambiguous. Exactly one of
+ * `networkClientId` / `chainId` selects the network client; the refinement
+ * below rejects supplying both or neither. `dryRun` short-circuits before
+ * broadcast (see {@link runSendTransaction}).
+ */
+export declare const SendTransactionParamsStruct: import("@metamask/superstruct").Struct<{
+    to: `0x${string}`;
+    data?: `0x${string}` | undefined;
+    value?: `0x${string}` | undefined;
+    from?: `0x${string}` | undefined;
+    gas?: `0x${string}` | undefined;
+    maxFeePerGas?: `0x${string}` | undefined;
+    maxPriorityFeePerGas?: `0x${string}` | undefined;
+    gasPrice?: `0x${string}` | undefined;
+    networkClientId?: string | undefined;
+    chainId?: `0x${string}` | undefined;
+    dryRun?: boolean | undefined;
+}, {
+    to: import("@metamask/superstruct").Struct<`0x${string}`, null>;
+    from: import("@metamask/superstruct").Struct<`0x${string}` | undefined, null>;
+    value: import("@metamask/superstruct").Struct<`0x${string}` | undefined, null>;
+    data: import("@metamask/superstruct").Struct<`0x${string}` | undefined, null>;
+    gas: import("@metamask/superstruct").Struct<`0x${string}` | undefined, null>;
+    maxFeePerGas: import("@metamask/superstruct").Struct<`0x${string}` | undefined, null>;
+    maxPriorityFeePerGas: import("@metamask/superstruct").Struct<`0x${string}` | undefined, null>;
+    gasPrice: import("@metamask/superstruct").Struct<`0x${string}` | undefined, null>;
+    networkClientId: import("@metamask/superstruct").Struct<string | undefined, null>;
+    chainId: import("@metamask/superstruct").Struct<`0x${string}` | undefined, null>;
+    dryRun: import("@metamask/superstruct").Struct<boolean | undefined, null>;
+}>;
+export type SendTransactionParams = Infer<typeof SendTransactionParamsStruct>;
+/**
+ * The resolved plan a `dryRun` returns: the network client and sender the
+ * daemon would use, without adding or broadcasting anything. Exported as a
+ * struct so the CLI can validate the payload it reads back over JSON-RPC
+ * (which erases types on the wire) rather than trusting its shape.
+ */
+export declare const SendTransactionDryRunResultStruct: import("@metamask/superstruct").Struct<{
+    value: `0x${string}`;
+    to: `0x${string}`;
+    from: `0x${string}`;
+    networkClientId: string;
+    dryRun: true;
+}, {
+    dryRun: import("@metamask/superstruct").Struct<true, true>;
+    from: import("@metamask/superstruct").Struct<`0x${string}`, null>;
+    to: import("@metamask/superstruct").Struct<`0x${string}`, null>;
+    value: import("@metamask/superstruct").Struct<`0x${string}`, null>;
+    networkClientId: import("@metamask/superstruct").Struct<string, null>;
+}>;
+/**
+ * The outcome of a broadcast send: the on-chain hash plus the id/status the
+ * daemon tracks the transaction under. Exported as a struct for the same
+ * client-side validation reason as {@link SendTransactionDryRunResultStruct}.
+ */
+export declare const SendTransactionBroadcastResultStruct: import("@metamask/superstruct").Struct<{
+    status: string;
+    transactionHash: string;
+    transactionId: string;
+}, {
+    transactionHash: import("@metamask/superstruct").Struct<string, null>;
+    transactionId: import("@metamask/superstruct").Struct<string, null>;
+    status: import("@metamask/superstruct").Struct<string, null>;
+}>;
+export type SendTransactionDryRunResult = Infer<typeof SendTransactionDryRunResultStruct>;
+export type SendTransactionBroadcastResult = Infer<typeof SendTransactionBroadcastResultStruct>;
+export type SendTransactionResult = SendTransactionDryRunResult | SendTransactionBroadcastResult;
+/**
+ * Add and broadcast a transaction through the daemon-hosted
+ * `TransactionController`, returning a serializable result.
+ *
+ * `TransactionController:addTransaction` returns `{ transactionMeta, result }`
+ * where `result` is a `Promise<hash>` that resolves once the transaction is
+ * signed and broadcast. That promise is not JSON-serializable, so it cannot
+ * travel back over the daemon's JSON-RPC socket via the generic `call`
+ * dispatch — hence this dedicated handler, which awaits the broadcast
+ * server-side and returns only the resolved hash (and id/status).
+ *
+ * The network client is resolved from `chainId` (via `NetworkController`) when
+ * `networkClientId` is not given directly, and `from` defaults to the selected
+ * account. The transaction is submitted as `isInternal` (the daemon is driven
+ * only by its owner over the `0600` same-user socket), which skips
+ * origin/permitted-account validation; its approval request is auto-accepted
+ * by the daemon's auto-approval subscription.
+ *
+ * When `dryRun` is set, the network client and sender are resolved and the
+ * params validated, but nothing is added or broadcast — the resolved plan is
+ * returned so the CLI can preview it before the user confirms.
+ *
+ * @param messenger - The wallet root messenger.
+ * @param params - Validated `sendTransaction` params.
+ * @returns The dry-run plan, or the broadcast hash with its id and status.
+ */
+export declare function runSendTransaction(messenger: Readonly<RootMessenger<DefaultActions, DefaultEvents>>, params: SendTransactionParams): Promise<SendTransactionResult>;
+//# sourceMappingURL=send-transaction.d.mts.map

package/dist/daemon/send-transaction.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"send-transaction.d.mts","sourceRoot":"","sources":["../../src/daemon/send-transaction.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,KAAK,EAAE,8BAA8B;AAGnD,OAAO,KAAK,EACV,cAAc,EACd,aAAa,EACb,aAAa,EACd,yBAAyB;AAqB1B;;;;;;;;;GASG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;EAmCvC,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAE9E;;;;;GAKG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;EAM5C,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,oCAAoC;;;;;;;;EAI/C,CAAC;AAEH,MAAM,MAAM,2BAA2B,GAAG,KAAK,CAC7C,OAAO,iCAAiC,CACzC,CAAC;AAEF,MAAM,MAAM,8BAA8B,GAAG,KAAK,CAChD,OAAO,oCAAoC,CAC5C,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAC7B,2BAA2B,GAC3B,8BAA8B,CAAC;AAEnC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,kBAAkB,CACtC,SAAS,EAAE,QAAQ,CAAC,aAAa,CAAC,cAAc,EAAE,aAAa,CAAC,CAAC,EACjE,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,qBAAqB,CAAC,CAiEhC"}