@vaultum/sdk 0.1.5

package/dist/index.mjs

@@ -0,0 +1,1982 @@
+// src/api.ts
+var e = encodeURIComponent;
+var API = {
+  op: {
+    submit: "/api/op/submit",
+    simulate: "/api/op/simulate",
+    capabilities: "/api/op/capabilities",
+    status: (id) => `/api/op/${e(id)}`,
+    wait: (id) => `/api/op/${e(id)}/wait`
+  },
+  auth: {
+    register: "/api/auth/register",
+    login: "/api/auth/login",
+    walletChallenge: "/api/auth/wallet/challenge",
+    walletVerify: "/api/auth/wallet/verify",
+    walletRegisterChallenge: "/api/auth/wallet/register/challenge",
+    walletRegisterVerify: "/api/auth/wallet/register/verify",
+    logout: "/api/auth/logout",
+    logoutAll: "/api/auth/logout-all",
+    me: "/api/auth/me",
+    walletLinkChallenge: "/api/auth/wallet/link/challenge",
+    walletLinkVerify: "/api/auth/wallet/link/verify",
+    wallets: "/api/auth/wallets"
+  },
+  accounts: {
+    create: "/api/accounts",
+    verify: "/api/accounts/verify",
+    operations: "/api/accounts/operations"
+  },
+  vault: {
+    state: (wallet) => `/api/vault/${e(wallet)}/state`,
+    features: (wallet) => `/api/vault/${e(wallet)}/features`,
+    feature: (wallet, featureId) => `/api/vault/${e(wallet)}/feature/${e(featureId)}`,
+    opNonce: (wallet) => `/api/vault/${e(wallet)}/op-nonce`,
+    securityCouncil: (wallet) => `/api/vault/${e(wallet)}/security-council`,
+    fallbackSigner: (wallet) => `/api/vault/${e(wallet)}/fallback-signer`,
+    paused: (wallet) => `/api/vault/${e(wallet)}/paused`,
+    l2Receiver: (wallet) => `/api/vault/${e(wallet)}/l2-receiver`,
+    tryExecute: "/api/vault/try-execute",
+    pause: "/api/vault/pause",
+    unpause: "/api/vault/unpause",
+    setSecurityCouncil: "/api/vault/security-council",
+    setFallbackSigner: "/api/vault/fallback-signer",
+    overrideGlobalPause: "/api/vault/override-global-pause"
+  },
+  sessionKey: {
+    grant: "/api/sessionkey/grant",
+    revoke: "/api/sessionkey/revoke",
+    revokeAll: "/api/sessionkey/revoke-all",
+    tokenLimits: "/api/sessionkey/token-limits",
+    maxValuePerCall: "/api/sessionkey/max-value-per-call",
+    sync: "/api/sessionkey/sync",
+    list: (wallet) => `/api/sessionkey/${e(wallet)}/list`,
+    info: (wallet, key) => `/api/sessionkey/${e(wallet)}/${e(key)}`,
+    count: (wallet) => `/api/sessionkey/${e(wallet)}/count`,
+    policySigner: (wallet) => `/api/sessionkey/${e(wallet)}/policy-signer`,
+    roles: (wallet, key) => `/api/sessionkey/${e(wallet)}/${e(key)}/roles`,
+    tokenLimit: (wallet, key, token) => `/api/sessionkey/${e(wallet)}/${e(key)}/token/${e(token)}/limit`
+  },
+  feature: {
+    enable: "/api/feature/enable",
+    disable: "/api/feature/disable",
+    reset: "/api/feature/reset",
+    spendingLimits: (wallet) => `/api/feature/spending-limits/${e(wallet)}`,
+    allowlist: (wallet) => `/api/feature/allowlist/${e(wallet)}`,
+    guardians: (wallet) => `/api/feature/guardians/${e(wallet)}`,
+    recovery: (wallet) => `/api/feature/recovery/${e(wallet)}`,
+    roles: (wallet) => `/api/feature/roles/${e(wallet)}`,
+    accountRoles: (wallet, account) => `/api/feature/roles/${e(wallet)}/${e(account)}`
+  },
+  spendingLimit: {
+    enable: "/api/spending-limit/enable",
+    disable: "/api/spending-limit/disable",
+    update: "/api/spending-limit/update",
+    enableToken: "/api/spending-limit/token/enable",
+    disableToken: "/api/spending-limit/token/disable",
+    updateToken: "/api/spending-limit/token/update",
+    setSpendValidator: "/api/spending-limit/validator/set",
+    status: (wallet) => `/api/spending-limit/${e(wallet)}/status`,
+    nativeSummaries: (wallet) => `/api/spending-limit/${e(wallet)}/native/summaries`,
+    tokenSummaries: (wallet, token) => `/api/spending-limit/${e(wallet)}/token/${e(token)}/summaries`,
+    preview: (wallet) => `/api/spending-limit/${e(wallet)}/preview`,
+    bucket: (wallet, windowStart) => `/api/spending-limit/${e(wallet)}/bucket/${windowStart}`,
+    nativeLimit: (wallet, window) => `/api/spending-limit/${e(wallet)}/native/${window}`,
+    nativeStatus: (wallet, window) => `/api/spending-limit/${e(wallet)}/native/${window}/status`,
+    tokenLimit: (wallet, token, window) => `/api/spending-limit/${e(wallet)}/token/${e(token)}/${window}`,
+    tokenStatus: (wallet, token, window) => `/api/spending-limit/${e(wallet)}/token/${e(token)}/${window}/status`
+  },
+  allowlist: {
+    enable: "/api/allowlist/enable",
+    disable: "/api/allowlist/disable",
+    contractOnly: "/api/allowlist/contract-only",
+    roots: "/api/allowlist/roots",
+    sync: "/api/allowlist/sync",
+    transferLimit: "/api/allowlist/transfer-limit",
+    actorPermissions: "/api/allowlist/actor/permissions",
+    getRoots: (wallet) => `/api/allowlist/${e(wallet)}/roots`,
+    getActorPermissions: (wallet, actor) => `/api/allowlist/${e(wallet)}/actor/${e(actor)}/permissions`,
+    tokenMaxTransfer: (wallet, token) => `/api/allowlist/${e(wallet)}/token/${e(token)}/max-transfer`
+  },
+  guardians: {
+    configure: "/api/guardians/configure"
+  },
+  recovery: {
+    initiate: "/api/recovery/initiate",
+    support: "/api/recovery/support",
+    execute: "/api/recovery/execute",
+    cancel: "/api/recovery/cancel",
+    status: (wallet) => `/api/recovery/${e(wallet)}/status`,
+    guardians: (wallet) => `/api/recovery/${e(wallet)}/guardians`,
+    proposal: (wallet) => `/api/recovery/${e(wallet)}/proposal`,
+    proposalState: (wallet) => `/api/recovery/${e(wallet)}/proposal-state`,
+    guardianApproved: (wallet, guardian) => `/api/recovery/${e(wallet)}/guardian/${e(guardian)}/approved`,
+    isGuardian: (wallet, guardian) => `/api/recovery/${e(wallet)}/guardian/${e(guardian)}`
+  },
+  recoveryAggregated: {
+    initiate: "/api/recovery/aggregated/initiate",
+    signature: "/api/recovery/aggregated/signature",
+    status: (wallet, proposedOwner) => `/api/recovery/aggregated/status/${e(wallet)}/${e(proposedOwner)}`,
+    prepare: "/api/recovery/aggregated/prepare"
+  },
+  roles: {
+    create: "/api/roles/create",
+    createBatch: "/api/roles/create-batch",
+    grant: "/api/roles/grant",
+    revoke: "/api/roles/revoke",
+    grantBatch: "/api/roles/grant-batch",
+    revokeBatch: "/api/roles/revoke-batch",
+    update: "/api/roles/update",
+    grantMulti: "/api/roles/grant-multi",
+    arm: "/api/roles/arm",
+    armed: (wallet) => `/api/roles/${e(wallet)}/armed`,
+    targetIndex: (wallet, target) => `/api/roles/${e(wallet)}/target/${e(target)}/index`,
+    selectorIndex: (wallet, selector) => `/api/roles/${e(wallet)}/selector/${e(selector)}/index`,
+    hasRole: (wallet, account, roleId) => `/api/roles/${e(wallet)}/${e(account)}/has-role/${e(roleId)}`,
+    budget: (wallet, roleId) => `/api/roles/${e(wallet)}/${e(roleId)}/budget`,
+    setBudget: (wallet, roleId) => `/api/roles/${e(wallet)}/${e(roleId)}/budget`,
+    show: (wallet, roleId) => `/api/roles/${e(wallet)}/${e(roleId)}`
+  },
+  proposals: {
+    list: "/api/proposals",
+    due: "/api/proposals/due",
+    create: "/api/proposals",
+    show: (id) => `/api/proposals/${e(id)}`,
+    digest: (id) => `/api/proposals/${e(id)}/digest`,
+    sign: (id) => `/api/proposals/${e(id)}/sign`,
+    finalize: (id) => `/api/proposals/${e(id)}/finalize`,
+    cancel: (id) => `/api/proposals/${e(id)}/cancel`
+  },
+  crosschain: {
+    config: (wallet) => `/api/crosschain/${e(wallet)}/config`,
+    pendingProposals: (wallet) => `/api/crosschain/${e(wallet)}/pending-proposals`,
+    receiverStateFresh: (wallet) => `/api/crosschain/l2-receiver/${e(wallet)}/state-fresh`,
+    receiverSkipProposal: (wallet) => `/api/crosschain/l2-receiver/${e(wallet)}/skip-proposal`,
+    gasLimit: (chainId) => `/api/crosschain/gas-limits/${chainId}`,
+    proposeOwnerUpdate: "/api/crosschain/propose-owner-update",
+    executeOwnerUpdate: "/api/crosschain/execute-owner-update",
+    resync: "/api/crosschain/resync"
+  },
+  settlement: {
+    tokens: "/api/settlement/tokens",
+    quote: "/api/settlement/quote",
+    prepare: "/api/settlement/prepare"
+  },
+  swap: {
+    quote: "/api/swap/quote",
+    build: "/api/swap/build"
+  },
+  addressBook: {
+    list: "/api/address-book",
+    create: "/api/address-book",
+    update: (id) => `/api/address-book/${id}`,
+    delete: (id) => `/api/address-book/${id}`
+  },
+  automations: {
+    list: "/api/automations",
+    create: "/api/automations",
+    show: (id) => `/api/automations/${e(id)}`,
+    update: (id) => `/api/automations/${e(id)}`,
+    delete: (id) => `/api/automations/${e(id)}`,
+    pause: (id) => `/api/automations/${e(id)}/pause`,
+    resume: (id) => `/api/automations/${e(id)}/resume`,
+    trigger: (id) => `/api/automations/${e(id)}/trigger`
+  },
+  addresses: {
+    capabilities: "/api/addresses/capabilities",
+    all: (chainId) => `/api/addresses/${chainId}`,
+    get: (chainId, name) => `/api/addresses/${chainId}/${e(name)}`
+  },
+  signature: {
+    timing: "/api/signature/timing",
+    userOpTemplate: "/api/signature/userop-template",
+    eip712Template: "/api/signature/eip712-template",
+    validateTimestamp: "/api/signature/validate-timestamp"
+  },
+  registry: {
+    features: "/api/registry/features",
+    version: "/api/registry/version",
+    isInternal: (featureId) => `/api/registry/feature/${e(featureId)}/internal`,
+    canValidatorHandleSelector: (validatorId, selector) => `/api/registry/validator/${e(validatorId)}/selector/${e(selector)}/permitted`,
+    coreModuleId: (key) => `/api/registry/core-module-id/${e(key)}`,
+    slotAccess: (featureId, slot) => `/api/registry/slot-access/${e(featureId)}/${e(slot)}`,
+    supportsMigration: (featureId) => `/api/registry/supports-migration/${e(featureId)}`,
+    isFeatureImplementation: (impl) => `/api/registry/is-feature-implementation/${e(impl)}`,
+    featureImplementation: (featureId) => `/api/registry/feature-implementation/${e(featureId)}`,
+    featureImplementationForWallet: (wallet, featureId) => `/api/registry/feature-implementation-for-wallet/${e(wallet)}/${e(featureId)}`,
+    isMandatoryFeature: (featureId) => `/api/registry/is-mandatory/${e(featureId)}`,
+    ecdsaModule: "/api/registry/ecdsa-module",
+    sessionKeyManager: "/api/registry/session-key-manager",
+    spendingLimitManager: "/api/registry/spending-limit-manager",
+    permissionsManager: "/api/registry/permissions-manager",
+    globallyPaused: (wallet) => `/api/registry/${e(wallet)}/globally-paused`,
+    canaryOptIn: (wallet) => `/api/registry/${e(wallet)}/canary-opt-in`,
+    capabilitySnapshot: (wallet) => `/api/registry/${e(wallet)}/capability-snapshot`,
+    mandatoryInitData: (wallet, featureId) => `/api/registry/${e(wallet)}/mandatory-init-data/${e(featureId)}`,
+    setCanaryOptIn: "/api/registry/canary/opt-in",
+    setMandatoryInitData: "/api/registry/mandatory-init-data",
+    updateCapabilitySnapshot: "/api/registry/capability-snapshot"
+  },
+  paymaster: {
+    banStatus: (account) => `/api/paymaster/ban-status/${e(account)}`,
+    refundCredit: (wallet, token) => `/api/paymaster/refund-credit/${e(wallet)}/${e(token)}`,
+    claimRefundCredit: "/api/paymaster/refund-credit/claim"
+  },
+  config: {
+    gasLimits: "/api/config/gas-limits"
+  },
+  relay: {
+    estimate: "/api/relay/estimate",
+    preview: "/api/relay/preview"
+  },
+  health: "/api/health"
+};
+function parseQuoteResponse(raw) {
+  return {
+    gasLimits: {
+      verificationGasLimit: BigInt(raw.gasLimits.verificationGasLimit),
+      callGasLimit: BigInt(raw.gasLimits.callGasLimit),
+      preVerificationGas: BigInt(raw.gasLimits.preVerificationGas),
+      maxFeePerGas: BigInt(raw.gasLimits.maxFeePerGas),
+      maxPriorityFeePerGas: BigInt(raw.gasLimits.maxPriorityFeePerGas)
+    },
+    paymasterAndData: raw.paymasterAndData,
+    sponsored: raw.sponsored
+  };
+}
+
+// src/userOpBuilder.ts
+import {
+  encodeAbiParameters,
+  encodeFunctionData,
+  parseAbiParameters,
+  keccak256 as keccak2562,
+  toBytes,
+  concat,
+  pad,
+  toHex as toHex2
+} from "viem";
+
+// src/constants.ts
+import { keccak256, toHex } from "viem";
+var ENTRYPOINT_V07 = "0x0000000071727De22E5E9d8BAf0edAc6f37da032";
+var FEATURE_ID_STRINGS = {
+  MODULE_ECDSA_VALIDATION: "module.validation.ecdsa",
+  MODULE_SESSION_KEY_VALIDATION: "module.validation.session_key",
+  FEATURE_SESSION_KEYS: "feature.session_keys",
+  FEATURE_SPENDING_LIMIT: "feature.spending_limit",
+  FEATURE_APPROVAL_LIMIT: "feature.approval_limit",
+  FEATURE_PERMISSIONS: "feature.permissions",
+  FEATURE_SOCIAL_RECOVERY: "feature.social_recovery",
+  FEATURE_PAYMASTER_GUARD: "feature.paymaster_guard"
+};
+var FEATURE_IDS = {
+  MODULE_ECDSA_VALIDATION: keccak256(toHex("module.validation.ecdsa")),
+  MODULE_SESSION_KEY_VALIDATION: keccak256(toHex("module.validation.session_key")),
+  FEATURE_SESSION_KEYS: keccak256(toHex("feature.session_keys")),
+  FEATURE_SPENDING_LIMIT: keccak256(toHex("feature.spending_limit")),
+  FEATURE_APPROVAL_LIMIT: keccak256(toHex("feature.approval_limit")),
+  FEATURE_PERMISSIONS: keccak256(toHex("feature.permissions")),
+  FEATURE_SOCIAL_RECOVERY: keccak256(toHex("feature.social_recovery")),
+  FEATURE_PAYMASTER_GUARD: keccak256(toHex("feature.paymaster_guard"))
+};
+var CONTRACTS = {
+  VAULTUM_CORE: "VaultumCore",
+  VAULTUM_FACTORY: "VaultumAccountFactory",
+  FEATURE_REGISTRY: "FeatureRegistry",
+  IMPLEMENTATION_REGISTRY: "ImplementationRegistry",
+  SESSION_KEY_MANAGER: "SessionKeyManager",
+  SPENDING_LIMIT_MANAGER: "SpendingLimitManager",
+  PERMISSIONS_MANAGER: "PermissionsManager",
+  SOCIAL_RECOVERY_MANAGER: "SocialRecoveryManager",
+  PAYMASTER_GUARD: "PaymasterGuard",
+  ECDSA_VALIDATION_MODULE: "ECDSAValidationModuleSingleton",
+  SESSION_KEY_VALIDATION_MODULE: "SessionKeyValidationModuleSingleton",
+  VAULTUM_SETTLEMENT_PAYMASTER: "VaultumSettlementPaymaster"
+};
+
+// src/userOpBuilder.ts
+function packGasLimits(verificationGasLimit, callGasLimit) {
+  return concat([
+    pad(toHex2(verificationGasLimit), { size: 16 }),
+    pad(toHex2(callGasLimit), { size: 16 })
+  ]);
+}
+function unpackGasLimits(packed) {
+  const bytes = toBytes(packed);
+  return {
+    verificationGasLimit: BigInt(toHex2(bytes.slice(0, 16))),
+    callGasLimit: BigInt(toHex2(bytes.slice(16, 32)))
+  };
+}
+function packGasFees(maxPriorityFeePerGas, maxFeePerGas) {
+  return concat([
+    pad(toHex2(maxPriorityFeePerGas), { size: 16 }),
+    pad(toHex2(maxFeePerGas), { size: 16 })
+  ]);
+}
+function unpackGasFees(packed) {
+  const bytes = toBytes(packed);
+  return {
+    maxPriorityFeePerGas: BigInt(toHex2(bytes.slice(0, 16))),
+    maxFeePerGas: BigInt(toHex2(bytes.slice(16, 32)))
+  };
+}
+function getUserOpHash(userOp, entryPoint, chainId) {
+  const packed = encodeAbiParameters(
+    parseAbiParameters("address, uint256, bytes32, bytes32, bytes32, uint256, bytes32, bytes32"),
+    [
+      userOp.sender,
+      userOp.nonce,
+      keccak2562(userOp.initCode),
+      keccak2562(userOp.callData),
+      userOp.accountGasLimits,
+      userOp.preVerificationGas,
+      userOp.gasFees,
+      keccak2562(userOp.paymasterAndData)
+    ]
+  );
+  return keccak2562(
+    encodeAbiParameters(
+      parseAbiParameters("bytes32, address, uint256"),
+      [keccak2562(packed), entryPoint, BigInt(chainId)]
+    )
+  );
+}
+var EXECUTE_ABI = [{
+  name: "execute",
+  type: "function",
+  inputs: [
+    { name: "target", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "data", type: "bytes" }
+  ],
+  outputs: []
+}];
+var EXECUTE_BATCH_ABI = [{
+  name: "executeBatch",
+  type: "function",
+  inputs: [{
+    name: "calls",
+    type: "tuple[]",
+    components: [
+      { name: "to", type: "address" },
+      { name: "value", type: "uint256" },
+      { name: "data", type: "bytes" }
+    ]
+  }],
+  outputs: []
+}];
+var ENABLE_FEATURE_ABI = [{
+  name: "enableFeature",
+  type: "function",
+  inputs: [
+    { name: "featureId", type: "bytes32" },
+    { name: "initData", type: "bytes" }
+  ],
+  outputs: []
+}];
+var DISABLE_FEATURE_ABI = [{
+  name: "disableFeature",
+  type: "function",
+  inputs: [{ name: "featureId", type: "bytes32" }],
+  outputs: []
+}];
+var UserOpBuilder = class {
+  account;
+  chainId;
+  entryPoint;
+  constructor(config) {
+    this.account = config.account;
+    this.chainId = config.chainId;
+    this.entryPoint = config.entryPoint ?? ENTRYPOINT_V07;
+  }
+  create(callData, nonce) {
+    return {
+      sender: this.account,
+      nonce,
+      initCode: "0x",
+      callData,
+      accountGasLimits: "0x" + "0".repeat(64),
+      preVerificationGas: 0n,
+      gasFees: "0x" + "0".repeat(64),
+      paymasterAndData: "0x",
+      signature: "0x"
+    };
+  }
+  encodeExecute(call) {
+    return encodeFunctionData({
+      abi: EXECUTE_ABI,
+      functionName: "execute",
+      args: [call.target, call.value, call.data]
+    });
+  }
+  encodeExecuteBatch(calls) {
+    return encodeFunctionData({
+      abi: EXECUTE_BATCH_ABI,
+      functionName: "executeBatch",
+      args: [calls.map((c) => ({ to: c.target, value: c.value, data: c.data }))]
+    });
+  }
+  encodeEnableFeature(featureId, initData) {
+    return encodeFunctionData({
+      abi: ENABLE_FEATURE_ABI,
+      functionName: "enableFeature",
+      args: [featureId, initData]
+    });
+  }
+  encodeDisableFeature(featureId) {
+    return encodeFunctionData({
+      abi: DISABLE_FEATURE_ABI,
+      functionName: "disableFeature",
+      args: [featureId]
+    });
+  }
+  buildExecute(call, nonce) {
+    return this.create(this.encodeExecute(call), nonce);
+  }
+  buildExecuteBatch(calls, nonce) {
+    return this.create(this.encodeExecuteBatch(calls), nonce);
+  }
+  buildEnableFeature(featureId, initData, nonce) {
+    return this.create(this.encodeEnableFeature(featureId, initData), nonce);
+  }
+  buildDisableFeature(featureId, nonce) {
+    return this.create(this.encodeDisableFeature(featureId), nonce);
+  }
+  withGas(userOp, gas) {
+    const currentLimits = unpackGasLimits(userOp.accountGasLimits);
+    const currentFees = unpackGasFees(userOp.gasFees);
+    return {
+      ...userOp,
+      accountGasLimits: packGasLimits(
+        gas.verificationGasLimit ?? currentLimits.verificationGasLimit,
+        gas.callGasLimit ?? currentLimits.callGasLimit
+      ),
+      preVerificationGas: gas.preVerificationGas ?? userOp.preVerificationGas,
+      gasFees: packGasFees(
+        gas.maxPriorityFeePerGas ?? currentFees.maxPriorityFeePerGas,
+        gas.maxFeePerGas ?? currentFees.maxFeePerGas
+      )
+    };
+  }
+  withPaymaster(userOp, paymasterAndData) {
+    return { ...userOp, paymasterAndData };
+  }
+  withSignature(userOp, signature) {
+    return { ...userOp, signature };
+  }
+  getHash(userOp) {
+    return getUserOpHash(userOp, this.entryPoint, this.chainId);
+  }
+};
+function createUserOpBuilder(config) {
+  return new UserOpBuilder(config);
+}
+
+// src/client.ts
+var DEFAULT_RETRY = {
+  maxAttempts: 3,
+  baseDelayMs: 200,
+  maxDelayMs: 5e3
+};
+function computeBackoff(attempt, base, max) {
+  const delay = base * Math.pow(2, attempt) + Math.random() * 100;
+  return Math.min(delay, max);
+}
+var RETRYABLE_CODES = /* @__PURE__ */ new Set([
+  "RATE_LIMITED",
+  "BUNDLER_ERROR",
+  "TIMEOUT"
+]);
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([408, 425, 429, 500, 502, 503, 504]);
+var VaultumError = class extends Error {
+  constructor(message, code, status, details, retryable = false) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.details = details;
+    this.retryable = retryable;
+    this.name = "VaultumError";
+  }
+};
+function serializeBody(body) {
+  return JSON.stringify(
+    body,
+    (_, value) => typeof value === "bigint" ? `0x${value.toString(16)}` : value
+  );
+}
+function nowUnix() {
+  return Math.floor(Date.now() / 1e3);
+}
+function fnv1a64Hex(input) {
+  let hash = 0xcbf29ce484222325n;
+  const prime = 0x100000001b3n;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= BigInt(input.charCodeAt(i));
+    hash = hash * prime & 0xffffffffffffffffn;
+  }
+  return hash.toString(16).padStart(16, "0");
+}
+function autoIdempotencyKey(body) {
+  return `v1_${fnv1a64Hex(serializeBody(body))}`;
+}
+function bigintToHex(value) {
+  return `0x${value.toString(16)}`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isUserOperation(value) {
+  if (!isRecord(value)) return false;
+  return typeof value.sender === "string" && typeof value.nonce === "string" && typeof value.initCode === "string" && typeof value.callData === "string" && typeof value.callGasLimit === "string" && typeof value.verificationGasLimit === "string" && typeof value.preVerificationGas === "string" && typeof value.maxFeePerGas === "string" && typeof value.maxPriorityFeePerGas === "string" && typeof value.paymasterAndData === "string" && typeof value.signature === "string";
+}
+function isPackedUserOp(value) {
+  if (!isRecord(value)) return false;
+  return typeof value.sender === "string" && typeof value.nonce === "bigint" && typeof value.initCode === "string" && typeof value.callData === "string" && typeof value.accountGasLimits === "string" && typeof value.preVerificationGas === "bigint" && typeof value.gasFees === "string" && typeof value.paymasterAndData === "string" && typeof value.signature === "string";
+}
+function normalizeUserOperation(userOp) {
+  return {
+    sender: userOp.sender.toLowerCase(),
+    nonce: userOp.nonce.toLowerCase(),
+    initCode: userOp.initCode.toLowerCase(),
+    callData: userOp.callData.toLowerCase(),
+    callGasLimit: userOp.callGasLimit.toLowerCase(),
+    verificationGasLimit: userOp.verificationGasLimit.toLowerCase(),
+    preVerificationGas: userOp.preVerificationGas.toLowerCase(),
+    maxFeePerGas: userOp.maxFeePerGas.toLowerCase(),
+    maxPriorityFeePerGas: userOp.maxPriorityFeePerGas.toLowerCase(),
+    paymasterAndData: userOp.paymasterAndData.toLowerCase(),
+    signature: userOp.signature.toLowerCase()
+  };
+}
+function packedToUserOperation(userOp) {
+  const limits = unpackGasLimits(userOp.accountGasLimits);
+  const fees = unpackGasFees(userOp.gasFees);
+  return normalizeUserOperation({
+    sender: userOp.sender,
+    nonce: bigintToHex(userOp.nonce),
+    initCode: userOp.initCode,
+    callData: userOp.callData,
+    callGasLimit: bigintToHex(limits.callGasLimit),
+    verificationGasLimit: bigintToHex(limits.verificationGasLimit),
+    preVerificationGas: bigintToHex(userOp.preVerificationGas),
+    maxFeePerGas: bigintToHex(fees.maxFeePerGas),
+    maxPriorityFeePerGas: bigintToHex(fees.maxPriorityFeePerGas),
+    paymasterAndData: userOp.paymasterAndData,
+    signature: userOp.signature
+  });
+}
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+function asString(value) {
+  return typeof value === "string" ? value : null;
+}
+function asNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value !== "" && /^[0-9]+$/.test(value)) {
+    const n = Number(value);
+    return Number.isFinite(n) ? n : null;
+  }
+  return null;
+}
+function asAddress(value) {
+  const s = asString(value);
+  if (!s) return null;
+  const v = s.toLowerCase();
+  return /^0x[a-f0-9]{40}$/.test(v) ? v : null;
+}
+function asHex(value) {
+  const s = asString(value);
+  if (!s) return null;
+  const v = s.toLowerCase();
+  return /^0x[a-f0-9]*$/.test(v) ? v : null;
+}
+function isAutomationType(value) {
+  return value === "recurring_payment" || value === "stop_loss" || value === "dca" || value === "rebalance";
+}
+function isAutomationStatus(value) {
+  return value === "active" || value === "paused" || value === "completed" || value === "failed";
+}
+function isAutomationExecutionStatus(value) {
+  return value === "pending" || value === "success" || value === "failed";
+}
+function mapAutomation(raw) {
+  const obj = isRecord(raw) ? raw : {};
+  return {
+    id: asString(obj.id) ?? "",
+    wallet: asAddress(obj.wallet) ?? ZERO_ADDRESS,
+    type: isAutomationType(obj.type) ? obj.type : "recurring_payment",
+    status: isAutomationStatus(obj.status) ? obj.status : "active",
+    sessionKey: asAddress(obj.session_key),
+    config: isRecord(obj.config) ? obj.config : {},
+    executionCount: asNumber(obj.execution_count) ?? 0,
+    failureCount: asNumber(obj.failure_count) ?? 0,
+    lastExecutedAt: asString(obj.last_executed_at),
+    nextExecutionAt: asString(obj.next_execution_at),
+    lastTxHash: asHex(obj.last_tx_hash),
+    lastError: asString(obj.last_error),
+    createdAt: asString(obj.created_at) ?? "",
+    updatedAt: asString(obj.updated_at) ?? ""
+  };
+}
+function mapAutomationExecution(raw) {
+  const obj = isRecord(raw) ? raw : {};
+  return {
+    id: asString(obj.id) ?? "",
+    status: isAutomationExecutionStatus(obj.status) ? obj.status : "pending",
+    txHash: asHex(obj.tx_hash),
+    error: asString(obj.error),
+    gasUsed: asString(obj.gas_used) ?? (typeof obj.gas_used === "number" ? String(obj.gas_used) : null),
+    createdAt: asString(obj.created_at) ?? ""
+  };
+}
+var VaultumClient = class {
+  baseURL;
+  headers;
+  timeout;
+  chain;
+  retry;
+  onRequest;
+  onResponse;
+  constructor(config) {
+    this.baseURL = normalizeURL(config.baseURL, Boolean(config.apiKey || config.bearer));
+    this.timeout = config.timeout ?? 3e4;
+    this.chain = config.chain;
+    this.headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    };
+    if (config.apiKey) this.headers["X-API-Key"] = config.apiKey;
+    if (config.bearer) this.headers["Authorization"] = `Bearer ${config.bearer}`;
+    this.retry = config.retry === false ? null : { ...DEFAULT_RETRY, ...typeof config.retry === "object" ? config.retry : {} };
+    this.onRequest = config.onRequest;
+    this.onResponse = config.onResponse;
+  }
+  setBearer(token) {
+    const t = typeof token === "string" ? token.trim() : "";
+    if (t === "") {
+      delete this.headers["Authorization"];
+      return;
+    }
+    this.headers["Authorization"] = `Bearer ${t}`;
+  }
+  setApiKey(key) {
+    const t = typeof key === "string" ? key.trim() : "";
+    if (t === "") {
+      delete this.headers["X-API-Key"];
+      return;
+    }
+    this.headers["X-API-Key"] = t;
+  }
+  setDefaultChain(chain) {
+    const t = typeof chain === "string" ? chain.trim() : "";
+    this.chain = t === "" ? void 0 : t;
+  }
+  async request(method, path, body, options) {
+    const maxAttempts = options?.retry !== false && this.retry ? this.retry.maxAttempts : 1;
+    let lastError;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), this.timeout);
+      const signal = options?.signal ? anySignal([options.signal, controller.signal]) : controller.signal;
+      try {
+        let ctx = {
+          method,
+          path,
+          headers: { ...this.headers, ...options?.headers || {} },
+          body
+        };
+        if (options?.idempotencyKey) ctx.headers["Idempotency-Key"] = options.idempotencyKey;
+        if (typeof options?.timestamp === "number") ctx.headers["X-Vaultum-Timestamp"] = String(options.timestamp);
+        if (this.onRequest) ctx = await this.onRequest(ctx);
+        const res = await fetch(`${this.baseURL}${ctx.path}`, {
+          method: ctx.method,
+          headers: ctx.headers,
+          body: ctx.body ? serializeBody(ctx.body) : void 0,
+          signal
+        });
+        clearTimeout(timer);
+        const data = await res.json().catch(() => ({}));
+        if (!res.ok) {
+          const errBody = data;
+          const code = mapErrorCode(errBody.code ?? errBody.error, res.status);
+          throw new VaultumError(
+            errBody.message ?? errBody.error ?? `Request failed: ${res.status}`,
+            code,
+            res.status,
+            errBody.details,
+            RETRYABLE_CODES.has(code) || RETRYABLE_STATUS.has(res.status)
+          );
+        }
+        let responseCtx = { status: res.status, headers: res.headers, data };
+        if (this.onResponse) responseCtx = await this.onResponse(responseCtx);
+        return responseCtx.data;
+      } catch (err) {
+        clearTimeout(timer);
+        if (err instanceof VaultumError) {
+          lastError = err;
+          if (err.retryable && attempt < maxAttempts - 1 && this.retry) {
+            await sleep(computeBackoff(attempt, this.retry.baseDelayMs, this.retry.maxDelayMs), options?.signal);
+            continue;
+          }
+          throw err;
+        }
+        if (err instanceof Error && err.name === "AbortError") {
+          throw new VaultumError("Request aborted", "TIMEOUT", void 0, void 0, true);
+        }
+        const networkError = new VaultumError(err instanceof Error ? err.message : "Unknown error", void 0, void 0, void 0, true);
+        lastError = networkError;
+        if (attempt < maxAttempts - 1 && this.retry) {
+          await sleep(computeBackoff(attempt, this.retry.baseDelayMs, this.retry.maxDelayMs), options?.signal);
+          continue;
+        }
+        throw networkError;
+      }
+    }
+    throw lastError ?? new VaultumError("Request failed after retries");
+  }
+  async submit(userOp, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    const normalized = isPackedUserOp(userOp) ? packedToUserOperation(userOp) : normalizeUserOperation(userOp);
+    const body = { chain, userOp: normalized };
+    const idempotencyKey = options?.idempotencyKey ?? autoIdempotencyKey(body);
+    const timestamp = options?.timestamp ?? nowUnix();
+    return this.request("POST", API.op.submit, body, {
+      idempotencyKey,
+      timestamp,
+      signal: options?.signal
+    });
+  }
+  async simulate(userOp, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    const normalized = isPackedUserOp(userOp) ? packedToUserOperation(userOp) : normalizeUserOperation(userOp);
+    return this.request("POST", API.op.simulate, { chain, userOp: normalized }, { signal: options?.signal });
+  }
+  async authRegister(params) {
+    const r = await this.request("POST", API.auth.register, params, { signal: params.signal });
+    this.setBearer(r.token);
+    return r;
+  }
+  async authLogin(params) {
+    const r = await this.request("POST", API.auth.login, params, { signal: params.signal });
+    this.setBearer(r.token);
+    return r;
+  }
+  async authMe(signal) {
+    return this.request("GET", API.auth.me, void 0, { signal });
+  }
+  async authLogout(signal) {
+    const r = await this.request("POST", API.auth.logout, void 0, { signal });
+    this.setBearer(null);
+    return r;
+  }
+  async authLogoutAll(signal) {
+    const r = await this.request("POST", API.auth.logoutAll, void 0, { signal });
+    this.setBearer(null);
+    return r;
+  }
+  async walletChallenge(params) {
+    return this.request("POST", API.auth.walletChallenge, {
+      chain: params.chain,
+      address: params.address.toLowerCase()
+    }, { signal: params.signal });
+  }
+  async walletVerify(params) {
+    const r = await this.request("POST", API.auth.walletVerify, {
+      chain: params.chain,
+      address: params.address.toLowerCase(),
+      signature: params.signature.toLowerCase()
+    }, { signal: params.signal });
+    this.setBearer(r.token);
+    return r;
+  }
+  async walletRegisterChallenge(params) {
+    return this.request("POST", API.auth.walletRegisterChallenge, {
+      chain: params.chain,
+      address: params.address.toLowerCase()
+    }, { signal: params.signal });
+  }
+  async walletRegisterVerify(params) {
+    const r = await this.request("POST", API.auth.walletRegisterVerify, {
+      chain: params.chain,
+      address: params.address.toLowerCase(),
+      signature: params.signature.toLowerCase(),
+      name: params.name,
+      email: params.email
+    }, { signal: params.signal });
+    this.setBearer(r.token);
+    return r;
+  }
+  async walletLinkChallenge(params) {
+    return this.request("POST", API.auth.walletLinkChallenge, {
+      chain: params.chain,
+      address: params.address.toLowerCase()
+    }, { signal: params.signal });
+  }
+  async walletLinkVerify(params) {
+    const raw = await this.request(
+      "POST",
+      API.auth.walletLinkVerify,
+      {
+        chain: params.chain,
+        address: params.address.toLowerCase(),
+        signature: params.signature.toLowerCase()
+      },
+      { signal: params.signal }
+    );
+    return {
+      wallets: (raw.wallets || []).map((w) => ({
+        address: w.address.toLowerCase(),
+        chainId: w.chain_id,
+        type: w.type
+      }))
+    };
+  }
+  async wallets(signal) {
+    const raw = await this.request(
+      "GET",
+      API.auth.wallets,
+      void 0,
+      { signal }
+    );
+    return {
+      wallets: (raw.wallets || []).map((w) => ({
+        address: w.address.toLowerCase(),
+        chainId: w.chain_id,
+        type: w.type
+      }))
+    };
+  }
+  async getOperation(id, signal) {
+    return this.request("GET", API.op.status(id), void 0, { signal });
+  }
+  async waitForOperation(id, options) {
+    const timeout = options?.timeout ?? 12e4;
+    const interval = options?.interval ?? 2e3;
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+      if (options?.signal?.aborted) {
+        throw new VaultumError("Operation cancelled", "TIMEOUT");
+      }
+      const result = await this.getOperation(id, options?.signal);
+      options?.onProgress?.(result);
+      if (result.state === "success" || result.state === "failed") return result;
+      await sleep(interval, options?.signal);
+    }
+    throw new VaultumError("Operation timeout", "TIMEOUT");
+  }
+  async getCapabilities(signal) {
+    return this.request("GET", API.op.capabilities, void 0, { signal });
+  }
+  async createAccount(options) {
+    return this.request("POST", API.accounts.create, {
+      sessionKeyAddress: options.sessionKeyAddress.toLowerCase(),
+      type: "create",
+      chain: options.chain ?? this.chain,
+      salt: options.salt,
+      owners: options.owners?.map((a) => a.toLowerCase()),
+      threshold: options.threshold,
+      securityCouncil: options.securityCouncil?.toLowerCase(),
+      modules: options.modules?.map((a) => a.toLowerCase()),
+      featureInits: options.featureInits?.map((f) => ({
+        featureId: f.featureId.toLowerCase(),
+        initData: f.initData?.toLowerCase()
+      }))
+    }, { signal: options.signal });
+  }
+  async verifyAccount(address, options) {
+    return this.request("POST", API.accounts.verify, {
+      address: address.toLowerCase(),
+      chain: options?.chain ?? this.chain
+    }, { signal: options?.signal });
+  }
+  async getVaultState(wallet, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.vault.state(wallet)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getNonce(wallet, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    const result = await this.request(
+      "GET",
+      `${API.vault.opNonce(wallet)}?chain=${chain}`,
+      void 0,
+      { signal: options?.signal }
+    );
+    return result.nonce;
+  }
+  async getBanStatus(account, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.paymaster.banStatus(account)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getRefundCredit(wallet, token, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.paymaster.refundCredit(wallet, token)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async buildClaimRefundCredit(params) {
+    return this.request("POST", API.paymaster.claimRefundCredit, {
+      wallet: params.wallet.toLowerCase(),
+      token: params.token.toLowerCase(),
+      chain: params.chain
+    }, { signal: params.signal });
+  }
+  async getSessionKeyInfo(wallet, key, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.sessionKey.info(wallet, key)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getSpendingLimitStatus(wallet, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.spendingLimit.status(wallet)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getAllowlistStatus(wallet, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.feature.allowlist(wallet)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getGuardians(wallet, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.feature.guardians(wallet)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getRecoveryStatus(wallet, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.feature.recovery(wallet)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getRecoveryStatusHint(account, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.recovery.status(account)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async initiateAggregatedRecovery(params) {
+    return this.request("POST", API.recoveryAggregated.initiate, {
+      wallet: params.wallet.toLowerCase(),
+      proposedOwner: params.proposedOwner.toLowerCase(),
+      chain: params.chain,
+      validUntil: params.validUntil
+    }, { signal: params.signal });
+  }
+  async submitRecoverySignature(params) {
+    return this.request("POST", API.recoveryAggregated.signature, {
+      wallet: params.wallet.toLowerCase(),
+      proposedOwner: params.proposedOwner.toLowerCase(),
+      guardian: params.guardian.toLowerCase(),
+      signature: params.signature,
+      chain: params.chain
+    }, { signal: params.signal });
+  }
+  async getAggregatedRecoveryStatus(wallet, proposedOwner, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.recoveryAggregated.status(wallet, proposedOwner)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async prepareAggregatedRecovery(params) {
+    return this.request("POST", API.recoveryAggregated.prepare, {
+      wallet: params.wallet.toLowerCase(),
+      proposedOwner: params.proposedOwner.toLowerCase(),
+      chain: params.chain
+    }, { signal: params.signal });
+  }
+  async getProposals(options) {
+    const params = new URLSearchParams();
+    if (options?.wallet) params.set("wallet", options.wallet.toLowerCase());
+    if (options?.status) params.set("status", options.status);
+    if (typeof options?.limit === "number") params.set("limit", String(options.limit));
+    if (options?.cursor) params.set("cursor", options.cursor);
+    const query = params.toString();
+    return this.request("GET", `${API.proposals.list}${query ? `?${query}` : ""}`, void 0, { signal: options?.signal });
+  }
+  async getDueProposals(options) {
+    const params = new URLSearchParams();
+    if (typeof options?.limit === "number") params.set("limit", String(options.limit));
+    if (options?.cursor) params.set("cursor", options.cursor);
+    const query = params.toString();
+    return this.request("GET", `${API.proposals.due}${query ? `?${query}` : ""}`, void 0, { signal: options?.signal });
+  }
+  async createProposal(params) {
+    return this.request("POST", API.proposals.create, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      calls: params.calls,
+      executeAfter: params.executeAfter,
+      executeBefore: params.executeBefore
+    }, { signal: params.signal });
+  }
+  async getProposal(id, signal) {
+    return this.request("GET", API.proposals.show(id), void 0, { signal });
+  }
+  async getProposalDigest(id, signal) {
+    return this.request("GET", API.proposals.digest(id), void 0, { signal });
+  }
+  async signProposal(params) {
+    return this.request("POST", API.proposals.sign(params.id), {
+      signer: params.signer.toLowerCase(),
+      signature: params.signature
+    }, { signal: params.signal });
+  }
+  async finalizeProposal(id, signal) {
+    return this.request("POST", API.proposals.finalize(id), void 0, { signal });
+  }
+  async cancelProposal(id, signal) {
+    return this.request("POST", API.proposals.cancel(id), void 0, { signal });
+  }
+  async getSettlementTokens(options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.settlement.tokens}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getSettlementQuote(params) {
+    return this.request("POST", API.settlement.quote, {
+      chain: params.chain,
+      sender: params.sender.toLowerCase(),
+      token: params.token,
+      maxGasCost: params.maxGasCost,
+      maxFeePerGas: params.maxFeePerGas
+    }, { signal: params.signal });
+  }
+  async prepareSettlement(params) {
+    const userOp = isPackedUserOp(params.userOp) ? packedToUserOperation(params.userOp) : isUserOperation(params.userOp) ? normalizeUserOperation(params.userOp) : params.userOp;
+    const body = {
+      chain: params.chain,
+      token: params.token,
+      userOp
+    };
+    const idempotencyKey = params.idempotencyKey ?? autoIdempotencyKey(body);
+    const timestamp = params.timestamp ?? nowUnix();
+    return this.request("POST", API.settlement.prepare, body, {
+      idempotencyKey,
+      timestamp,
+      signal: params.signal
+    });
+  }
+  async swapQuote(params) {
+    return this.request("POST", API.swap.quote, {
+      wallet: params.wallet.toLowerCase(),
+      fromChain: params.fromChain,
+      toChain: params.toChain,
+      fromToken: params.fromToken.toLowerCase(),
+      toToken: params.toToken.toLowerCase(),
+      amount: params.amount,
+      slippageBps: params.slippageBps,
+      deadlineSeconds: params.deadlineSeconds,
+      allowBridges: params.allowBridges,
+      allowDexes: params.allowDexes
+    }, { signal: params.signal });
+  }
+  async swapBuild(params) {
+    return this.request("POST", API.swap.build, {
+      wallet: params.wallet.toLowerCase(),
+      fromChain: params.fromChain,
+      toChain: params.toChain,
+      quoteId: params.quoteId,
+      routeId: params.routeId,
+      slippageBps: params.slippageBps
+    }, { signal: params.signal });
+  }
+  async getCrossChainConfig(wallet, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.crosschain.config(wallet)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getCrossChainPendingProposals(wallet, options) {
+    const params = new URLSearchParams();
+    params.set("chain", options?.chain ?? this.chain ?? "sepolia");
+    if (options?.lookbackBlocks) params.set("lookbackBlocks", String(options.lookbackBlocks));
+    if (options?.max) params.set("max", String(options.max));
+    return this.request("GET", `${API.crosschain.pendingProposals(wallet)}?${params.toString()}`, void 0, { signal: options?.signal });
+  }
+  async buildSessionKeyGrant(params) {
+    return this.request("POST", API.sessionKey.grant, {
+      wallet: params.wallet.toLowerCase(),
+      sessionKey: params.sessionKey.toLowerCase(),
+      chain: params.chain,
+      expiry: params.expiry,
+      startTime: params.startTime,
+      targets: params.targets?.map((t) => t.toLowerCase()),
+      selectors: params.selectors,
+      roles: params.roles
+    }, { signal: params.signal });
+  }
+  async buildSessionKeyRevoke(params) {
+    return this.request("POST", API.sessionKey.revoke, {
+      wallet: params.wallet.toLowerCase(),
+      sessionKey: params.sessionKey.toLowerCase(),
+      chain: params.chain
+    }, { signal: params.signal });
+  }
+  async buildEnableFeature(params) {
+    return this.request("POST", API.feature.enable, {
+      wallet: params.wallet.toLowerCase(),
+      featureId: params.featureId,
+      chain: params.chain,
+      initData: params.initData
+    }, { signal: params.signal });
+  }
+  async buildDisableFeature(params) {
+    return this.request("POST", API.feature.disable, {
+      wallet: params.wallet.toLowerCase(),
+      featureId: params.featureId,
+      chain: params.chain
+    }, { signal: params.signal });
+  }
+  async buildResetFeatureInitialization(params) {
+    return this.request("POST", API.feature.reset, {
+      wallet: params.wallet.toLowerCase(),
+      featureId: params.featureId,
+      chain: params.chain
+    }, { signal: params.signal });
+  }
+  async buildTryExecute(params) {
+    return this.request("POST", API.vault.tryExecute, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      calls: params.calls
+    }, { signal: params.signal });
+  }
+  async buildConfigureGuardians(params) {
+    return this.request("POST", API.guardians.configure, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      guardians: params.guardians.map((g) => g.toLowerCase()),
+      threshold: params.threshold,
+      timelock: params.timelock
+    }, { signal: params.signal });
+  }
+  async getAddressBook(options) {
+    const params = new URLSearchParams();
+    if (options?.chain) params.set("chain", options.chain);
+    if (typeof options?.limit === "number") params.set("limit", String(options.limit));
+    if (options?.cursor) params.set("cursor", options.cursor);
+    const query = params.toString();
+    return this.request("GET", `${API.addressBook.list}${query ? `?${query}` : ""}`, void 0, { signal: options?.signal });
+  }
+  async createAddressBookEntry(params) {
+    const r = await this.request("POST", API.addressBook.create, {
+      chain: params.chain,
+      label: params.label,
+      address: params.address.toLowerCase(),
+      tags: params.tags,
+      notes: params.notes
+    }, { signal: params.signal });
+    return r.entry;
+  }
+  async updateAddressBookEntry(id, params) {
+    const r = await this.request("PUT", API.addressBook.update(id), {
+      label: params.label,
+      tags: params.tags,
+      notes: params.notes
+    }, { signal: params.signal });
+    return r.entry;
+  }
+  async deleteAddressBookEntry(id, signal) {
+    await this.request("DELETE", API.addressBook.delete(id), void 0, { signal });
+  }
+  async getAutomations(params) {
+    const q = new URLSearchParams();
+    q.set("wallet", params.wallet.toLowerCase());
+    if (typeof params.limit === "number") q.set("limit", String(params.limit));
+    if (params.cursor) q.set("cursor", params.cursor);
+    const r = await this.request(
+      "GET",
+      `${API.automations.list}?${q.toString()}`,
+      void 0,
+      { signal: params.signal }
+    );
+    return {
+      automations: (r.automations || []).map(mapAutomation),
+      nextCursor: r.nextCursor ?? null,
+      hasMore: Boolean(r.hasMore)
+    };
+  }
+  async createAutomation(params) {
+    const r = await this.request("POST", API.automations.create, {
+      wallet: params.wallet.toLowerCase(),
+      type: params.type,
+      session_key: params.sessionKey?.toLowerCase(),
+      config: params.config
+    }, { signal: params.signal });
+    return mapAutomation(r.automation);
+  }
+  async getAutomation(id, signal) {
+    const r = await this.request("GET", API.automations.show(id), void 0, { signal });
+    return {
+      automation: mapAutomation(r.automation),
+      executions: (r.executions || []).map(mapAutomationExecution)
+    };
+  }
+  async pauseAutomation(id, signal) {
+    const r = await this.request("POST", API.automations.pause(id), void 0, { signal });
+    return mapAutomation(r.automation);
+  }
+  async resumeAutomation(id, signal) {
+    const r = await this.request("POST", API.automations.resume(id), void 0, { signal });
+    return mapAutomation(r.automation);
+  }
+  async deleteAutomation(id, signal) {
+    await this.request("DELETE", API.automations.delete(id), void 0, { signal });
+  }
+  async getContractAddresses(chainId, signal) {
+    return this.request("GET", API.addresses.all(chainId), void 0, { signal });
+  }
+  async getContractAddress(chainId, name, signal) {
+    return this.request("GET", API.addresses.get(chainId, name), void 0, { signal });
+  }
+  async getTimingConfig(signal) {
+    return this.request("GET", API.signature.timing, void 0, { signal });
+  }
+  async getGasLimits(signal) {
+    return this.request("GET", API.config.gasLimits, void 0, { signal });
+  }
+  async getAccountOperations(options) {
+    const params = new URLSearchParams();
+    params.set("account", options.account.toLowerCase());
+    if (options.chain) params.set("chain", options.chain);
+    if (options.state) params.set("state", options.state);
+    if (typeof options.limit === "number") params.set("limit", String(options.limit));
+    if (options.cursor) params.set("cursor", options.cursor);
+    return this.request("GET", `${API.accounts.operations}?${params.toString()}`, void 0, { signal: options.signal });
+  }
+  async getEnabledFeatures(wallet, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.vault.features(wallet)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getFeatureConfig(wallet, featureId, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.vault.feature(wallet, featureId)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getSecurityCouncil(wallet, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.vault.securityCouncil(wallet)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getFallbackSigner(wallet, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.vault.fallbackSigner(wallet)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async isPaused(wallet, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.vault.paused(wallet)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getL2Receiver(wallet, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.vault.l2Receiver(wallet)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async buildPauseCore(params) {
+    return this.request("POST", API.vault.pause, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain
+    }, { signal: params.signal });
+  }
+  async buildUnpauseCore(params) {
+    return this.request("POST", API.vault.unpause, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain
+    }, { signal: params.signal });
+  }
+  async buildSetSecurityCouncil(params) {
+    return this.request("POST", API.vault.setSecurityCouncil, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      securityCouncil: params.securityCouncil.toLowerCase()
+    }, { signal: params.signal });
+  }
+  async buildSetFallbackSigner(params) {
+    return this.request("POST", API.vault.setFallbackSigner, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      fallbackSigner: params.fallbackSigner.toLowerCase()
+    }, { signal: params.signal });
+  }
+  async buildOverrideGlobalPause(params) {
+    return this.request("POST", API.vault.overrideGlobalPause, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      override: params.override
+    }, { signal: params.signal });
+  }
+  async getSessionKeyCount(wallet, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.sessionKey.count(wallet)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getSessionKeyPolicySigner(wallet, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.sessionKey.policySigner(wallet)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getSessionKeyRoles(wallet, sessionKey, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.sessionKey.roles(wallet, sessionKey)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getSessionKeyTokenLimit(wallet, sessionKey, token, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.sessionKey.tokenLimit(wallet, sessionKey, token)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async buildRevokeAllSessionKeys(params) {
+    return this.request("POST", API.sessionKey.revokeAll, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain
+    }, { signal: params.signal });
+  }
+  async buildSetSessionKeyTokenLimits(params) {
+    return this.request("POST", API.sessionKey.tokenLimits, {
+      wallet: params.wallet.toLowerCase(),
+      sessionKey: params.sessionKey.toLowerCase(),
+      chain: params.chain,
+      limits: params.limits.map((l) => ({ token: l.token.toLowerCase(), limit: l.limit }))
+    }, { signal: params.signal });
+  }
+  async buildSetMaxValuePerCall(params) {
+    return this.request("POST", API.sessionKey.maxValuePerCall, {
+      wallet: params.wallet.toLowerCase(),
+      sessionKey: params.sessionKey.toLowerCase(),
+      chain: params.chain,
+      maxValue: params.maxValue
+    }, { signal: params.signal });
+  }
+  async buildSyncSessionKey(params) {
+    return this.request("POST", API.sessionKey.sync, {
+      wallet: params.wallet.toLowerCase(),
+      sessionKey: params.sessionKey.toLowerCase(),
+      chain: params.chain
+    }, { signal: params.signal });
+  }
+  async getFeatureSessionKeys(wallet, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.sessionKey.list(wallet)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getFeatureSpendingLimits(wallet, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.feature.spendingLimits(wallet)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getFeatureRoles(wallet, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.feature.roles(wallet)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getAccountRoles(wallet, account, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.feature.accountRoles(wallet, account)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getNativeSpendingSummaries(wallet, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.spendingLimit.nativeSummaries(wallet)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getTokenSpendingSummaries(wallet, token, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.spendingLimit.tokenSummaries(wallet, token)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getSpendingPreview(wallet, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.spendingLimit.preview(wallet)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getSpendingBucket(wallet, windowStart, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.spendingLimit.bucket(wallet, windowStart)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getNativeLimit(wallet, window, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.spendingLimit.nativeLimit(wallet, window)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getNativeLimitStatus(wallet, window, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.spendingLimit.nativeStatus(wallet, window)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getTokenLimit(wallet, token, window, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.spendingLimit.tokenLimit(wallet, token, window)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getTokenLimitStatus(wallet, token, window, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.spendingLimit.tokenStatus(wallet, token, window)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async buildEnableSpendingLimit(params) {
+    return this.request("POST", API.spendingLimit.enable, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      window: params.window,
+      limit: params.limit
+    }, { signal: params.signal });
+  }
+  async buildDisableSpendingLimit(params) {
+    return this.request("POST", API.spendingLimit.disable, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      window: params.window
+    }, { signal: params.signal });
+  }
+  async buildUpdateSpendingLimit(params) {
+    return this.request("POST", API.spendingLimit.update, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      window: params.window,
+      limit: params.limit
+    }, { signal: params.signal });
+  }
+  async buildEnableTokenSpendingLimit(params) {
+    return this.request("POST", API.spendingLimit.enableToken, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      token: params.token.toLowerCase(),
+      window: params.window,
+      limit: params.limit
+    }, { signal: params.signal });
+  }
+  async buildDisableTokenSpendingLimit(params) {
+    return this.request("POST", API.spendingLimit.disableToken, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      token: params.token.toLowerCase(),
+      window: params.window
+    }, { signal: params.signal });
+  }
+  async buildUpdateTokenSpendingLimit(params) {
+    return this.request("POST", API.spendingLimit.updateToken, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      token: params.token.toLowerCase(),
+      window: params.window,
+      limit: params.limit
+    }, { signal: params.signal });
+  }
+  async buildSetSpendValidator(params) {
+    return this.request("POST", API.spendingLimit.setSpendValidator, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      target: params.target.toLowerCase(),
+      selector: params.selector.toLowerCase(),
+      module: params.module.toLowerCase()
+    }, { signal: params.signal });
+  }
+  async getAllowlistRoots(wallet, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.allowlist.getRoots(wallet)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getActorPermissions(wallet, actor, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.allowlist.getActorPermissions(wallet, actor)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getTokenMaxTransfer(wallet, token, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.allowlist.tokenMaxTransfer(wallet, token)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async buildEnableAllowlist(params) {
+    return this.request("POST", API.allowlist.enable, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain
+    }, { signal: params.signal });
+  }
+  async buildDisableAllowlist(params) {
+    return this.request("POST", API.allowlist.disable, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain
+    }, { signal: params.signal });
+  }
+  async buildEnableContractOnly(params) {
+    return this.request("POST", API.allowlist.contractOnly, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      enabled: params.enabled
+    }, { signal: params.signal });
+  }
+  async buildSetAllowlistRoots(params) {
+    return this.request("POST", API.allowlist.roots, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      addressRoot: params.addressRoot,
+      selectorRoot: params.selectorRoot
+    }, { signal: params.signal });
+  }
+  async buildSyncAllowlist(params) {
+    return this.request("POST", API.allowlist.sync, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain
+    }, { signal: params.signal });
+  }
+  async buildSetMaxTransferAmount(params) {
+    return this.request("POST", API.allowlist.transferLimit, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      token: params.token.toLowerCase(),
+      maxAmount: params.maxAmount
+    }, { signal: params.signal });
+  }
+  async buildSetActorPermissions(params) {
+    return this.request("POST", API.allowlist.actorPermissions, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      actor: params.actor.toLowerCase(),
+      permissions: params.permissions
+    }, { signal: params.signal });
+  }
+  async getRecoveryGuardians(wallet, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.recovery.guardians(wallet)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getRecoveryProposal(wallet, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.recovery.proposal(wallet)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getRecoveryProposalState(wallet, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.recovery.proposalState(wallet)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async hasGuardianApproved(wallet, guardian, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.recovery.guardianApproved(wallet, guardian)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async isGuardian(wallet, guardian, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.recovery.isGuardian(wallet, guardian)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async buildInitiateRecovery(params) {
+    return this.request("POST", API.recovery.initiate, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      proposedOwner: params.proposedOwner.toLowerCase()
+    }, { signal: params.signal });
+  }
+  async buildSupportRecovery(params) {
+    return this.request("POST", API.recovery.support, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      guardian: params.guardian.toLowerCase(),
+      signature: params.signature
+    }, { signal: params.signal });
+  }
+  async buildExecuteRecovery(params) {
+    return this.request("POST", API.recovery.execute, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain
+    }, { signal: params.signal });
+  }
+  async buildCancelRecovery(params) {
+    return this.request("POST", API.recovery.cancel, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain
+    }, { signal: params.signal });
+  }
+  async getArmedStatus(wallet, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.roles.armed(wallet)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getTargetIndex(wallet, target, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.roles.targetIndex(wallet, target)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getSelectorIndex(wallet, selector, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.roles.selectorIndex(wallet, selector)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async hasRole(wallet, account, roleId, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.roles.hasRole(wallet, account, roleId)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getRoleBudget(wallet, roleId, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.roles.budget(wallet, roleId)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getRole(wallet, roleId, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    const raw = await this.request("GET", `${API.roles.show(wallet, roleId)}?chain=${chain}`, void 0, { signal: options?.signal });
+    const role = raw.role;
+    if (!role || typeof role !== "object") {
+      throw new VaultumError("Invalid role response", "BUNDLER_ERROR", 502, raw);
+    }
+    return {
+      wallet: (raw.wallet ?? wallet).toLowerCase(),
+      roleId: (raw.roleId ?? roleId).toLowerCase(),
+      chain: typeof raw.chain === "string" && raw.chain !== "" ? raw.chain : chain,
+      name: typeof role.name === "string" ? role.name : "",
+      targetBitmap: typeof role.targetBitmap === "string" ? role.targetBitmap : "0",
+      selectorBitmap: typeof role.selectorBitmap === "string" ? role.selectorBitmap : "0",
+      maxValue: typeof role.maxValue === "string" ? role.maxValue : "0"
+    };
+  }
+  async buildCreateRole(params) {
+    return this.request("POST", API.roles.create, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      roleId: params.roleId,
+      name: params.name,
+      targetBitmap: params.targetBitmap,
+      selectorBitmap: params.selectorBitmap,
+      maxValue: typeof params.maxValue === "number" ? params.maxValue : void 0
+    }, { signal: params.signal });
+  }
+  async buildCreateRolesBatch(params) {
+    return this.request("POST", API.roles.createBatch, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      roles: params.roles.map((r) => ({
+        roleId: r.roleId,
+        name: r.name,
+        targetBitmap: r.targetBitmap,
+        selectorBitmap: r.selectorBitmap,
+        maxValue: typeof r.maxValue === "number" ? String(r.maxValue) : r.maxValue ?? "0"
+      }))
+    }, { signal: params.signal });
+  }
+  async buildGrantRole(params) {
+    return this.request("POST", API.roles.grant, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      account: params.account.toLowerCase(),
+      roleId: params.roleId
+    }, { signal: params.signal });
+  }
+  async buildRevokeRole(params) {
+    return this.request("POST", API.roles.revoke, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      account: params.account.toLowerCase(),
+      roleId: params.roleId
+    }, { signal: params.signal });
+  }
+  async buildGrantRolesBatch(params) {
+    return this.request("POST", API.roles.grantBatch, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      grants: params.grants.map((g) => ({
+        account: g.account.toLowerCase(),
+        roleId: g.roleId
+      }))
+    }, { signal: params.signal });
+  }
+  async buildRevokeRolesBatch(params) {
+    return this.request("POST", API.roles.revokeBatch, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      revokes: params.revokes.map((r) => ({
+        account: r.account.toLowerCase(),
+        roleId: r.roleId
+      }))
+    }, { signal: params.signal });
+  }
+  async buildUpdateRole(params) {
+    return this.request("POST", API.roles.update, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      roleId: params.roleId,
+      name: params.name,
+      targetBitmap: params.targetBitmap,
+      selectorBitmap: params.selectorBitmap,
+      maxValue: params.maxValue
+    }, { signal: params.signal });
+  }
+  async buildSetRoleBitmap(params) {
+    const current = await this.getRole(params.wallet, params.roleId, { chain: params.chain, signal: params.signal });
+    return this.buildUpdateRole({
+      wallet: params.wallet,
+      chain: params.chain,
+      roleId: params.roleId,
+      name: current.name,
+      targetBitmap: params.targetBitmap,
+      selectorBitmap: params.selectorBitmap,
+      maxValue: current.maxValue,
+      signal: params.signal
+    });
+  }
+  async buildGrantRolesMultiAccount(params) {
+    return this.request("POST", API.roles.grantMulti, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      accounts: params.accounts.map((a) => a.toLowerCase()),
+      roleIds: params.roleIds
+    }, { signal: params.signal });
+  }
+  async buildArmRoles(params) {
+    return this.request("POST", API.roles.arm, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      armed: params.armed
+    }, { signal: params.signal });
+  }
+  async buildSetRoleBudget(params) {
+    return this.request("POST", API.roles.setBudget(params.wallet, params.roleId), {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      budget: params.budget
+    }, { signal: params.signal });
+  }
+  async getCrossChainReceiverState(wallet, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.crosschain.receiverStateFresh(wallet)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getCrossChainSkipProposal(wallet, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.crosschain.receiverSkipProposal(wallet)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getCrossChainGasLimit(chainId, signal) {
+    return this.request("GET", API.crosschain.gasLimit(chainId), void 0, { signal });
+  }
+  async buildProposeOwnerUpdate(params) {
+    return this.request("POST", API.crosschain.proposeOwnerUpdate, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      newOwners: params.newOwners.map((o) => o.toLowerCase()),
+      newThreshold: params.newThreshold,
+      targetChains: params.targetChains
+    }, { signal: params.signal });
+  }
+  async buildExecuteOwnerUpdate(params) {
+    return this.request("POST", API.crosschain.executeOwnerUpdate, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      proposalId: params.proposalId
+    }, { signal: params.signal });
+  }
+  async buildResyncL2(params) {
+    return this.request("POST", API.crosschain.resync, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      targetChain: params.targetChain
+    }, { signal: params.signal });
+  }
+  async updateAutomation(id, params) {
+    const r = await this.request("PUT", API.automations.update(id), {
+      session_key: params.sessionKey ? params.sessionKey.toLowerCase() : params.sessionKey,
+      config: params.config
+    }, { signal: params.signal });
+    return mapAutomation(r.automation);
+  }
+  async triggerAutomation(id, signal) {
+    const r = await this.request(
+      "POST",
+      API.automations.trigger(id),
+      void 0,
+      { signal }
+    );
+    return {
+      automation: mapAutomation(r.automation),
+      message: r.message
+    };
+  }
+  async getAddressCapabilities(signal) {
+    return this.request("GET", API.addresses.capabilities, void 0, { signal });
+  }
+  async getUserOpTemplate(options) {
+    const params = new URLSearchParams();
+    if (options?.chain) params.set("chain", options.chain);
+    const query = params.toString();
+    return this.request("GET", `${API.signature.userOpTemplate}${query ? `?${query}` : ""}`, void 0, { signal: options?.signal });
+  }
+  async getEIP712Template(options) {
+    const params = new URLSearchParams();
+    if (options?.chain) params.set("chain", options.chain);
+    const query = params.toString();
+    return this.request("GET", `${API.signature.eip712Template}${query ? `?${query}` : ""}`, void 0, { signal: options?.signal });
+  }
+  async validateTimestamp(params) {
+    return this.request("POST", API.signature.validateTimestamp, {
+      validAfter: params.validAfter,
+      validUntil: params.validUntil
+    }, { signal: params.signal });
+  }
+  async getRegistryFeatures(options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.registry.features}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getRegistryVersion(options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.registry.version}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async isFeatureInternal(featureId, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.registry.isInternal(featureId)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async canValidatorHandleSelector(validatorId, selector, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.registry.canValidatorHandleSelector(validatorId, selector)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getRegistryCoreModuleId(key, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.registry.coreModuleId(key)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async canAccessRegistrySlot(featureId, slot, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.registry.slotAccess(featureId, slot)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async registrySupportsMigration(featureId, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.registry.supportsMigration(featureId)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async isRegistryFeatureImplementation(impl, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.registry.isFeatureImplementation(impl)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getRegistryFeatureImplementation(featureId, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.registry.featureImplementation(featureId)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getRegistryFeatureImplementationForWallet(wallet, featureId, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.registry.featureImplementationForWallet(wallet, featureId)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async isRegistryMandatoryFeature(featureId, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.registry.isMandatoryFeature(featureId)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getRegistryEcdsaModule(options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.registry.ecdsaModule}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getRegistrySessionKeyManager(options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.registry.sessionKeyManager}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getRegistrySpendingLimitManager(options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.registry.spendingLimitManager}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getRegistryPermissionsManager(options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.registry.permissionsManager}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getRegistryCapabilitySnapshot(wallet, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.registry.capabilitySnapshot(wallet)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async getRegistryMandatoryInitData(wallet, featureId, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.registry.mandatoryInitData(wallet, featureId)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async buildSetRegistryCanaryOptIn(params) {
+    return this.request("POST", API.registry.setCanaryOptIn, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      optIn: params.optIn
+    }, { signal: params.signal });
+  }
+  async buildSetRegistryMandatoryInitData(params) {
+    return this.request("POST", API.registry.setMandatoryInitData, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      featureId: params.featureId,
+      initData: params.initData
+    }, { signal: params.signal });
+  }
+  async buildUpdateRegistryCapabilitySnapshot(params) {
+    return this.request("POST", API.registry.updateCapabilitySnapshot, {
+      wallet: params.wallet.toLowerCase(),
+      chain: params.chain,
+      snapshot: params.snapshot
+    }, { signal: params.signal });
+  }
+  async isGloballyPaused(wallet, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.registry.globallyPaused(wallet)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async isCanaryOptIn(wallet, options) {
+    const chain = options?.chain ?? this.chain ?? "sepolia";
+    return this.request("GET", `${API.registry.canaryOptIn(wallet)}?chain=${chain}`, void 0, { signal: options?.signal });
+  }
+  async estimateRelay(params) {
+    return this.request("POST", API.relay.estimate, {
+      chain: params.chain,
+      userOp: params.userOp
+    }, { signal: params.signal });
+  }
+  async previewRelay(params) {
+    return this.request("POST", API.relay.preview, {
+      chain: params.chain,
+      userOp: params.userOp
+    }, { signal: params.signal });
+  }
+  async getHealth(signal) {
+    return this.request("GET", API.health, void 0, { signal });
+  }
+};
+function normalizeURL(url, hasCredentials) {
+  const trimmed = url.trim();
+  if (!trimmed) throw new VaultumError("Base URL required", "INVALID_CONFIG");
+  let parsed;
+  try {
+    parsed = new URL(trimmed);
+  } catch {
+    throw new VaultumError("Invalid base URL", "INVALID_CONFIG");
+  }
+  const isHttps = parsed.protocol === "https:";
+  const isLocal = parsed.protocol === "http:" && (parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1");
+  if (!isHttps && !isLocal) throw new VaultumError("Base URL must use https or localhost", "INVALID_CONFIG");
+  if (hasCredentials && !isHttps) throw new VaultumError("Credentials require https", "INVALID_CONFIG");
+  return trimmed.replace(/\/$/, "");
+}
+function mapErrorCode(code, status) {
+  if (code === "INVALID_USEROP") return "INVALID_USEROP";
+  if (code === "INVALID_CONFIG") return "INVALID_CONFIG";
+  if (code === "RATE_LIMITED" || status === 429) return "RATE_LIMITED";
+  if (code === "UNAUTHORIZED" || status === 401) return "UNAUTHORIZED";
+  if (code === "FORBIDDEN" || status === 403) return "FORBIDDEN";
+  if (code === "NOT_FOUND" || status === 404) return "NOT_FOUND";
+  if (status === 422) return "VALIDATION_ERROR";
+  return "BUNDLER_ERROR";
+}
+function anySignal(signals) {
+  const controller = new AbortController();
+  for (const signal of signals) {
+    if (signal.aborted) {
+      controller.abort(signal.reason);
+      return controller.signal;
+    }
+    signal.addEventListener("abort", () => controller.abort(signal.reason), { once: true });
+  }
+  return controller.signal;
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new DOMException("Aborted", "AbortError"));
+      return;
+    }
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener("abort", () => {
+      clearTimeout(timer);
+      reject(new DOMException("Aborted", "AbortError"));
+    }, { once: true });
+  });
+}
+
+// src/governance.ts
+import { hashTypedData } from "viem";
+var GOVERNANCE_DOMAIN_NAME = "VaultumGovernance";
+var GOVERNANCE_DOMAIN_VERSION = "1";
+function buildCrossChainRootTypedData(params) {
+  return {
+    domain: {
+      name: GOVERNANCE_DOMAIN_NAME,
+      version: GOVERNANCE_DOMAIN_VERSION,
+      chainId: params.chainId,
+      verifyingContract: params.registry
+    },
+    types: {
+      CrossChainRoot: [
+        { name: "merkleRoot", type: "bytes32" },
+        { name: "nonce", type: "uint256" },
+        { name: "validUntil", type: "uint64" }
+      ]
+    },
+    primaryType: "CrossChainRoot",
+    message: {
+      merkleRoot: params.merkleRoot,
+      nonce: params.nonce,
+      validUntil: params.validUntil
+    }
+  };
+}
+function hashCrossChainRootTypedData(params) {
+  return hashTypedData(buildCrossChainRootTypedData(params));
+}
+
+// src/index.ts
+var VERSION = "0.1.5";
+export {
+  API,
+  CONTRACTS,
+  ENTRYPOINT_V07,
+  FEATURE_IDS,
+  FEATURE_ID_STRINGS,
+  GOVERNANCE_DOMAIN_NAME,
+  GOVERNANCE_DOMAIN_VERSION,
+  UserOpBuilder,
+  VERSION,
+  VaultumClient,
+  VaultumError,
+  buildCrossChainRootTypedData,
+  createUserOpBuilder,
+  getUserOpHash,
+  hashCrossChainRootTypedData,
+  packGasFees,
+  packGasLimits,
+  parseQuoteResponse,
+  unpackGasFees,
+  unpackGasLimits
+};