@chipi-stack/backend 14.3.1 → 14.6.0

package/dist/skuPurchases.mjs

@@ -1,27 +1,398 @@
-import { Chain, STARKNET_CONTRACTS } from '@chipi-stack/types';
-import { formatAmount, SKU_CONTRACTS, CARRIER_IDS, SERVICE_TYPES, API_ENDPOINTS, WALLET_RPC_ENDPOINTS, WALLET_CLASS_HASHES } from '@chipi-stack/shared';
-import { CallData, cairo, hash, RpcProvider, Account } from 'starknet';
 import CryptoES from 'crypto-es';
+import { hash, CallData, cairo, ec, shortString, RpcProvider, Account } from 'starknet';
+import { formatAmount, SKU_CONTRACTS, CARRIER_IDS, SERVICE_TYPES, API_ENDPOINTS, WALLET_RPC_ENDPOINTS, WALLET_CLASS_HASHES } from '@chipi-stack/shared';
+import { Chain, STARKNET_CONTRACTS } from '@chipi-stack/types';
 
-// src/sku-purchases.ts
-var decryptPrivateKey = (encryptedPrivateKey, password) => {
-  if (!encryptedPrivateKey || !password) {
-    throw new Error("Encrypted private key and password are required");
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var decryptPrivateKey;
+var init_encryption = __esm({
+  "src/lib/encryption.ts"() {
+    decryptPrivateKey = (encryptedPrivateKey, password) => {
+      if (!encryptedPrivateKey || !password) {
+        throw new Error("Encrypted private key and password are required");
+      }
+      try {
+        const bytes = CryptoES.AES.decrypt(encryptedPrivateKey, password);
+        const decrypted = bytes.toString(CryptoES.enc.Utf8);
+        if (!decrypted) {
+          throw new Error("Decryption resulted in empty string");
+        }
+        return decrypted;
+      } catch (error) {
+        if (error instanceof Error) {
+          throw error;
+        }
+        throw new Error(`Decryption failed: ${error}`);
+      }
+    };
+  }
+});
+
+// src/encryption.ts
+var init_encryption2 = __esm({
+  "src/encryption.ts"() {
+    init_encryption();
+  }
+});
+function toBigInt(x) {
+  if (typeof x === "bigint") return x;
+  if (typeof x === "number") return BigInt(x);
+  return BigInt(x);
+}
+function poseidonSpan(values) {
+  const felts = values.map((v) => typeof v === "bigint" ? "0x" + v.toString(16) : v);
+  return BigInt(hash.computePoseidonHashOnElements(felts));
+}
+function hashCall(call) {
+  const calldataFelts = CallData.toHex(
+    Array.isArray(call.calldata) ? call.calldata : [call.calldata]
+  );
+  const calldataItems = calldataFelts.map((x) => BigInt(x));
+  const calldataHash = poseidonSpan(calldataItems);
+  return poseidonSpan([
+    CALL_TYPE_HASH_REV1,
+    toBigInt(call.contractAddress),
+    toBigInt(hash.getSelectorFromName(call.entrypoint)),
+    calldataHash
+  ]);
+}
+function hashCalls(calls) {
+  const callHashes = calls.map(hashCall);
+  return poseidonSpan(callHashes);
+}
+function hashStarknetDomain(chainIdFelt) {
+  return poseidonSpan([
+    STARKNET_DOMAIN_TYPE_HASH_REV1,
+    BigInt(OE_DOMAIN_NAME),
+    OE_DOMAIN_VERSION,
+    toBigInt(chainIdFelt),
+    OE_DOMAIN_REVISION
+  ]);
+}
+function hashOutsideExecutionStruct(oe) {
+  const callsArrayHash = hashCalls(oe.calls);
+  return poseidonSpan([
+    OUTSIDE_EXECUTION_TYPE_HASH_REV1,
+    toBigInt(oe.caller),
+    toBigInt(oe.nonce),
+    oe.execute_after,
+    oe.execute_before,
+    callsArrayHash
+  ]);
+}
+function computeSnip12Hash(oe, contractAddress, chainIdFelt) {
+  const domainHash = hashStarknetDomain(chainIdFelt);
+  const structHash = hashOutsideExecutionStruct(oe);
+  return poseidonSpan([
+    BigInt(STARKNET_MESSAGE_PREFIX),
+    domainHash,
+    toBigInt(contractAddress),
+    structHash
+  ]);
+}
+function snip12HashToHexAsciiBytes(h) {
+  const hex = h.toString(16).padStart(64, "0");
+  return new TextEncoder().encode(hex);
+}
+var OUTSIDE_EXECUTION_TYPE_HASH_REV1, CALL_TYPE_HASH_REV1, STARKNET_DOMAIN_TYPE_HASH_REV1, STARKNET_MESSAGE_PREFIX, OE_DOMAIN_NAME, OE_DOMAIN_VERSION, OE_DOMAIN_REVISION, SIG_VERSION_V2_SNIP12, SIG_VERSION_V2_THRESHOLD;
+var init_snip12_hash = __esm({
+  "src/shhh/snip12-hash.ts"() {
+    OUTSIDE_EXECUTION_TYPE_HASH_REV1 = 0x5a4b49e17039355cd95d1f0981d75901191d1319b1f4b05a9a791d218d7e0cn;
+    CALL_TYPE_HASH_REV1 = 0x3635c7f2a7ba93844c0d064e18e487f35ab90f7c39d00f186a781fc3f0c2ca9n;
+    STARKNET_DOMAIN_TYPE_HASH_REV1 = 0x1ff2f602e42168014d405a94f75e8a93d640751d71d16311266e140d8b0a210n;
+    STARKNET_MESSAGE_PREFIX = shortString.encodeShortString("StarkNet Message");
+    OE_DOMAIN_NAME = shortString.encodeShortString("Account.execute_from_outside");
+    OE_DOMAIN_VERSION = 2n;
+    OE_DOMAIN_REVISION = 1n;
+    shortString.encodeShortString("V1_HEX_ASCII");
+    SIG_VERSION_V2_SNIP12 = shortString.encodeShortString("V2_SNIP12");
+    SIG_VERSION_V2_THRESHOLD = shortString.encodeShortString("V2_THRESHOLD");
+    BigInt(
+      "0x1d1144bb2138366ff28d8e9ab57456b1d332ac42196230c3a602003c89872"
+    );
+    BigInt(
+      "0x94c5a761f34b25a4e603c651ac0e1fc4fad9cdb5517f7fa1bb54044c7e5ef8"
+    );
+  }
+});
+var init_threshold = __esm({
+  "src/shhh/threshold.ts"() {
+    init_snip12_hash();
+    BigInt(SIG_VERSION_V2_SNIP12);
+    BigInt(SIG_VERSION_V2_THRESHOLD);
+  }
+});
+function buildOutsideExecution(params) {
+  const nowSec = BigInt(Math.floor(Date.now() / 1e3));
+  const after = params.executeAfter ?? nowSec - BigInt(OE_EXECUTE_AFTER_CLOCK_SKEW_BUFFER);
+  const before = params.executeBefore ?? nowSec + BigInt(MAX_OE_VALIDITY_WINDOW_SECONDS) - BigInt(OE_EXECUTE_AFTER_CLOCK_SKEW_BUFFER);
+  if (before <= after) {
+    throw new Error(
+      `executeBefore (${before}) must be strictly greater than executeAfter (${after}).`
+    );
+  }
+  if (before - after > BigInt(MAX_OE_VALIDITY_WINDOW_SECONDS)) {
+    throw new Error(
+      `OE validity window ${before - after}s exceeds max ${MAX_OE_VALIDITY_WINDOW_SECONDS}s (audit M-2). Adjust executeBefore.`
+    );
+  }
+  return {
+    caller: params.caller ?? ANY_CALLER_FELT,
+    nonce: params.nonce,
+    execute_after: after,
+    execute_before: before,
+    calls: params.calls
+  };
+}
+function computeOeHash(oe, accountAddress, chainId) {
+  return computeSnip12Hash(oe, accountAddress, chainId);
+}
+function wrapV2Snip12Envelope(params) {
+  const tag = typeof params.kindTag === "bigint" ? params.kindTag : BigInt(shortString.encodeShortString(params.kindTag));
+  return [
+    BigInt(SIG_VERSION_V2_SNIP12),
+    params.ownerId,
+    tag,
+    ...params.payload.map((v) => typeof v === "bigint" ? v : BigInt(v))
+  ];
+}
+var ANY_CALLER_FELT, MAX_OE_VALIDITY_WINDOW_SECONDS, OE_EXECUTE_AFTER_CLOCK_SKEW_BUFFER;
+var init_oe = __esm({
+  "src/shhh/oe.ts"() {
+    init_snip12_hash();
+    init_threshold();
+    ANY_CALLER_FELT = BigInt(shortString.encodeShortString("ANY_CALLER"));
+    MAX_OE_VALIDITY_WINDOW_SECONDS = 2 * 60 * 60;
+    OE_EXECUTE_AFTER_CLOCK_SKEW_BUFFER = 60;
+  }
+});
+var init_compute_wallet_address = __esm({
+  "src/shhh/compute-wallet-address.ts"() {
+  }
+});
+function buildStarkEnvelope(params) {
+  const pkHex = "0x" + (typeof params.privateKey === "bigint" ? params.privateKey : BigInt(params.privateKey)).toString(16).padStart(64, "0");
+  const sig = ec.starkCurve.sign("0x" + params.messageHash.toString(16), pkHex);
+  const r = BigInt("0x" + sig.r.toString(16));
+  const s = BigInt("0x" + sig.s.toString(16));
+  const ownerIndex = params.ownerIndex ?? 0n;
+  if (ownerIndex < 0n || ownerIndex >= 0x100000000n) {
+    throw new Error(
+      `buildStarkEnvelope: ownerIndex ${ownerIndex} is out of u32 range [0, 2^32). owner_id is the u32 INDEX into the wallet's owner_set (0 for primary, 1 for second, etc.); do NOT pass an owner_commitment or pubkey here.`
+    );
+  }
+  return wrapV2Snip12Envelope({
+    ownerId: ownerIndex,
+    kindTag: STARK_KIND_TAG,
+    payload: [r, s]
+  });
+}
+var STARK_KIND_TAG;
+var init_stark = __esm({
+  "src/shhh/signers/stark.ts"() {
+    init_compute_wallet_address();
+    init_oe();
+    STARK_KIND_TAG = "STARK";
+    BigInt(shortString.encodeShortString(STARK_KIND_TAG));
   }
+});
+async function ensureGaragaInit() {
+  if (garagaInitPromise) return garagaInitPromise;
+  const attempt = (async () => {
+    const garaga = await import('garaga');
+    await garaga.init();
+    return garaga;
+  })();
+  garagaInitPromise = attempt;
   try {
-    const bytes = CryptoES.AES.decrypt(encryptedPrivateKey, password);
-    const decrypted = bytes.toString(CryptoES.enc.Utf8);
-    if (!decrypted) {
-      throw new Error("Decryption resulted in empty string");
+    return await attempt;
+  } catch (err) {
+    if (garagaInitPromise === attempt) garagaInitPromise = null;
+    throw err;
+  }
+}
+function bytesToLeBigInt(bytes) {
+  let x = 0n;
+  for (let i = bytes.length - 1; i >= 0; i--) x = x << 8n | BigInt(bytes[i]);
+  return x;
+}
+function ed25519SignedBytes(messageHash) {
+  return snip12HashToHexAsciiBytes(messageHash);
+}
+async function buildEd25519Envelope(params) {
+  const ownerIndex = params.ownerIndex ?? 0n;
+  if (ownerIndex < 0n || ownerIndex >= 0x100000000n) {
+    throw new Error(
+      `buildEd25519Envelope: ownerIndex ${ownerIndex} is out of u32 range [0, 2^32). owner_id is the u32 INDEX into the wallet's owner_set (0 for primary, 1 for second, etc.); do NOT pass an owner_commitment or pubkey here.`
+    );
+  }
+  if (params.privateKey.length !== 32) {
+    throw new Error(
+      `Ed25519 private key must be exactly 32 bytes; got ${params.privateKey.length}.`
+    );
+  }
+  const ed = await import('@noble/ed25519');
+  const garaga = await ensureGaragaInit();
+  const publicKey = await ed.getPublicKeyAsync(params.privateKey);
+  const signedBytes = ed25519SignedBytes(params.messageHash);
+  const signature = await ed.signAsync(signedBytes, params.privateKey);
+  const R = signature.slice(0, 32);
+  const s = signature.slice(32, 64);
+  const payload = garaga.eddsaCalldataBuilder(
+    bytesToLeBigInt(R),
+    bytesToLeBigInt(s),
+    bytesToLeBigInt(publicKey),
+    signedBytes,
+    false
+  );
+  return wrapV2Snip12Envelope({
+    ownerId: ownerIndex,
+    kindTag: ED25519_KIND_TAG,
+    payload
+  });
+}
+var ED25519_KIND_TAG, garagaInitPromise;
+var init_ed25519 = __esm({
+  "src/shhh/signers/ed25519.ts"() {
+    init_compute_wallet_address();
+    init_oe();
+    init_snip12_hash();
+    ED25519_KIND_TAG = "ED25519";
+    BigInt(shortString.encodeShortString(ED25519_KIND_TAG));
+    garagaInitPromise = null;
+  }
+});
+
+// src/shhh/execute-paymaster-raw.ts
+var execute_paymaster_raw_exports = {};
+__export(execute_paymaster_raw_exports, {
+  executeShhhSponsoredRaw: () => executeShhhSponsoredRaw,
+  resolveShhhChainId: () => resolveShhhChainId,
+  serializeExecuteFromOutsideV2Calldata: () => serializeExecuteFromOutsideV2Calldata
+});
+function resolveShhhChainId(params) {
+  if (params.override !== void 0) {
+    return typeof params.override === "bigint" ? "0x" + params.override.toString(16) : params.override;
+  }
+  const url = (params.baseUrl ?? "").toLowerCase();
+  if (url.includes("sepolia")) return SN_SEPOLIA_CHAIN_ID;
+  return SN_MAIN_CHAIN_ID;
+}
+function serializeExecuteFromOutsideV2Calldata(params) {
+  const out = [];
+  const oe = params.outsideExecution;
+  const toBig = (v) => typeof v === "bigint" ? v : BigInt(v);
+  out.push(toBig(oe.caller));
+  out.push(toBig(oe.nonce));
+  out.push(oe.execute_after);
+  out.push(oe.execute_before);
+  out.push(BigInt(oe.calls.length));
+  for (const call of oe.calls) {
+    out.push(BigInt(call.contractAddress));
+    out.push(BigInt(hash.getSelectorFromName(call.entrypoint)));
+    const callData = Array.isArray(call.calldata) ? call.calldata : [];
+    out.push(BigInt(callData.length));
+    for (const datum of callData) {
+      out.push(typeof datum === "bigint" ? datum : BigInt(datum));
     }
-    return decrypted;
-  } catch (error) {
-    if (error instanceof Error) {
-      throw error;
+  }
+  out.push(BigInt(params.signature.length));
+  for (const sigFelt of params.signature) {
+    out.push(sigFelt);
+  }
+  return out.map((v) => "0x" + v.toString(16));
+}
+function newOeNonce() {
+  const tsMs = BigInt(Date.now());
+  const rand = BigInt(Math.floor(Math.random() * 16777215));
+  return tsMs << 24n | rand;
+}
+async function executeShhhSponsoredRaw(params) {
+  const signerKind = params.signerKind ?? "STARK";
+  const SDK_SHIPPED_OE_KINDS = ["STARK", "ED25519"];
+  if (!SDK_SHIPPED_OE_KINDS.includes(signerKind)) {
+    throw new Error(
+      `SHHH signerKind="${signerKind}" is not yet shipped from the SDK (Wave B ships STARK + ED25519). Wait for the follow-up PR that adds external-rooted (MetaMask, Phantom, passkey, Apple) signing.`
+    );
+  }
+  const privateKeyHex = decryptPrivateKey(params.wallet.encryptedPrivateKey, params.encryptKey);
+  if (!privateKeyHex) {
+    throw new Error(
+      "Failed to decrypt private key for SHHH OE. Verify the encryptKey matches the one used at wallet creation."
+    );
+  }
+  const oe = buildOutsideExecution({
+    nonce: params.nonce ?? newOeNonce(),
+    calls: params.calls,
+    caller: ANY_CALLER_FELT
+  });
+  const chainId = resolveShhhChainId({
+    override: params.chainId,
+    baseUrl: params.client.baseUrl
+  });
+  const messageHash = computeOeHash(oe, params.wallet.publicKey, chainId);
+  let signature;
+  if (signerKind === "STARK") {
+    signature = buildStarkEnvelope({
+      privateKey: privateKeyHex,
+      messageHash
+    });
+  } else {
+    const edKeyHex = privateKeyHex.startsWith("0x") ? privateKeyHex.slice(2) : privateKeyHex;
+    if (edKeyHex.length !== 64) {
+      throw new Error(
+        `SHHH ED25519 private key is ${edKeyHex.length} hex chars; expected 64 (32 raw bytes). The stored ciphertext does not look like a Chipi-held Ed25519 key \u2014 check wallet provenance.`
+      );
     }
-    throw new Error(`Decryption failed: ${error}`);
+    const edPrivKey = Uint8Array.from(Buffer.from(edKeyHex, "hex"));
+    signature = await buildEd25519Envelope({
+      privateKey: edPrivKey,
+      messageHash
+    });
   }
-};
+  const calldata = serializeExecuteFromOutsideV2Calldata({
+    outsideExecution: oe,
+    signature
+  });
+  const response = await params.client.post({
+    endpoint: "/transactions/execute-sponsored-raw",
+    bearerToken: params.bearerToken,
+    body: {
+      accountAddress: params.wallet.publicKey,
+      calldata,
+      signerKind,
+      ...params.externalUserId ? { externalUserId: params.externalUserId } : {}
+    }
+  });
+  if (!response || !response.transactionHash) {
+    throw new Error(
+      "execute-sponsored-raw response missing transactionHash. Check the chipi-back logs for upstream paymaster errors."
+    );
+  }
+  return response.transactionHash;
+}
+var SN_MAIN_CHAIN_ID, SN_SEPOLIA_CHAIN_ID;
+var init_execute_paymaster_raw = __esm({
+  "src/shhh/execute-paymaster-raw.ts"() {
+    init_encryption2();
+    init_oe();
+    init_stark();
+    init_ed25519();
+    SN_MAIN_CHAIN_ID = "0x534e5f4d41494e";
+    SN_SEPOLIA_CHAIN_ID = "0x534e5f5345504f4c4941";
+  }
+});
+
+// src/execute-paymaster-transaction.ts
+init_encryption2();
 function normalizeSignature(signature) {
   if (Array.isArray(signature)) {
     if (signature.length < 2) {
@@ -61,6 +432,22 @@ var executePaymasterTransaction = async ({
       );
     }
     const walletType = wallet.walletType ?? "READY";
+    if (walletType === "SHHH") {
+      const { executeShhhSponsoredRaw: executeShhhSponsoredRaw2 } = await Promise.resolve().then(() => (init_execute_paymaster_raw(), execute_paymaster_raw_exports));
+      const shhhSignerKind = (wallet.signerKind ?? "STARK") || "STARK";
+      return await executeShhhSponsoredRaw2({
+        client,
+        bearerToken,
+        wallet: {
+          publicKey: wallet.publicKey,
+          encryptedPrivateKey: wallet.encryptedPrivateKey,
+          walletType: wallet.walletType
+        },
+        encryptKey,
+        calls,
+        signerKind: shhhSignerKind
+      });
+    }
     const isKnownType = Object.prototype.hasOwnProperty.call(WALLET_RPC_ENDPOINTS, walletType) && Object.prototype.hasOwnProperty.call(WALLET_CLASS_HASHES, walletType);
     const rpcUrl = isKnownType ? WALLET_RPC_ENDPOINTS[walletType] : WALLET_RPC_ENDPOINTS["CHIPI"];
     const accountClassHash = isKnownType ? WALLET_CLASS_HASHES[walletType] : WALLET_CLASS_HASHES["CHIPI"];
@@ -273,9 +660,9 @@ var ChipiTransactions = class {
   /**
    * Get on-chain transaction status
    */
-  async getTransactionStatus(hash2, bearerToken) {
+  async getTransactionStatus(hash5, bearerToken) {
     return this.client.get({
-      endpoint: `${API_ENDPOINTS.TRANSACTIONS}/${hash2}/status`,
+      endpoint: `${API_ENDPOINTS.TRANSACTIONS}/${hash5}/status`,
       bearerToken
     });
   }