@chipi-stack/backend 14.15.0 → 14.16.0

package/dist/index.mjs

@@ -1953,9 +1953,9 @@ var ChipiTransactions = class {
   /**
    * Get on-chain transaction status
    */
-  async getTransactionStatus(hash11, bearerToken) {
+  async getTransactionStatus(hash13, bearerToken) {
     return this.client.get({
-      endpoint: `${API_ENDPOINTS.TRANSACTIONS}/${hash11}/status`,
+      endpoint: `${API_ENDPOINTS.TRANSACTIONS}/${hash13}/status`,
       bearerToken
     });
   }
@@ -3310,9 +3310,13 @@ var ChipiAi = class {
    * session key: a USDC `transfer` to the offer's `payTo`, then the same call
    * again with `X-PAYMENT`. The price must be at most `maxAmount`, `model`
    * must be payable and the input within `maxPromptBytes`, all checked before
-   * paying. The session must whitelist `transfer` and cap USDC. A payment
-   * that was made but not served is reported in `error.details.xPayment`;
-   * pass it back as `options.xPayment` to retry without paying again.
+   * paying. The wallet must be a wallet of the organization that owns the
+   * `sk_`: the first request names it in `X-PAYER`, and when the API answers
+   * that a payment from it would be refused, nothing is paid
+   * (`X402_PAYER_NOT_IN_ORG`). The session must whitelist `transfer` and cap
+   * USDC. A payment that was made but not served is reported in
+   * `error.details.xPayment`; pass it back as `options.xPayment` to retry
+   * without paying again.
    *
    * @example
    * ```typescript
@@ -3324,20 +3328,32 @@ var ChipiAi = class {
    * ```
    */
   async think(params, options = {}) {
+    let payer;
+    if (options.payWithSession && !options.xPayment) {
+      try {
+        payer = padFelt(options.payWithSession.wallet.publicKey);
+      } catch {
+        payer = void 0;
+      }
+    }
     try {
-      return await this.postThink(params, options.xPayment);
+      return await this.postThink(params, options.xPayment, payer);
     } catch (err) {
       const offer = options.payWithSession ? sessionTransferOffer(err) : void 0;
       if (!offer || !options.payWithSession) throw err;
       return this.payAndThink(params, offer, options.payWithSession);
     }
   }
-  postThink(params, xPayment) {
+  postThink(params, xPayment, payer) {
+    const headers = {
+      ...xPayment ? { "X-PAYMENT": xPayment } : {},
+      ...payer ? { "X-PAYER": payer } : {}
+    };
     return this.client.post({
       endpoint: `${AI_BASE}/think`,
       bearerToken: this.secret(),
       body: params,
-      ...xPayment ? { headers: { "X-PAYMENT": xPayment } } : {}
+      ...Object.keys(headers).length > 0 ? { headers } : {}
     });
   }
   /**
@@ -3390,6 +3406,15 @@ var ChipiAi = class {
         { x402: { accepts: [offer] } }
       );
     }
+    const payerCheck = offer.extra?.payer;
+    if (payerCheck?.accepted === false && typeof payerCheck.address === "string" && sameFelt(payerCheck.address, pay.wallet.publicKey)) {
+      throw new ChipiApiError(
+        `Wallet ${pay.wallet.publicKey} is not a wallet of the organization that owns this API key, so the API would refuse its payment; nothing was paid. Pay from a wallet of this organization.`,
+        "X402_PAYER_NOT_IN_ORG",
+        402,
+        { x402: { accepts: [offer] } }
+      );
+    }
     const payer = pay.wallet.publicKey;
     const mask = (1n << 128n) - 1n;
     const transactionHash = await this.sessions.executeTransactionWithSession(
@@ -3517,6 +3542,122 @@ var ChipiAi = class {
     });
   }
 };
+var STARKNET_SIGNATURE_VALID = "0x56414c4944";
+function toFeltHex(value) {
+  return num.toHex(BigInt(value));
+}
+function normalizeStarknetAddress(address) {
+  return `0x${BigInt(address).toString(16).padStart(64, "0")}`;
+}
+function isContractNotFound(err) {
+  const e = err;
+  if (e?.baseError?.code === 20 || e?.code === 20) return true;
+  return /contract not found/i.test(e?.message ?? String(err));
+}
+async function isValidStarknetSignature(provider, accountAddress, messageHash, signature) {
+  try {
+    const sig = signature.map(toFeltHex);
+    const result = await provider.callContract({
+      contractAddress: normalizeStarknetAddress(accountAddress),
+      entrypoint: "is_valid_signature",
+      calldata: [toFeltHex(messageHash), toFeltHex(sig.length), ...sig]
+    });
+    const first = result?.[0];
+    if (first !== void 0 && BigInt(first) === BigInt(STARKNET_SIGNATURE_VALID)) {
+      return { valid: true };
+    }
+    return { valid: false, reason: "INVALID_SIGNATURE" };
+  } catch (err) {
+    if (isContractNotFound(err)) return { valid: false, reason: "ACCOUNT_NOT_DEPLOYED" };
+    return {
+      valid: false,
+      reason: "INVALID_SIGNATURE",
+      detail: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+var COUNTERFACTUAL_ACCOUNT_CLASSES = {
+  /** OpenZeppelin AccountUpgradeable 3.0 (Bramble's default account). */
+  OPENZEPPELIN_V3: "0x01d1777db36cdd06dd62cfde77b1b6ae06412af95d57a13dc40ac77b8a702381",
+  /** Argent X / Ready 0.4 (`WALLET_CLASS_HASHES.READY`). */
+  ARGENT_V0_4: "0x036078334509b514626504edc9fb252328d1a240e4e948bef8d0c08dff45927f"
+};
+function starkVerify(r, s, messageHash, publicKey) {
+  const x = BigInt(publicKey).toString(16).padStart(64, "0");
+  const sig = new ec.starkCurve.Signature(BigInt(r), BigInt(s));
+  for (const prefix of ["02", "03"]) {
+    try {
+      if (ec.starkCurve.verify(sig, toFeltHex(messageHash), prefix + x)) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function verifyUndeployedStarknetSignature(deployment, messageHash, signature) {
+  const classHash = normalizeStarknetAddress(deployment.class_hash);
+  const calldata = deployment.calldata.map(toFeltHex);
+  const sig = signature.map(toFeltHex);
+  let publicKey;
+  let r;
+  let s;
+  if (classHash === COUNTERFACTUAL_ACCOUNT_CLASSES.OPENZEPPELIN_V3) {
+    if (calldata.length !== 1 || sig.length !== 2) {
+      return { valid: false, reason: "INVALID_SIGNATURE" };
+    }
+    [publicKey] = calldata;
+    [r, s] = sig;
+  } else if (classHash === COUNTERFACTUAL_ACCOUNT_CLASSES.ARGENT_V0_4) {
+    if (calldata.length !== 3 || BigInt(calldata[0]) !== 0n || BigInt(calldata[2]) !== 1n) {
+      return { valid: false, reason: "UNSUPPORTED_ACCOUNT_CLASS" };
+    }
+    if (sig.length !== 5 || BigInt(sig[0]) !== 1n || BigInt(sig[1]) !== 0n) {
+      return { valid: false, reason: "INVALID_SIGNATURE" };
+    }
+    if (BigInt(sig[2]) !== BigInt(calldata[1])) {
+      return { valid: false, reason: "INVALID_SIGNATURE" };
+    }
+    publicKey = calldata[1];
+    [, , , r, s] = sig;
+  } else {
+    return { valid: false, reason: "UNSUPPORTED_ACCOUNT_CLASS" };
+  }
+  const expected = hash.calculateContractAddressFromHash(
+    toFeltHex(deployment.salt),
+    classHash,
+    calldata,
+    0
+  );
+  if (normalizeStarknetAddress(expected) !== normalizeStarknetAddress(deployment.address)) {
+    return { valid: false, reason: "ADDRESS_MISMATCH" };
+  }
+  return starkVerify(r, s, messageHash, publicKey) ? { valid: true } : { valid: false, reason: "INVALID_SIGNATURE" };
+}
+
+// src/x402/facilitator.ts
+var TRANSFER_SELECTOR2 = BigInt(hash.getSelectorFromName("transfer"));
+function shhhTransferMatches(oeCalldata, payload) {
+  try {
+    const felts = oeCalldata.map((v) => BigInt(v));
+    const [, , , executeBefore, callsLen] = felts;
+    if (callsLen !== 1n) return { ok: false, reason: "SHHH payment must be exactly one transfer" };
+    const [to, selector, len, recipient, low, high] = felts.slice(5, 11);
+    if (to !== BigInt(payload.asset) || selector !== TRANSFER_SELECTOR2 || len !== 3n) {
+      return { ok: false, reason: "SHHH payment call is not a transfer of the payment asset" };
+    }
+    if (recipient !== BigInt(payload.toAddress)) {
+      return { ok: false, reason: "SHHH payment pays a different recipient" };
+    }
+    if (low + (high << 128n) !== BigInt(payload.amount)) {
+      return { ok: false, reason: "SHHH payment amount differs from the declared amount" };
+    }
+    if (executeBefore <= BigInt(Math.floor(Date.now() / 1e3))) {
+      return { ok: false, reason: "SHHH payment has expired (execute_before in the past)" };
+    }
+    return { ok: true };
+  } catch {
+    return { ok: false, reason: "Malformed SHHH oeCalldata" };
+  }
+}
 var InMemoryNonceStore = class {
   constructor() {
     this.used = /* @__PURE__ */ new Set();
@@ -3559,11 +3700,18 @@ var X402Facilitator = class _X402Facilitator {
    * Verify a payment signature is valid (doesn't execute the transfer).
    *
    * Checks:
-   * 1. Nonce has not been used (replay protection)
-   * 2. Payment has not expired (validUntil > now)
-   * 3. Asset is USDC mainnet
-   * 4. Amount is positive
-   * 5. Addresses are non-empty
+   * 1. x402 version is 1
+   * 2. Network is starknet-mainnet
+   * 3. Nonce has not been used (replay protection)
+   * 4. Payment has not expired (validUntil > now)
+   * 5. Asset is USDC mainnet
+   * 6. Amount is positive
+   * 7. Addresses are non-empty
+   * 8. Signature: with a `provider`, the payer account's `is_valid_signature`
+   *    must return 'VALID'. Without one, only its presence is checked (not a
+   *    cryptographic check). SHHH payloads must sign exactly one transfer
+   *    of `amount` of `asset` to `toAddress`; their signature is checked
+   *    on-chain at settle.
    */
   async verify(payment) {
     const { payload } = payment;
@@ -3619,6 +3767,8 @@ var X402Facilitator = class _X402Facilitator {
       if (!Array.isArray(oeCalldata) || oeCalldata.length === 0) {
         return { valid: false, reason: "Missing SHHH oeCalldata" };
       }
+      const bound = shhhTransferMatches(oeCalldata, payment.payload);
+      if (!bound.ok) return { valid: false, reason: bound.reason };
       return { valid: true };
     }
     if (!this.provider) {
@@ -3639,22 +3789,25 @@ var X402Facilitator = class _X402Facilitator {
       valid_until: String(payload.validUntil),
       nonce: payload.nonce
     });
-    const msgHash = typedData.getMessageHash(paymentTypedData, payload.fromAddress);
+    let msgHash;
     try {
-      const result = await this.provider.callContract({
-        contractAddress: payload.fromAddress,
-        entrypoint: "is_valid_signature",
-        calldata: [msgHash, "2", payload.signature.r, payload.signature.s]
-      });
-      const VALID = "0x56414c4944";
-      if (result[0] === VALID || result[0] === BigInt(VALID).toString()) {
-        return { valid: true };
-      }
-      return { valid: false, reason: "Invalid SNIP-12 signature" };
+      msgHash = typedData.getMessageHash(paymentTypedData, payload.fromAddress);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      return { valid: false, reason: `Signature verification failed: ${message}` };
+      return { valid: false, reason: `Malformed payment: ${message}` };
     }
+    const check = await isValidStarknetSignature(this.provider, payload.fromAddress, msgHash, [
+      payload.signature.r,
+      payload.signature.s
+    ]);
+    if (check.valid) return { valid: true };
+    if (check.reason === "ACCOUNT_NOT_DEPLOYED") {
+      return { valid: false, reason: "Payer account is not deployed" };
+    }
+    return {
+      valid: false,
+      reason: check.detail ? `Signature verification failed: ${check.detail}` : "Invalid SNIP-12 signature"
+    };
   }
   /**
    * Settle a verified payment by executing the USDC transfer via paymaster.
@@ -3783,7 +3936,7 @@ var signTypedData = async ({
     throw error;
   }
 };
-function toFeltHex(x) {
+function toFeltHex2(x) {
   return "0x" + x.toString(16).padStart(64, "0");
 }
 var signTypedDataArray = async ({
@@ -3813,7 +3966,7 @@ var signTypedDataArray = async ({
       messageHash,
       ownerIndex: 0n
     });
-    return envelope.map(toFeltHex);
+    return envelope.map(toFeltHex2);
   }
   const provider = new RpcProvider({ nodeUrl: WALLET_RPC_ENDPOINTS[walletType] });
   const account = new Account({ provider, address: wallet.publicKey, signer: privateKeyDecrypted });
@@ -4098,8 +4251,8 @@ var ChipiSDK = class {
   /**
    * Get on-chain transaction status (supports polling for confirmation)
    */
-  async getTransactionStatus(hash11, bearerToken) {
-    return this.transactions.getTransactionStatus(hash11, this.resolveBearerToken(bearerToken));
+  async getTransactionStatus(hash13, bearerToken) {
+    return this.transactions.getTransactionStatus(hash13, this.resolveBearerToken(bearerToken));
   }
   /**
    * Prepare a wallet upgrade (e.g., READY → CHIPI or CHIPI v29 → v33).
@@ -4471,6 +4624,106 @@ function x402Middleware(config) {
     next();
   };
 }
+var SIWS_DOMAIN_NAME = "Sign in with Starknet";
+var SIWS_DOMAIN_VERSION = "1";
+var SIWS_CHAIN_ID = "SN_MAIN";
+var DEFAULT_STATEMENT = "Sign in. This request costs nothing and moves no funds.";
+function assertPrintableAscii(field, value) {
+  if (!/^[\x20-\x7e]*$/.test(value)) {
+    throw new Error(`SIWS ${field} must be single-line printable ASCII`);
+  }
+}
+function createStarknetSignInTypedData(params) {
+  const message = {
+    domain: params.domain,
+    address: normalizeStarknetAddress(params.address),
+    statement: params.statement ?? DEFAULT_STATEMENT,
+    uri: params.uri,
+    nonce: params.nonce,
+    issuedAt: params.issuedAt ?? Math.floor(Date.now() / 1e3),
+    expirationTime: params.expirationTime
+  };
+  for (const field of ["domain", "statement", "uri", "nonce"]) {
+    assertPrintableAscii(field, message[field]);
+  }
+  if (!/^[A-Za-z0-9]{8,}$/.test(message.nonce)) {
+    throw new Error("SIWS nonce must be at least 8 letters or digits");
+  }
+  if (!Number.isInteger(message.issuedAt) || !Number.isInteger(message.expirationTime)) {
+    throw new Error("SIWS times must be whole unix seconds");
+  }
+  if (message.expirationTime <= message.issuedAt) {
+    throw new Error("SIWS expirationTime must be after issuedAt");
+  }
+  return {
+    types: {
+      StarknetDomain: [
+        { name: "name", type: "shortstring" },
+        { name: "version", type: "shortstring" },
+        { name: "chainId", type: "shortstring" },
+        { name: "revision", type: "shortstring" }
+      ],
+      SignIn: [
+        { name: "domain", type: "string" },
+        { name: "address", type: "ContractAddress" },
+        { name: "statement", type: "string" },
+        { name: "uri", type: "string" },
+        { name: "nonce", type: "string" },
+        { name: "issuedAt", type: "timestamp" },
+        { name: "expirationTime", type: "timestamp" }
+      ]
+    },
+    primaryType: "SignIn",
+    domain: {
+      name: SIWS_DOMAIN_NAME,
+      version: SIWS_DOMAIN_VERSION,
+      chainId: SIWS_CHAIN_ID,
+      revision: "1"
+    },
+    message: { ...message }
+  };
+}
+var MAX_SKEW_SECONDS = 60;
+async function verifyStarknetSignIn(params) {
+  const { typedData: typedData2, signature, provider, expected, deploymentData } = params;
+  const raw = typedData2?.message;
+  if (!raw || !Array.isArray(signature) || signature.length === 0) {
+    return { ok: false, reason: "MALFORMED" };
+  }
+  if (typedData2.domain?.chainId !== SIWS_CHAIN_ID) return { ok: false, reason: "WRONG_CHAIN" };
+  let canonical;
+  let message;
+  try {
+    canonical = createStarknetSignInTypedData({
+      domain: String(raw.domain),
+      uri: String(raw.uri),
+      address: String(raw.address),
+      nonce: String(raw.nonce),
+      statement: String(raw.statement),
+      issuedAt: Number(raw.issuedAt),
+      expirationTime: Number(raw.expirationTime)
+    });
+    message = canonical.message;
+  } catch {
+    return { ok: false, reason: "MALFORMED" };
+  }
+  if (message.domain !== expected.domain) return { ok: false, reason: "WRONG_DOMAIN" };
+  if (message.uri !== expected.uri) return { ok: false, reason: "WRONG_URI" };
+  if (message.nonce !== expected.nonce) return { ok: false, reason: "WRONG_NONCE" };
+  const now = expected.now ?? Math.floor(Date.now() / 1e3);
+  if (now >= message.expirationTime) return { ok: false, reason: "EXPIRED" };
+  if (message.issuedAt > now + MAX_SKEW_SECONDS) return { ok: false, reason: "NOT_YET_VALID" };
+  const messageHash = typedData.getMessageHash(canonical, message.address);
+  const onChain = await isValidStarknetSignature(provider, message.address, messageHash, signature);
+  if (onChain.valid) return { ok: true, address: message.address, message };
+  if (onChain.reason !== "ACCOUNT_NOT_DEPLOYED") return { ok: false, reason: "INVALID_SIGNATURE" };
+  if (!deploymentData) return { ok: false, reason: "ACCOUNT_NOT_DEPLOYED" };
+  if (normalizeStarknetAddress(deploymentData.address) !== message.address) {
+    return { ok: false, reason: "ADDRESS_MISMATCH" };
+  }
+  const offChain = verifyUndeployedStarknetSignature(deploymentData, messageHash, signature);
+  return offChain.valid ? { ok: true, address: message.address, message } : { ok: false, reason: offChain.reason };
+}
 
 // src/shhh/index.ts
 init_snip12_hash();
@@ -5369,6 +5622,6 @@ function submitViaAccount(funded) {
   };
 }
 
-export { ANY_CALLER_FELT, APPLE_ISSUER, BOOTSTRAP_DOMAIN_SEPARATOR, ChipiAi, ChipiBrowserSDK, ChipiClient, ChipiPaymasterAdapter, ChipiSDK, ChipiServerSDK, ChipiSessions, ChipiSkuPurchases, ChipiSkus, ChipiTransactions, ChipiTreasury, ChipiWallets, DEFAULT_OP_EXPIRY_SECONDS, ISIGNER_CANONICAL_LABEL, ISIGNER_ID, ISRC9_V2_ID, MAX_OE_VALIDITY_WINDOW_SECONDS, MIN_THRESHOLD_OWNERS, OE_DOMAIN_NAME, OE_DOMAIN_REVISION, OE_DOMAIN_VERSION, OP_ADD_OWNER, OP_REMOVE_OWNER, OP_ROTATE_OWNER, OP_SET_THRESHOLD, ROLE_GUARDIAN, ROLE_OWNER, SIG_VERSION_V1_HEX_ASCII, SIG_VERSION_V2_SNIP12, SIG_VERSION_V2_THRESHOLD, STARKNET_MESSAGE_PREFIX, SessionTxVerifier, ShhhAccount, TIMELOCK_SECONDS, VIEW_SELECTORS, X402Facilitator, X402ShhhClient, assertValidV2Snip12Envelope, buildAddSessionKeyCall, buildBootstrapSignedCall, buildCancelPendingOpCall, buildCancelRecoveryCall, buildEd25519Envelope, buildEd25519EnvelopeFromSignature, buildEip191EnvelopeFromPrivateKey, buildEip191EnvelopeFromSignature, buildExecuteAddOwnerCall, buildExecuteRemoveOwnerCall, buildExecuteRotateOwnerCall, buildExecuteSetThresholdCall, buildFinalizeRecoveryCall, buildInitiateRecoveryCall, buildJwtAppleSubEnvelopeFromTestKey, buildJwtAppleSubEnvelopeFromTokenResponse, buildMigrationCalls, buildOutsideExecution, buildProposeAddOwnerCall, buildProposeRemoveOwnerCall, buildProposeRotateOwnerCall, buildProposeSetThresholdCall, buildRemoveSpendingPolicyCall, buildRevokeSessionKeyCall, buildSessionSetupCalls, buildSetSpendingPolicyCall, buildStarkEnvelope, buildThresholdEnvelope, buildWebAuthnEnvelopeFromAssertion, buildWebAuthnEnvelopeFromPrivateKey, byteArrayToFelts, computeAddressSalt, computeBootstrapMessage, computeISignerId, computeOeHash, computeShhhAddress, computeSnip12Hash, decryptPrivateKey, ed25519OwnerId, ed25519OwnerPubkeyParam, ed25519PubkeyFelts, ed25519SignedBytes, eip191OwnerId, eip191OwnerPubkeyParam, eip191PubkeyFelts, encryptPrivateKey, estimateThresholdGasOverhead, executeShhhSponsoredRaw, hashCall, hashCalls, hashOutsideExecutionStruct, hashStarknetDomain, isReadyToExecute, isThinkDecision, jwtAppleSubHash, jwtAppleSubOwnerId, jwtAppleSubPubkeyFelts, labelToFelt, locateSubClaim, messageHashToNonceB64url, migrateChipiWalletToShhh, normalizeEntrypoints, ownerCommitment, parseAppleIdToken, parseDerEcdsaSignature, parseEip191Signature, parseThresholdEnvelope, resolveShhhChainId, secondsUntilExecutable, serializeExecuteFromOutsideV2Calldata, signBootstrapMessage, signTypedData, signTypedDataArray, snip12HashToHexAsciiBytes, starkOwnerId, starkPubkeyFelts, submitViaAccount, validateSpendingPolicyConfig, waitForTransaction, webauthnOwnerId, webauthnOwnerPubkeyParam, webauthnPubkeyFelts, wrapV2Snip12Envelope, wrapV2ThresholdEnvelope, x402Middleware };
+export { ANY_CALLER_FELT, APPLE_ISSUER, BOOTSTRAP_DOMAIN_SEPARATOR, COUNTERFACTUAL_ACCOUNT_CLASSES, ChipiAi, ChipiBrowserSDK, ChipiClient, ChipiPaymasterAdapter, ChipiSDK, ChipiServerSDK, ChipiSessions, ChipiSkuPurchases, ChipiSkus, ChipiTransactions, ChipiTreasury, ChipiWallets, DEFAULT_OP_EXPIRY_SECONDS, ISIGNER_CANONICAL_LABEL, ISIGNER_ID, ISRC9_V2_ID, MAX_OE_VALIDITY_WINDOW_SECONDS, MIN_THRESHOLD_OWNERS, OE_DOMAIN_NAME, OE_DOMAIN_REVISION, OE_DOMAIN_VERSION, OP_ADD_OWNER, OP_REMOVE_OWNER, OP_ROTATE_OWNER, OP_SET_THRESHOLD, ROLE_GUARDIAN, ROLE_OWNER, SIG_VERSION_V1_HEX_ASCII, SIG_VERSION_V2_SNIP12, SIG_VERSION_V2_THRESHOLD, SIWS_CHAIN_ID, SIWS_DOMAIN_NAME, SIWS_DOMAIN_VERSION, STARKNET_MESSAGE_PREFIX, STARKNET_SIGNATURE_VALID, SessionTxVerifier, ShhhAccount, TIMELOCK_SECONDS, VIEW_SELECTORS, X402Facilitator, X402ShhhClient, assertValidV2Snip12Envelope, buildAddSessionKeyCall, buildBootstrapSignedCall, buildCancelPendingOpCall, buildCancelRecoveryCall, buildEd25519Envelope, buildEd25519EnvelopeFromSignature, buildEip191EnvelopeFromPrivateKey, buildEip191EnvelopeFromSignature, buildExecuteAddOwnerCall, buildExecuteRemoveOwnerCall, buildExecuteRotateOwnerCall, buildExecuteSetThresholdCall, buildFinalizeRecoveryCall, buildInitiateRecoveryCall, buildJwtAppleSubEnvelopeFromTestKey, buildJwtAppleSubEnvelopeFromTokenResponse, buildMigrationCalls, buildOutsideExecution, buildProposeAddOwnerCall, buildProposeRemoveOwnerCall, buildProposeRotateOwnerCall, buildProposeSetThresholdCall, buildRemoveSpendingPolicyCall, buildRevokeSessionKeyCall, buildSessionSetupCalls, buildSetSpendingPolicyCall, buildStarkEnvelope, buildThresholdEnvelope, buildWebAuthnEnvelopeFromAssertion, buildWebAuthnEnvelopeFromPrivateKey, byteArrayToFelts, computeAddressSalt, computeBootstrapMessage, computeISignerId, computeOeHash, computeShhhAddress, computeSnip12Hash, createStarknetSignInTypedData, decryptPrivateKey, ed25519OwnerId, ed25519OwnerPubkeyParam, ed25519PubkeyFelts, ed25519SignedBytes, eip191OwnerId, eip191OwnerPubkeyParam, eip191PubkeyFelts, encryptPrivateKey, estimateThresholdGasOverhead, executeShhhSponsoredRaw, hashCall, hashCalls, hashOutsideExecutionStruct, hashStarknetDomain, isReadyToExecute, isThinkDecision, isValidStarknetSignature, jwtAppleSubHash, jwtAppleSubOwnerId, jwtAppleSubPubkeyFelts, labelToFelt, locateSubClaim, messageHashToNonceB64url, migrateChipiWalletToShhh, normalizeEntrypoints, normalizeStarknetAddress, ownerCommitment, parseAppleIdToken, parseDerEcdsaSignature, parseEip191Signature, parseThresholdEnvelope, resolveShhhChainId, secondsUntilExecutable, serializeExecuteFromOutsideV2Calldata, signBootstrapMessage, signTypedData, signTypedDataArray, snip12HashToHexAsciiBytes, starkOwnerId, starkPubkeyFelts, submitViaAccount, validateSpendingPolicyConfig, verifyStarknetSignIn, verifyUndeployedStarknetSignature, waitForTransaction, webauthnOwnerId, webauthnOwnerPubkeyParam, webauthnPubkeyFelts, wrapV2Snip12Envelope, wrapV2ThresholdEnvelope, x402Middleware };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map