@dev.sail.money/sailor 1.3.0-208 → 1.3.0-210

package/packages/cli/dist/server.cjs

@@ -15943,7 +15943,7 @@ var require_get_intrinsic = __commonJS({
     var abs = require_abs();
     var floor = require_floor();
     var max = require_max();
-    var min = require_min();
+    var min2 = require_min();
     var pow = require_pow();
     var round = require_round();
     var sign3 = require_sign();
@@ -16057,7 +16057,7 @@ var require_get_intrinsic = __commonJS({
       "%Math.abs%": abs,
       "%Math.floor%": floor,
       "%Math.max%": max,
-      "%Math.min%": min,
+      "%Math.min%": min2,
       "%Math.pow%": pow,
       "%Math.round%": round,
       "%Math.sign%": sign3,
@@ -22055,12 +22055,12 @@ var require_cookie = __commonJS({
       } while (++index2 < max);
       return max;
     }
-    function endIndex(str, index2, min) {
-      while (index2 > min) {
+    function endIndex(str, index2, min2) {
+      while (index2 > min2) {
         var code = str.charCodeAt(--index2);
         if (code !== 32 && code !== 9) return index2 + 1;
       }
-      return min;
+      return min2;
     }
     function serialize(name, val, opt) {
       var enc = opt && opt.encode || encodeURIComponent;
@@ -26953,8 +26953,8 @@ var init_encoding = __esm({
   "../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.4.3/node_modules/viem/_esm/errors/encoding.js"() {
     init_base();
     IntegerOutOfRangeError = class extends BaseError {
-      constructor({ max, min, signed, size: size6, value }) {
-        super(`Number "${value}" is not in safe ${size6 ? `${size6 * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`, { name: "IntegerOutOfRangeError" });
+      constructor({ max, min: min2, signed, size: size6, value }) {
+        super(`Number "${value}" is not in safe ${size6 ? `${size6 * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min2} to ${max})` : `(above ${min2})`}`, { name: "IntegerOutOfRangeError" });
       }
     };
     SizeOverflowError = class extends BaseError {
@@ -27265,9 +27265,9 @@ function aexists(instance, checkFinished = true) {
 }
 function aoutput(out, instance) {
   abytes(out);
-  const min = instance.outputLen;
-  if (out.length < min) {
-    throw new Error("digestInto() expects output buffer of length at least " + min);
+  const min2 = instance.outputLen;
+  if (out.length < min2) {
+    throw new Error("digestInto() expects output buffer of length at least " + min2);
   }
 }
 function u32(arr) {
@@ -28063,11 +28063,11 @@ function encodeBool(value) {
 function encodeNumber(value, { signed, size: size6 = 256 }) {
   if (typeof size6 === "number") {
     const max = 2n ** (BigInt(size6) - (signed ? 1n : 0n)) - 1n;
-    const min = signed ? -max - 1n : 0n;
-    if (value > max || value < min)
+    const min2 = signed ? -max - 1n : 0n;
+    if (value > max || value < min2)
       throw new IntegerOutOfRangeError({
         max: max.toString(),
-        min: min.toString(),
+        min: min2.toString(),
         signed,
         size: size6 / 8,
         value: value.toString()
@@ -29898,12 +29898,12 @@ function utf8ToBytes2(str) {
     throw new Error("string expected");
   return new Uint8Array(new TextEncoder().encode(str));
 }
-function inRange(n, min, max) {
-  return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
+function inRange(n, min2, max) {
+  return isPosBig(n) && isPosBig(min2) && isPosBig(max) && min2 <= n && n < max;
 }
-function aInRange(title, n, min, max) {
-  if (!inRange(n, min, max))
-    throw new Error("expected valid " + title + ": " + min + " <= n < " + max + ", got " + n);
+function aInRange(title, n, min2, max) {
+  if (!inRange(n, min2, max))
+    throw new Error("expected valid " + title + ": " + min2 + " <= n < " + max + ", got " + n);
 }
 function bitLen(n) {
   let len;
@@ -34260,8 +34260,8 @@ var init_encoding2 = __esm({
   "../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/errors/encoding.js"() {
     init_base2();
     IntegerOutOfRangeError2 = class extends BaseError3 {
-      constructor({ max, min, signed, size: size6, value }) {
-        super(`Number "${value}" is not in safe ${size6 ? `${size6 * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`, { name: "IntegerOutOfRangeError" });
+      constructor({ max, min: min2, signed, size: size6, value }) {
+        super(`Number "${value}" is not in safe ${size6 ? `${size6 * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min2} to ${max})` : `(above ${min2})`}`, { name: "IntegerOutOfRangeError" });
       }
     };
     InvalidBytesBooleanError = class extends BaseError3 {
@@ -34990,11 +34990,11 @@ function encodeBool2(value) {
 function encodeNumber2(value, { signed, size: size6 = 256 }) {
   if (typeof size6 === "number") {
     const max = 2n ** (BigInt(size6) - (signed ? 1n : 0n)) - 1n;
-    const min = signed ? -max - 1n : 0n;
-    if (value > max || value < min)
+    const min2 = signed ? -max - 1n : 0n;
+    if (value > max || value < min2)
       throw new IntegerOutOfRangeError2({
         max: max.toString(),
-        min: min.toString(),
+        min: min2.toString(),
         signed,
         size: size6 / 8,
         value: value.toString()
@@ -38094,8 +38094,8 @@ var init_Hex = __esm({
     encoder6 = /* @__PURE__ */ new TextEncoder();
     hexes5 = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
     IntegerOutOfRangeError3 = class extends BaseError4 {
-      constructor({ max, min, signed, size: size6, value }) {
-        super(`Number \`${value}\` is not in safe${size6 ? ` ${size6 * 8}-bit` : ""}${signed ? " signed" : " unsigned"} integer range ${max ? `(\`${min}\` to \`${max}\`)` : `(above \`${min}\`)`}`);
+      constructor({ max, min: min2, signed, size: size6, value }) {
+        super(`Number \`${value}\` is not in safe${size6 ? ` ${size6 * 8}-bit` : ""}${signed ? " signed" : " unsigned"} integer range ${max ? `(\`${min2}\` to \`${max}\`)` : `(above \`${min2}\`)`}`);
         Object.defineProperty(this, "name", {
           enumerable: true,
           configurable: true,
@@ -38597,7 +38597,7 @@ var init_contracts = __esm({
 });
 
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/errors/chain.js
-var ChainDoesNotSupportContract, ClientChainNotConfiguredError, InvalidChainIdError2;
+var ChainDoesNotSupportContract, ChainMismatchError, ChainNotFoundError, ClientChainNotConfiguredError, InvalidChainIdError2;
 var init_chain2 = __esm({
   "../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/errors/chain.js"() {
     init_base2();
@@ -38616,6 +38616,27 @@ var init_chain2 = __esm({
         });
       }
     };
+    ChainMismatchError = class extends BaseError3 {
+      constructor({ chain: chain2, currentChainId }) {
+        super(`The current chain of the wallet (id: ${currentChainId}) does not match the target chain for the transaction (id: ${chain2.id} \u2013 ${chain2.name}).`, {
+          metaMessages: [
+            `Current Chain ID:  ${currentChainId}`,
+            `Expected Chain ID: ${chain2.id} \u2013 ${chain2.name}`
+          ],
+          name: "ChainMismatchError"
+        });
+      }
+    };
+    ChainNotFoundError = class extends BaseError3 {
+      constructor() {
+        super([
+          "No chain was provided to the request.",
+          "Please provide a chain with the `chain` argument on the Action, or by supplying a `chain` to WalletClient."
+        ].join("\n"), {
+          name: "ChainNotFoundError"
+        });
+      }
+    };
     ClientChainNotConfiguredError = class extends BaseError3 {
       constructor() {
         super("No chain was provided to the Client.", {
@@ -40679,6 +40700,52 @@ var LocalKeyring = class _LocalKeyring {
   }
 };
 
+// ../sdk/dist/abis/SailGovernance.js
+var SailGovernanceAbi = [
+  {
+    type: "function",
+    name: "baseFee",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "complexityRate",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "MAX_PERMISSION_FEE_WEI",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "permissionRegistrationFee",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "maxPermissionsPerAccount",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "isPaused",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "bool" }]
+  }
+];
+
 // ../sdk/dist/safe.js
 init_esm();
 var gnosisSafeAbi = [
@@ -40740,6 +40807,42 @@ function buildSafeSetupInitializer(params) {
   });
 }
 
+// ../sdk/dist/fees.js
+function min(a, b) {
+  return a < b ? a : b;
+}
+async function estimatePermissionFee(publicClient, governance, permission) {
+  try {
+    const [baseFee, complexityRate, cap, code] = await Promise.all([
+      publicClient.readContract({
+        address: governance,
+        abi: SailGovernanceAbi,
+        functionName: "baseFee"
+      }),
+      publicClient.readContract({
+        address: governance,
+        abi: SailGovernanceAbi,
+        functionName: "complexityRate"
+      }),
+      publicClient.readContract({
+        address: governance,
+        abi: SailGovernanceAbi,
+        functionName: "MAX_PERMISSION_FEE_WEI"
+      }),
+      publicClient.getBytecode({ address: permission })
+    ]);
+    const byteLength = code ? BigInt((code.length - 2) / 2) : 0n;
+    const fee = min(baseFee, cap) + min(byteLength * complexityRate, cap);
+    return min(fee, cap);
+  } catch {
+    return publicClient.readContract({
+      address: governance,
+      abi: SailGovernanceAbi,
+      functionName: "permissionRegistrationFee"
+    });
+  }
+}
+
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/utils/getAction.js
 function getAction(client, actionFn, name) {
   const action_implicit = client[actionFn.name];
@@ -42800,6 +42903,56 @@ function watchContractEvent(client, parameters) {
   return enablePolling ? pollContractEvent() : subscribeContractEvent();
 }
 
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/actions/wallet/writeContract.js
+init_parseAccount();
+
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/errors/account.js
+init_base2();
+var AccountNotFoundError = class extends BaseError3 {
+  constructor({ docsPath: docsPath9 } = {}) {
+    super([
+      "Could not find an Account to execute with this Action.",
+      "Please provide an Account with the `account` argument on the Action, or by supplying an `account` to the Client."
+    ].join("\n"), {
+      docsPath: docsPath9,
+      docsSlug: "account",
+      name: "AccountNotFoundError"
+    });
+  }
+};
+var AccountTypeNotSupportedError = class extends BaseError3 {
+  constructor({ docsPath: docsPath9, metaMessages, type }) {
+    super(`Account type "${type}" is not supported.`, {
+      docsPath: docsPath9,
+      metaMessages,
+      name: "AccountTypeNotSupportedError"
+    });
+  }
+};
+
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/actions/wallet/writeContract.js
+init_encodeFunctionData2();
+
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/actions/wallet/sendTransaction.js
+init_parseAccount();
+init_base2();
+
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/utils/chain/assertCurrentChain.js
+init_chain2();
+function assertCurrentChain({ chain: chain2, currentChainId }) {
+  if (!chain2)
+    throw new ChainNotFoundError();
+  if (currentChainId !== chain2.id)
+    throw new ChainMismatchError({ chain: chain2, currentChainId });
+}
+
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/actions/wallet/sendTransaction.js
+init_concat2();
+init_extract();
+init_transactionRequest();
+init_lru2();
+init_assertRequest();
+
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/actions/wallet/sendRawTransaction.js
 async function sendRawTransaction(client, { serializedTransaction }) {
   return client.request({
@@ -42808,6 +42961,218 @@ async function sendRawTransaction(client, { serializedTransaction }) {
   }, { retryCount: 0 });
 }
 
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/actions/wallet/sendTransaction.js
+var supportsWalletNamespace = new LruMap2(128);
+async function sendTransaction(client, parameters) {
+  const { account: account_ = client.account, assertChainId = true, chain: chain2 = client.chain, accessList, authorizationList, blobs, data, dataSuffix = typeof client.dataSuffix === "string" ? client.dataSuffix : client.dataSuffix?.value, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, type, value, ...rest } = parameters;
+  if (typeof account_ === "undefined")
+    throw new AccountNotFoundError({
+      docsPath: "/docs/actions/wallet/sendTransaction"
+    });
+  const account = account_ ? parseAccount(account_) : null;
+  let nonceManagerParameters;
+  try {
+    assertRequest(parameters);
+    const to = await (async () => {
+      if (parameters.to)
+        return parameters.to;
+      if (parameters.to === null)
+        return void 0;
+      if (authorizationList && authorizationList.length > 0)
+        return await recoverAuthorizationAddress({
+          authorization: authorizationList[0]
+        }).catch(() => {
+          throw new BaseError3("`to` is required. Could not infer from `authorizationList`.");
+        });
+      return void 0;
+    })();
+    if (account?.type === "json-rpc" || account === null) {
+      let chainId;
+      if (chain2 !== null) {
+        chainId = await getAction(client, getChainId, "getChainId")({});
+        if (assertChainId)
+          assertCurrentChain({
+            currentChainId: chainId,
+            chain: chain2
+          });
+      }
+      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
+      const format = chainFormat || formatTransactionRequest;
+      const request = format({
+        // Pick out extra data that might exist on the chain's transaction request type.
+        ...extract(rest, { format: chainFormat }),
+        accessList,
+        account,
+        authorizationList,
+        blobs,
+        chainId,
+        data: dataSuffix ? concat2([data ?? "0x", dataSuffix]) : data,
+        gas,
+        gasPrice,
+        maxFeePerBlobGas,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce,
+        to,
+        type,
+        value
+      }, "sendTransaction");
+      const isWalletNamespaceSupported = supportsWalletNamespace.get(client.uid);
+      const method = isWalletNamespaceSupported ? "wallet_sendTransaction" : "eth_sendTransaction";
+      try {
+        return await client.request({
+          method,
+          params: [request]
+        }, { retryCount: 0 });
+      } catch (e) {
+        if (isWalletNamespaceSupported === false)
+          throw e;
+        const error = e;
+        if (error.name === "InvalidInputRpcError" || error.name === "InvalidParamsRpcError" || error.name === "MethodNotFoundRpcError" || error.name === "MethodNotSupportedRpcError") {
+          return await client.request({
+            method: "wallet_sendTransaction",
+            params: [request]
+          }, { retryCount: 0 }).then((hash4) => {
+            supportsWalletNamespace.set(client.uid, true);
+            return hash4;
+          }).catch((e2) => {
+            const walletNamespaceError = e2;
+            if (walletNamespaceError.name === "MethodNotFoundRpcError" || walletNamespaceError.name === "MethodNotSupportedRpcError") {
+              supportsWalletNamespace.set(client.uid, false);
+              throw error;
+            }
+            throw walletNamespaceError;
+          });
+        }
+        throw error;
+      }
+    }
+    if (account?.type === "local") {
+      if (account.nonceManager && typeof nonce === "undefined") {
+        const requestChainId = rest.chainId;
+        const chainId = await (async () => {
+          if (typeof requestChainId === "number")
+            return requestChainId;
+          if (chain2)
+            return chain2.id;
+          return getAction(client, getChainId, "getChainId")({});
+        })();
+        nonceManagerParameters = { address: account.address, chainId };
+      }
+      const request = await getAction(client, prepareTransactionRequest, "prepareTransactionRequest")({
+        account,
+        accessList,
+        authorizationList,
+        blobs,
+        chain: chain2,
+        data: dataSuffix ? concat2([data ?? "0x", dataSuffix]) : data,
+        gas,
+        gasPrice,
+        maxFeePerBlobGas,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce,
+        nonceManager: account.nonceManager,
+        parameters: [...defaultParameters, "sidecars"],
+        type,
+        value,
+        ...rest,
+        to
+      });
+      const serializer = chain2?.serializers?.transaction;
+      const serializedTransaction = await account.signTransaction(request, {
+        serializer
+      });
+      return await getAction(client, sendRawTransaction, "sendRawTransaction")({
+        serializedTransaction
+      });
+    }
+    if (account?.type === "smart")
+      throw new AccountTypeNotSupportedError({
+        metaMessages: [
+          "Consider using the `sendUserOperation` Action instead."
+        ],
+        docsPath: "/docs/actions/bundler/sendUserOperation",
+        type: "smart"
+      });
+    throw new AccountTypeNotSupportedError({
+      docsPath: "/docs/actions/wallet/sendTransaction",
+      type: account?.type
+    });
+  } catch (err) {
+    if (err instanceof AccountTypeNotSupportedError)
+      throw err;
+    if (nonceManagerParameters)
+      account?.nonceManager?.reset(nonceManagerParameters);
+    throw getTransactionError(err, {
+      ...parameters,
+      account,
+      chain: parameters.chain || void 0
+    });
+  }
+}
+
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/actions/wallet/writeContract.js
+async function writeContract(client, parameters) {
+  return writeContract.internal(client, sendTransaction, "sendTransaction", parameters);
+}
+(function(writeContract2) {
+  async function internal(client, actionFn, name, parameters) {
+    const { abi: abi2, account: account_ = client.account, address, args, functionName, ...request } = parameters;
+    if (typeof account_ === "undefined")
+      throw new AccountNotFoundError({
+        docsPath: "/docs/contract/writeContract"
+      });
+    const account = account_ ? parseAccount(account_) : null;
+    const data = encodeFunctionData2({
+      abi: abi2,
+      args,
+      functionName
+    });
+    try {
+      return await getAction(client, actionFn, name)({
+        data,
+        to: address,
+        account,
+        ...request
+      });
+    } catch (error) {
+      throw getContractError(error, {
+        abi: abi2,
+        address,
+        args,
+        docsPath: "/docs/contract/writeContract",
+        functionName,
+        sender: account?.address
+      });
+    }
+  }
+  writeContract2.internal = internal;
+})(writeContract || (writeContract = {}));
+
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/actions/wallet/waitForCallsStatus.js
+init_base2();
+
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/errors/calls.js
+init_base2();
+var BundleFailedError = class extends BaseError3 {
+  constructor(result) {
+    super(`Call bundle failed with status: ${result.statusCode}`, {
+      name: "BundleFailedError"
+    });
+    Object.defineProperty(this, "result", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.result = result;
+  }
+};
+
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/actions/wallet/waitForCallsStatus.js
+init_withResolvers();
+
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/utils/promise/withRetry.js
 init_utils4();
 function withRetry(fn, { delay: delay_ = 100, retryCount = 2, shouldRetry: shouldRetry2 = () => true, signal } = {}) {
@@ -42850,6 +43215,14 @@ function withRetry(fn, { delay: delay_ = 100, retryCount = 2, shouldRetry: shoul
   });
 }
 
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/actions/wallet/waitForCallsStatus.js
+init_stringify2();
+
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/actions/wallet/getCallsStatus.js
+init_slice2();
+init_trim2();
+init_fromHex2();
+
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/utils/formatters/transactionReceipt.js
 init_fromHex2();
 var receiptStatuses = {
@@ -42877,6 +43250,251 @@ function formatTransactionReceipt(transactionReceipt, _) {
   return receipt;
 }
 
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/actions/wallet/sendCalls.js
+init_parseAccount();
+init_base2();
+init_rpc();
+init_encodeFunctionData2();
+init_concat2();
+init_fromHex2();
+init_toHex2();
+var fallbackMagicIdentifier = "0x5792579257925792579257925792579257925792579257925792579257925792";
+var fallbackTransactionErrorMagicIdentifier = numberToHex2(0, {
+  size: 32
+});
+async function sendCalls(client, parameters) {
+  const { account: account_ = client.account, chain: chain2 = client.chain, experimental_fallback, experimental_fallbackDelay = 32, forceAtomic = false, id, version: version5 = "2.0.0" } = parameters;
+  const account = account_ ? parseAccount(account_) : null;
+  let capabilities = parameters.capabilities;
+  if (client.dataSuffix && !parameters.capabilities?.dataSuffix) {
+    if (typeof client.dataSuffix === "string")
+      capabilities = {
+        ...parameters.capabilities,
+        dataSuffix: { value: client.dataSuffix, optional: true }
+      };
+    else
+      capabilities = {
+        ...parameters.capabilities,
+        dataSuffix: {
+          value: client.dataSuffix.value,
+          ...client.dataSuffix.required ? {} : { optional: true }
+        }
+      };
+  }
+  const calls = parameters.calls.map((call_) => {
+    const call2 = call_;
+    const data = call2.abi ? encodeFunctionData2({
+      abi: call2.abi,
+      functionName: call2.functionName,
+      args: call2.args
+    }) : call2.data;
+    return {
+      data: call2.dataSuffix && data ? concat2([data, call2.dataSuffix]) : data,
+      to: call2.to,
+      value: call2.value ? numberToHex2(call2.value) : void 0
+    };
+  });
+  try {
+    const response = await client.request({
+      method: "wallet_sendCalls",
+      params: [
+        {
+          atomicRequired: forceAtomic,
+          calls,
+          capabilities,
+          chainId: numberToHex2(chain2.id),
+          from: account?.address,
+          id,
+          version: version5
+        }
+      ]
+    }, { retryCount: 0 });
+    if (typeof response === "string")
+      return { id: response };
+    return response;
+  } catch (err) {
+    const error = err;
+    if (experimental_fallback && (error.name === "MethodNotFoundRpcError" || error.name === "MethodNotSupportedRpcError" || error.name === "UnknownRpcError" || error.details.toLowerCase().includes("does not exist / is not available") || error.details.toLowerCase().includes("missing or invalid. request()") || error.details.toLowerCase().includes("did not match any variant of untagged enum") || error.details.toLowerCase().includes("account upgraded to unsupported contract") || error.details.toLowerCase().includes("eip-7702 not supported") || error.details.toLowerCase().includes("unsupported wc_ method") || // magic.link
+    error.details.toLowerCase().includes("feature toggled misconfigured") || // Trust Wallet
+    error.details.toLowerCase().includes("jsonrpcengine: response has no error or result for request"))) {
+      if (capabilities) {
+        const hasNonOptionalCapability = Object.values(capabilities).some((capability) => !capability.optional);
+        if (hasNonOptionalCapability) {
+          const message = "non-optional `capabilities` are not supported on fallback to `eth_sendTransaction`.";
+          throw new UnsupportedNonOptionalCapabilityError(new BaseError3(message, {
+            details: message
+          }));
+        }
+      }
+      if (forceAtomic && calls.length > 1) {
+        const message = "`forceAtomic` is not supported on fallback to `eth_sendTransaction`.";
+        throw new AtomicityNotSupportedError(new BaseError3(message, {
+          details: message
+        }));
+      }
+      const results = [];
+      for (const call2 of calls) {
+        try {
+          const value = await sendTransaction(client, {
+            account,
+            chain: chain2,
+            data: call2.data,
+            to: call2.to,
+            value: call2.value ? hexToBigInt2(call2.value) : void 0
+          });
+          results.push({ status: "fulfilled", value });
+        } catch (reason) {
+          results.push({ reason, status: "rejected" });
+        }
+        if (experimental_fallbackDelay > 0)
+          await new Promise((resolve) => setTimeout(resolve, experimental_fallbackDelay));
+      }
+      if (results.every((r) => r.status === "rejected"))
+        throw results[0].reason;
+      const hashes = results.map((result) => {
+        if (result.status === "fulfilled")
+          return result.value;
+        return fallbackTransactionErrorMagicIdentifier;
+      });
+      return {
+        id: concat2([
+          ...hashes,
+          numberToHex2(chain2.id, { size: 32 }),
+          fallbackMagicIdentifier
+        ])
+      };
+    }
+    throw getTransactionError(err, {
+      ...parameters,
+      account,
+      chain: parameters.chain
+    });
+  }
+}
+
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/actions/wallet/getCallsStatus.js
+async function getCallsStatus(client, parameters) {
+  async function getStatus(id) {
+    const isTransactions = id.endsWith(fallbackMagicIdentifier.slice(2));
+    if (isTransactions) {
+      const chainId2 = trim2(sliceHex2(id, -64, -32));
+      const hashes = sliceHex2(id, 0, -64).slice(2).match(/.{1,64}/g);
+      const receipts2 = await Promise.all(hashes.map((hash4) => fallbackTransactionErrorMagicIdentifier.slice(2) !== hash4 ? client.request({
+        method: "eth_getTransactionReceipt",
+        params: [`0x${hash4}`]
+      }, { dedupe: true }) : void 0));
+      const status2 = (() => {
+        if (receipts2.some((r) => r === null))
+          return 100;
+        if (receipts2.every((r) => r?.status === "0x1"))
+          return 200;
+        if (receipts2.every((r) => r?.status === "0x0"))
+          return 500;
+        return 600;
+      })();
+      return {
+        atomic: false,
+        chainId: hexToNumber3(chainId2),
+        receipts: receipts2.filter(Boolean),
+        status: status2,
+        version: "2.0.0"
+      };
+    }
+    return client.request({
+      method: "wallet_getCallsStatus",
+      params: [id]
+    });
+  }
+  const { atomic = false, chainId, receipts, version: version5 = "2.0.0", ...response } = await getStatus(parameters.id);
+  const [status, statusCode] = (() => {
+    const statusCode2 = response.status;
+    if (statusCode2 >= 100 && statusCode2 < 200)
+      return ["pending", statusCode2];
+    if (statusCode2 >= 200 && statusCode2 < 300)
+      return ["success", statusCode2];
+    if (statusCode2 >= 300 && statusCode2 < 700)
+      return ["failure", statusCode2];
+    if (statusCode2 === "CONFIRMED")
+      return ["success", 200];
+    if (statusCode2 === "PENDING")
+      return ["pending", 100];
+    return [void 0, statusCode2];
+  })();
+  return {
+    ...response,
+    atomic,
+    // @ts-expect-error: for backwards compatibility
+    chainId: chainId ? hexToNumber3(chainId) : void 0,
+    receipts: receipts?.map((receipt) => ({
+      ...receipt,
+      blockNumber: hexToBigInt2(receipt.blockNumber),
+      gasUsed: hexToBigInt2(receipt.gasUsed),
+      status: receiptStatuses[receipt.status]
+    })) ?? [],
+    statusCode,
+    status,
+    version: version5
+  };
+}
+
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/actions/wallet/waitForCallsStatus.js
+async function waitForCallsStatus(client, parameters) {
+  const {
+    id,
+    pollingInterval = client.pollingInterval,
+    status = ({ statusCode }) => statusCode === 200 || statusCode >= 300,
+    retryCount = 4,
+    retryDelay = ({ count }) => ~~(1 << count) * 200,
+    // exponential backoff
+    timeout = 6e4,
+    throwOnFailure = false
+  } = parameters;
+  const observerId = stringify2(["waitForCallsStatus", client.uid, id]);
+  const { promise, resolve, reject } = withResolvers();
+  let timer;
+  const unobserve = observe(observerId, { resolve, reject }, (emit) => {
+    const unpoll = poll(async () => {
+      const done = (fn) => {
+        clearTimeout(timer);
+        unpoll();
+        fn();
+        unobserve();
+      };
+      try {
+        const result = await withRetry(async () => {
+          const result2 = await getAction(client, getCallsStatus, "getCallsStatus")({ id });
+          if (throwOnFailure && result2.status === "failure")
+            throw new BundleFailedError(result2);
+          return result2;
+        }, {
+          retryCount,
+          delay: retryDelay
+        });
+        if (!status(result))
+          return;
+        done(() => emit.resolve(result));
+      } catch (error) {
+        done(() => emit.reject(error));
+      }
+    }, {
+      interval: pollingInterval,
+      emitOnBegin: true
+    });
+    return unpoll;
+  });
+  timer = timeout ? setTimeout(() => {
+    unobserve();
+    clearTimeout(timer);
+    reject(new WaitForCallsStatusTimeoutError({ id }));
+  }, timeout) : void 0;
+  return await promise;
+}
+var WaitForCallsStatusTimeoutError = class extends BaseError3 {
+  constructor({ id }) {
+    super(`Timed out while waiting for call bundle with id "${id}" to be confirmed.`, { name: "WaitForCallsStatusTimeoutError" });
+  }
+};
+
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/clients/createClient.js
 init_parseAccount();
 
@@ -44417,6 +45035,26 @@ function hashString(str, seed = 0) {
   return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(36);
 }
 
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/utils/chain/defineChain.js
+function defineChain(chain2) {
+  const chainInstance = {
+    formatters: void 0,
+    fees: void 0,
+    serializers: void 0,
+    ...chain2
+  };
+  function extend(base) {
+    return (fnOrExtended) => {
+      const properties = typeof fnOrExtended === "function" ? fnOrExtended(base) : fnOrExtended;
+      const combined = { ...base, ...properties };
+      return Object.assign(combined, { extend: extend(combined) });
+    };
+  }
+  return Object.assign(chainInstance, {
+    extend: extend(chainInstance)
+  });
+}
+
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/utils/index.js
 init_fromHex2();
 
@@ -44649,6 +45287,32 @@ init_isAddress2();
 init_size2();
 init_toHex2();
 init_regex4();
+init_stringify2();
+function serializeTypedData(parameters) {
+  const { domain: domain_, message: message_, primaryType, types } = parameters;
+  const normalizeData = (struct, data_) => {
+    const data = { ...data_ };
+    for (const param of struct) {
+      const { name, type } = param;
+      if (type === "address")
+        data[name] = data[name].toLowerCase();
+    }
+    return data;
+  };
+  const domain = (() => {
+    if (!types.EIP712Domain)
+      return {};
+    if (!domain_)
+      return {};
+    return normalizeData(types.EIP712Domain, domain_);
+  })();
+  const message = (() => {
+    if (primaryType === "EIP712Domain")
+      return void 0;
+    return normalizeData(types[primaryType], message_);
+  })();
+  return stringify2({ domain, message, primaryType, types });
+}
 function validateTypedData2(parameters) {
   const { domain, message, primaryType, types } = parameters;
   const validateData = (struct, data) => {
@@ -45564,11 +46228,11 @@ function encodeBoolean(value) {
 function encodeNumber3(value, { signed, size: size6 }) {
   if (typeof size6 === "number") {
     const max = 2n ** (BigInt(size6) - (signed ? 1n : 0n)) - 1n;
-    const min = signed ? -max - 1n : 0n;
-    if (value > max || value < min)
+    const min2 = signed ? -max - 1n : 0n;
+    if (value > max || value < min2)
       throw new IntegerOutOfRangeError3({
         max: max.toString(),
-        min: min.toString(),
+        min: min2.toString(),
         signed,
         size: size6 / 8,
         value: value.toString()
@@ -48437,6 +49101,507 @@ function createPublicClient(parameters) {
   return client.extend(publicActions);
 }
 
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/actions/wallet/addChain.js
+init_toHex2();
+async function addChain(client, { chain: chain2 }) {
+  const { id, name, nativeCurrency, rpcUrls, blockExplorers } = chain2;
+  await client.request({
+    method: "wallet_addEthereumChain",
+    params: [
+      {
+        chainId: numberToHex2(id),
+        chainName: name,
+        nativeCurrency,
+        rpcUrls: rpcUrls.default.http,
+        blockExplorerUrls: blockExplorers ? Object.values(blockExplorers).map(({ url }) => url) : void 0
+      }
+    ]
+  }, { dedupe: true, retryCount: 0 });
+}
+
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/actions/wallet/deployContract.js
+init_encodeDeployData();
+function deployContract(walletClient, parameters) {
+  const { abi: abi2, args, bytecode, ...request } = parameters;
+  const calldata = encodeDeployData({ abi: abi2, args, bytecode });
+  return sendTransaction(walletClient, {
+    ...request,
+    ...request.authorizationList ? { to: null } : {},
+    data: calldata
+  });
+}
+
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/actions/wallet/getAddresses.js
+init_getAddress2();
+async function getAddresses(client) {
+  if (client.account?.type === "local")
+    return [client.account.address];
+  const addresses = await client.request({ method: "eth_accounts" }, { dedupe: true });
+  return addresses.map((address) => checksumAddress2(address));
+}
+
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/actions/wallet/getCapabilities.js
+init_parseAccount();
+init_toHex2();
+async function getCapabilities(client, parameters = {}) {
+  const { account = client.account, chainId } = parameters;
+  const account_ = account ? parseAccount(account) : void 0;
+  const params = chainId ? [account_?.address, [numberToHex2(chainId)]] : [account_?.address];
+  const capabilities_raw = await client.request({
+    method: "wallet_getCapabilities",
+    params
+  });
+  const capabilities = {};
+  for (const [chainId2, capabilities_] of Object.entries(capabilities_raw)) {
+    capabilities[Number(chainId2)] = {};
+    for (let [key, value] of Object.entries(capabilities_)) {
+      if (key === "addSubAccount")
+        key = "unstable_addSubAccount";
+      capabilities[Number(chainId2)][key] = value;
+    }
+  }
+  return typeof chainId === "number" ? capabilities[chainId] : capabilities;
+}
+
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/actions/wallet/getPermissions.js
+async function getPermissions(client) {
+  const permissions = await client.request({ method: "wallet_getPermissions" }, { dedupe: true });
+  return permissions;
+}
+
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/actions/wallet/prepareAuthorization.js
+init_parseAccount();
+init_isAddressEqual();
+async function prepareAuthorization(client, parameters) {
+  const { account: account_ = client.account, chainId, nonce } = parameters;
+  if (!account_)
+    throw new AccountNotFoundError({
+      docsPath: "/docs/eip7702/prepareAuthorization"
+    });
+  const account = parseAccount(account_);
+  const executor = (() => {
+    if (!parameters.executor)
+      return void 0;
+    if (parameters.executor === "self")
+      return parameters.executor;
+    return parseAccount(parameters.executor);
+  })();
+  const authorization = {
+    address: parameters.contractAddress ?? parameters.address,
+    chainId,
+    nonce
+  };
+  if (typeof authorization.chainId === "undefined")
+    authorization.chainId = client.chain?.id ?? await getAction(client, getChainId, "getChainId")({});
+  if (typeof authorization.nonce === "undefined") {
+    authorization.nonce = await getAction(client, getTransactionCount, "getTransactionCount")({
+      address: account.address,
+      blockTag: "pending"
+    });
+    if (executor === "self" || executor?.address && isAddressEqual(executor.address, account.address))
+      authorization.nonce += 1;
+  }
+  return authorization;
+}
+
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/actions/wallet/requestAddresses.js
+init_getAddress2();
+async function requestAddresses(client) {
+  const addresses = await client.request({ method: "eth_requestAccounts" }, { dedupe: true, retryCount: 0 });
+  return addresses.map((address) => getAddress(address));
+}
+
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/actions/wallet/requestPermissions.js
+async function requestPermissions(client, permissions) {
+  return client.request({
+    method: "wallet_requestPermissions",
+    params: [permissions]
+  }, { retryCount: 0 });
+}
+
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/actions/wallet/sendCallsSync.js
+async function sendCallsSync(client, parameters) {
+  const { chain: chain2 = client.chain } = parameters;
+  const timeout = parameters.timeout ?? Math.max((chain2?.blockTime ?? 0) * 3, 5e3);
+  const result = await getAction(client, sendCalls, "sendCalls")(parameters);
+  const status = await getAction(client, waitForCallsStatus, "waitForCallsStatus")({
+    ...parameters,
+    id: result.id,
+    timeout
+  });
+  return status;
+}
+
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/actions/wallet/sendTransactionSync.js
+init_parseAccount();
+init_base2();
+init_transaction2();
+init_concat2();
+init_extract();
+init_transactionRequest();
+init_lru2();
+init_assertRequest();
+var supportsWalletNamespace2 = new LruMap2(128);
+async function sendTransactionSync(client, parameters) {
+  const { account: account_ = client.account, assertChainId = true, chain: chain2 = client.chain, accessList, authorizationList, blobs, data, dataSuffix = typeof client.dataSuffix === "string" ? client.dataSuffix : client.dataSuffix?.value, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, pollingInterval, throwOnReceiptRevert, type, value, ...rest } = parameters;
+  const timeout = parameters.timeout ?? Math.max((chain2?.blockTime ?? 0) * 3, 5e3);
+  if (typeof account_ === "undefined")
+    throw new AccountNotFoundError({
+      docsPath: "/docs/actions/wallet/sendTransactionSync"
+    });
+  const account = account_ ? parseAccount(account_) : null;
+  let nonceManagerParameters;
+  try {
+    assertRequest(parameters);
+    const to = await (async () => {
+      if (parameters.to)
+        return parameters.to;
+      if (parameters.to === null)
+        return void 0;
+      if (authorizationList && authorizationList.length > 0)
+        return await recoverAuthorizationAddress({
+          authorization: authorizationList[0]
+        }).catch(() => {
+          throw new BaseError3("`to` is required. Could not infer from `authorizationList`.");
+        });
+      return void 0;
+    })();
+    if (account?.type === "json-rpc" || account === null) {
+      let chainId;
+      if (chain2 !== null) {
+        chainId = await getAction(client, getChainId, "getChainId")({});
+        if (assertChainId)
+          assertCurrentChain({
+            currentChainId: chainId,
+            chain: chain2
+          });
+      }
+      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
+      const format = chainFormat || formatTransactionRequest;
+      const request = format({
+        // Pick out extra data that might exist on the chain's transaction request type.
+        ...extract(rest, { format: chainFormat }),
+        accessList,
+        account,
+        authorizationList,
+        blobs,
+        chainId,
+        data: dataSuffix ? concat2([data ?? "0x", dataSuffix]) : data,
+        gas,
+        gasPrice,
+        maxFeePerBlobGas,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce,
+        to,
+        type,
+        value
+      }, "sendTransaction");
+      const isWalletNamespaceSupported = supportsWalletNamespace2.get(client.uid);
+      const method = isWalletNamespaceSupported ? "wallet_sendTransaction" : "eth_sendTransaction";
+      const hash4 = await (async () => {
+        try {
+          return await client.request({
+            method,
+            params: [request]
+          }, { retryCount: 0 });
+        } catch (e) {
+          if (isWalletNamespaceSupported === false)
+            throw e;
+          const error = e;
+          if (error.name === "InvalidInputRpcError" || error.name === "InvalidParamsRpcError" || error.name === "MethodNotFoundRpcError" || error.name === "MethodNotSupportedRpcError") {
+            return await client.request({
+              method: "wallet_sendTransaction",
+              params: [request]
+            }, { retryCount: 0 }).then((hash5) => {
+              supportsWalletNamespace2.set(client.uid, true);
+              return hash5;
+            }).catch((e2) => {
+              const walletNamespaceError = e2;
+              if (walletNamespaceError.name === "MethodNotFoundRpcError" || walletNamespaceError.name === "MethodNotSupportedRpcError") {
+                supportsWalletNamespace2.set(client.uid, false);
+                throw error;
+              }
+              throw walletNamespaceError;
+            });
+          }
+          throw error;
+        }
+      })();
+      const receipt = await getAction(client, waitForTransactionReceipt, "waitForTransactionReceipt")({
+        checkReplacement: false,
+        hash: hash4,
+        pollingInterval,
+        timeout
+      });
+      if (throwOnReceiptRevert && receipt.status === "reverted")
+        throw new TransactionReceiptRevertedError({ receipt });
+      return receipt;
+    }
+    if (account?.type === "local") {
+      if (account.nonceManager && typeof nonce === "undefined") {
+        const requestChainId = rest.chainId;
+        const chainId = await (async () => {
+          if (typeof requestChainId === "number")
+            return requestChainId;
+          if (chain2)
+            return chain2.id;
+          return getAction(client, getChainId, "getChainId")({});
+        })();
+        nonceManagerParameters = { address: account.address, chainId };
+      }
+      const request = await getAction(client, prepareTransactionRequest, "prepareTransactionRequest")({
+        account,
+        accessList,
+        authorizationList,
+        blobs,
+        chain: chain2,
+        data: dataSuffix ? concat2([data ?? "0x", dataSuffix]) : data,
+        gas,
+        gasPrice,
+        maxFeePerBlobGas,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce,
+        nonceManager: account.nonceManager,
+        parameters: [...defaultParameters, "sidecars"],
+        type,
+        value,
+        ...rest,
+        to
+      });
+      const serializer = chain2?.serializers?.transaction;
+      const serializedTransaction = await account.signTransaction(request, {
+        serializer
+      });
+      return await getAction(client, sendRawTransactionSync, "sendRawTransactionSync")({
+        serializedTransaction,
+        throwOnReceiptRevert,
+        timeout: parameters.timeout
+      });
+    }
+    if (account?.type === "smart")
+      throw new AccountTypeNotSupportedError({
+        metaMessages: [
+          "Consider using the `sendUserOperation` Action instead."
+        ],
+        docsPath: "/docs/actions/bundler/sendUserOperation",
+        type: "smart"
+      });
+    throw new AccountTypeNotSupportedError({
+      docsPath: "/docs/actions/wallet/sendTransactionSync",
+      type: account?.type
+    });
+  } catch (err) {
+    if (err instanceof AccountTypeNotSupportedError)
+      throw err;
+    if (nonceManagerParameters && !(err instanceof TransactionReceiptRevertedError))
+      account?.nonceManager?.reset(nonceManagerParameters);
+    throw getTransactionError(err, {
+      ...parameters,
+      account,
+      chain: parameters.chain || void 0
+    });
+  }
+}
+
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/actions/wallet/showCallsStatus.js
+async function showCallsStatus(client, parameters) {
+  const { id } = parameters;
+  await client.request({
+    method: "wallet_showCallsStatus",
+    params: [id]
+  });
+  return;
+}
+
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/actions/wallet/signAuthorization.js
+init_parseAccount();
+async function signAuthorization2(client, parameters) {
+  const { account: account_ = client.account } = parameters;
+  if (!account_)
+    throw new AccountNotFoundError({
+      docsPath: "/docs/eip7702/signAuthorization"
+    });
+  const account = parseAccount(account_);
+  if (!account.signAuthorization)
+    throw new AccountTypeNotSupportedError({
+      docsPath: "/docs/eip7702/signAuthorization",
+      metaMessages: [
+        "The `signAuthorization` Action does not support JSON-RPC Accounts."
+      ],
+      type: account.type
+    });
+  const authorization = await prepareAuthorization(client, parameters);
+  return account.signAuthorization(authorization);
+}
+
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/actions/wallet/signMessage.js
+init_parseAccount();
+init_toHex2();
+async function signMessage2(client, { account: account_ = client.account, message }) {
+  if (!account_)
+    throw new AccountNotFoundError({
+      docsPath: "/docs/actions/wallet/signMessage"
+    });
+  const account = parseAccount(account_);
+  if (account.signMessage)
+    return account.signMessage({ message });
+  const message_ = (() => {
+    if (typeof message === "string")
+      return stringToHex2(message);
+    if (message.raw instanceof Uint8Array)
+      return toHex2(message.raw);
+    return message.raw;
+  })();
+  return client.request({
+    method: "personal_sign",
+    params: [message_, account.address]
+  }, { retryCount: 0 });
+}
+
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/actions/wallet/signTransaction.js
+init_parseAccount();
+init_toHex2();
+init_transactionRequest();
+init_assertRequest();
+async function signTransaction2(client, parameters) {
+  const { account: account_ = client.account, chain: chain2 = client.chain, ...transaction } = parameters;
+  if (!account_)
+    throw new AccountNotFoundError({
+      docsPath: "/docs/actions/wallet/signTransaction"
+    });
+  const account = parseAccount(account_);
+  assertRequest({
+    account,
+    ...parameters
+  });
+  const chainId = await getAction(client, getChainId, "getChainId")({});
+  if (chain2 !== null)
+    assertCurrentChain({
+      currentChainId: chainId,
+      chain: chain2
+    });
+  const formatters = chain2?.formatters || client.chain?.formatters;
+  const format = formatters?.transactionRequest?.format || formatTransactionRequest;
+  if (account.signTransaction)
+    return account.signTransaction({
+      ...transaction,
+      account,
+      chainId
+    }, { serializer: client.chain?.serializers?.transaction });
+  return await client.request({
+    method: "eth_signTransaction",
+    params: [
+      {
+        ...format({
+          ...transaction,
+          account
+        }, "signTransaction"),
+        chainId: numberToHex2(chainId),
+        from: account.address
+      }
+    ]
+  }, { retryCount: 0 });
+}
+
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/actions/wallet/signTypedData.js
+init_parseAccount();
+async function signTypedData2(client, parameters) {
+  const { account: account_ = client.account, domain, message, primaryType } = parameters;
+  if (!account_)
+    throw new AccountNotFoundError({
+      docsPath: "/docs/actions/wallet/signTypedData"
+    });
+  const account = parseAccount(account_);
+  const types = {
+    EIP712Domain: getTypesForEIP712Domain2({ domain }),
+    ...parameters.types
+  };
+  validateTypedData2({ domain, message, primaryType, types });
+  if (account.signTypedData)
+    return account.signTypedData({ domain, message, primaryType, types });
+  const typedData = serializeTypedData({ domain, message, primaryType, types });
+  return client.request({
+    method: "eth_signTypedData_v4",
+    params: [account.address, typedData]
+  }, { retryCount: 0 });
+}
+
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/actions/wallet/switchChain.js
+init_toHex2();
+async function switchChain(client, { id }) {
+  await client.request({
+    method: "wallet_switchEthereumChain",
+    params: [
+      {
+        chainId: numberToHex2(id)
+      }
+    ]
+  }, { retryCount: 0 });
+}
+
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/actions/wallet/watchAsset.js
+async function watchAsset(client, params) {
+  const added = await client.request({
+    method: "wallet_watchAsset",
+    params
+  }, { retryCount: 0 });
+  return added;
+}
+
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/actions/wallet/writeContractSync.js
+async function writeContractSync(client, parameters) {
+  return writeContract.internal(client, sendTransactionSync, "sendTransactionSync", parameters);
+}
+
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/clients/decorators/wallet.js
+function walletActions(client) {
+  return {
+    addChain: (args) => addChain(client, args),
+    deployContract: (args) => deployContract(client, args),
+    fillTransaction: (args) => fillTransaction(client, args),
+    getAddresses: () => getAddresses(client),
+    getCallsStatus: (args) => getCallsStatus(client, args),
+    getCapabilities: (args) => getCapabilities(client, args),
+    getChainId: () => getChainId(client),
+    getPermissions: () => getPermissions(client),
+    prepareAuthorization: (args) => prepareAuthorization(client, args),
+    prepareTransactionRequest: (args) => prepareTransactionRequest(client, args),
+    requestAddresses: () => requestAddresses(client),
+    requestPermissions: (args) => requestPermissions(client, args),
+    sendCalls: (args) => sendCalls(client, args),
+    sendCallsSync: (args) => sendCallsSync(client, args),
+    sendRawTransaction: (args) => sendRawTransaction(client, args),
+    sendRawTransactionSync: (args) => sendRawTransactionSync(client, args),
+    sendTransaction: (args) => sendTransaction(client, args),
+    sendTransactionSync: (args) => sendTransactionSync(client, args),
+    showCallsStatus: (args) => showCallsStatus(client, args),
+    signAuthorization: (args) => signAuthorization2(client, args),
+    signMessage: (args) => signMessage2(client, args),
+    signTransaction: (args) => signTransaction2(client, args),
+    signTypedData: (args) => signTypedData2(client, args),
+    switchChain: (args) => switchChain(client, args),
+    waitForCallsStatus: (args) => waitForCallsStatus(client, args),
+    watchAsset: (args) => watchAsset(client, args),
+    writeContract: (args) => writeContract(client, args),
+    writeContractSync: (args) => writeContractSync(client, args)
+  };
+}
+
+// ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/clients/createWalletClient.js
+function createWalletClient(parameters) {
+  const { key = "wallet", name = "Wallet Client", transport } = parameters;
+  const client = createClient({
+    ...parameters,
+    key,
+    name,
+    transport,
+    type: "walletClient"
+  });
+  return client.extend(walletActions);
+}
+
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/clients/transports/createTransport.js
 function createTransport({ key, methods, name, request, retryCount = 3, retryDelay = 150, timeout, type }, value) {
   const uid2 = uid();
@@ -48620,7 +49785,7 @@ async function sign2({ hash: hash4, privateKey, to = "object" }) {
 }
 
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/accounts/utils/signAuthorization.js
-async function signAuthorization2(parameters) {
+async function signAuthorization3(parameters) {
   const { chainId, nonce, privateKey, to = "object" } = parameters;
   const address = parameters.contractAddress ?? parameters.address;
   const signature = await sign2({
@@ -48639,13 +49804,13 @@ async function signAuthorization2(parameters) {
 }
 
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/accounts/utils/signMessage.js
-async function signMessage2({ message, privateKey }) {
+async function signMessage3({ message, privateKey }) {
   return await sign2({ hash: hashMessage2(message), privateKey, to: "hex" });
 }
 
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/accounts/utils/signTransaction.js
 init_keccak2562();
-async function signTransaction2(parameters) {
+async function signTransaction3(parameters) {
   const { privateKey, transaction, serializer = serializeTransaction2 } = parameters;
   const signableTransaction = (() => {
     if (transaction.type === "eip4844")
@@ -48663,7 +49828,7 @@ async function signTransaction2(parameters) {
 }
 
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/accounts/utils/signTypedData.js
-async function signTypedData2(parameters) {
+async function signTypedData3(parameters) {
   const { privateKey, ...typedData } = parameters;
   return await sign2({
     hash: hashTypedData2(typedData),
@@ -48684,16 +49849,16 @@ function privateKeyToAccount2(privateKey, options = {}) {
       return sign2({ hash: hash4, privateKey, to: "hex" });
     },
     async signAuthorization(authorization) {
-      return signAuthorization2({ ...authorization, privateKey });
+      return signAuthorization3({ ...authorization, privateKey });
     },
     async signMessage({ message }) {
-      return signMessage2({ message, privateKey });
+      return signMessage3({ message, privateKey });
     },
     async signTransaction(transaction, { serializer } = {}) {
-      return signTransaction2({ privateKey, transaction, serializer });
+      return signTransaction3({ privateKey, transaction, serializer });
     },
     async signTypedData(typedData) {
-      return signTypedData2({ ...typedData, privateKey });
+      return signTypedData3({ ...typedData, privateKey });
     }
   });
   return {
@@ -49386,8 +50551,8 @@ function startServer(sailDir, { port = PORT } = {}) {
     }
     res.json({ ok: true });
   });
-  app.post("/api/mandate-submit", (req, res) => {
-    const { signature, signedAt } = req.body ?? {};
+  app.post("/api/mandate-submit", async (req, res) => {
+    const { signature, signedAt, permissions: signedAddrs, deadline } = req.body ?? {};
     if (!signature) {
       res.status(400).json({ error: "missing signature" });
       return;
@@ -49399,17 +50564,57 @@ function startServer(sailDir, { port = PORT } = {}) {
       res.status(404).json({ error: "no mandate draft to submit" });
       return;
     }
+    const safe = draft.account;
+    const chainId = draft.chainId;
+    const draftPerms = draft.permissions ?? draft.items ?? [];
+    const permissionMeta = draftPerms.map((p) => ({
+      template: p.label ?? p.template ?? null,
+      address: p.address ?? p.template ?? null,
+      explanation: p.explanation ?? null
+    }));
+    const addrs = (Array.isArray(signedAddrs) && signedAddrs.length ? signedAddrs : permissionMeta.map((p) => p.address)).filter(Boolean).map((a) => getAddress(a));
+    let txHash = null;
+    try {
+      if (!deadline) throw new Error("missing deadline");
+      if (addrs.length === 0) throw new Error("no permissions to register");
+      const env = parseEnvFile(at(".env.local"));
+      const password = process.env.SAIL_PASSPHRASE || env.SAIL_PASSPHRASE;
+      if (!password) throw new Error("SAIL_PASSPHRASE not set \u2014 cannot unlock the agent key");
+      const rpcUrl = env.RPC_URL || env.BASE_SEPOLIA_RPC_URL;
+      if (!rpcUrl) throw new Error("RPC_URL not set in .sail/.env.local");
+      const deployment = getSailDeployment(Number(chainId));
+      if (!deployment?.kernel) throw new Error(`No SailKernel deployment for chain ${chainId}`);
+      const keyring = await LocalKeyring.fromKeystoreFile(at("keys/manager.json"), password);
+      const publicClient = createPublicClient({ transport: http(rpcUrl) });
+      let fee = 0n;
+      for (const a of addrs) fee += await estimatePermissionFee(publicClient, deployment.governance, a);
+      const chain2 = defineChain({
+        id: Number(chainId),
+        name: `chain-${chainId}`,
+        nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+        rpcUrls: { default: { http: [rpcUrl] } }
+      });
+      const walletClient = createWalletClient({ account: keyring.viemAccount, chain: chain2, transport: http(rpcUrl) });
+      const data = encodeFunctionData2({
+        abi: SailKernelAbi,
+        functionName: "registerPermissions",
+        args: [getAddress(safe), addrs, BigInt(deadline), signature]
+      });
+      txHash = await walletClient.sendTransaction({ to: deployment.kernel, data, value: fee, account: keyring.viemAccount, chain: chain2 });
+      const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+      if (receipt.status !== "success") throw new Error(`registerPermissions reverted (tx ${txHash})`);
+    } catch (err) {
+      res.status(500).json({ error: `On-chain registration failed: ${err?.message ?? String(err)}` });
+      return;
+    }
     const mandate = {
-      safe: draft.account,
-      chainId: draft.chainId,
+      safe,
+      chainId,
       signedAt: signedAt || (/* @__PURE__ */ new Date()).toISOString(),
       signature,
-      registeredOnChain: false,
-      permissions: (draft.items ?? []).map((it) => ({
-        template: it.template,
-        params: it.params,
-        explanation: it.explanation
-      }))
+      registeredOnChain: true,
+      txHash,
+      permissions: permissionMeta
     };
     try {
       import_node_fs2.default.mkdirSync(sailDir, { recursive: true });
@@ -49419,7 +50624,10 @@ function startServer(sailDir, { port = PORT } = {}) {
         existing = Array.isArray(raw) ? raw : [raw];
       } catch {
       }
-      import_node_fs2.default.writeFileSync(at("mandate.json"), `${JSON.stringify([...existing, mandate], null, 2)}
+      const deduped = existing.filter(
+        (m) => !(m.safe?.toLowerCase() === safe?.toLowerCase() && m.chainId === chainId)
+      );
+      import_node_fs2.default.writeFileSync(at("mandate.json"), `${JSON.stringify([...deduped, mandate], null, 2)}
 `);
       try {
         import_node_fs2.default.rmSync(at("mandate-draft.json"));