@chipi-stack/backend 14.6.0 → 14.8.0

package/dist/index.js

@@ -405,21 +405,52 @@ async function buildEd25519Envelope(params) {
     );
   }
   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),
+  return assembleEd25519Envelope({
+    R: signature.slice(0, 32),
+    s: signature.slice(32, 64),
+    publicKey,
     signedBytes,
+    ownerIndex
+  });
+}
+async function buildEd25519EnvelopeFromSignature(params) {
+  const ownerIndex = params.ownerIndex ?? 0n;
+  if (ownerIndex < 0n || ownerIndex >= 0x100000000n) {
+    throw new Error(
+      `buildEd25519EnvelopeFromSignature: 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); do NOT pass an owner_commitment or pubkey here.`
+    );
+  }
+  if (params.signature.length !== 64) {
+    throw new Error(
+      `Ed25519 signature must be exactly 64 bytes (R\u2016s); got ${params.signature.length}.`
+    );
+  }
+  if (params.publicKey.length !== 32) {
+    throw new Error(`Ed25519 public key must be exactly 32 bytes; got ${params.publicKey.length}.`);
+  }
+  const signedBytes = ed25519SignedBytes(params.messageHash);
+  return assembleEd25519Envelope({
+    R: params.signature.slice(0, 32),
+    s: params.signature.slice(32, 64),
+    publicKey: params.publicKey,
+    signedBytes,
+    ownerIndex
+  });
+}
+async function assembleEd25519Envelope(parts) {
+  const garaga = await ensureGaragaInit();
+  const payload = garaga.eddsaCalldataBuilder(
+    bytesToLeBigInt(parts.R),
+    bytesToLeBigInt(parts.s),
+    bytesToLeBigInt(parts.publicKey),
+    parts.signedBytes,
     false
   );
   return wrapV2Snip12Envelope({
-    ownerId: ownerIndex,
+    ownerId: parts.ownerIndex,
     kindTag: ED25519_KIND_TAG,
     payload
   });
@@ -1434,12 +1465,17 @@ var ChipiWallets = class {
       }
       const isShhh = walletType === "SHHH";
       const effectiveSignerKind = isShhh ? params.signerKind ?? "STARK" : void 0;
-      const SDK_SHIPPED_SHHH_KINDS = ["STARK", "ED25519"];
+      const SDK_SHIPPED_SHHH_KINDS = [
+        "STARK",
+        "ED25519",
+        "WEBAUTHN_P256",
+        "EIP191_SECP256K1"
+      ];
       if (isShhh && !SDK_SHIPPED_SHHH_KINDS.includes(
         effectiveSignerKind
       )) {
         throw new Error(
-          `SHHH signerKind=${effectiveSignerKind} is not yet shipped from the SDK (Wave B ships STARK + ED25519). Use signerKind="STARK" or "ED25519", or wait for the follow-up PRs that add external-rooted (MetaMask, Phantom, passkey, Apple) deploy support.`
+          `SHHH signerKind=${effectiveSignerKind} is not yet shipped from the SDK (supports STARK, ED25519, WEBAUTHN_P256, EIP191_SECP256K1). JWT_ES256_APPLE_SUB and others remain deferred to their follow-up PRs (OAuth / Apple-Developer context).`
         );
       }
       const rpcUrl = walletType === "READY" ? shared.WALLET_RPC_ENDPOINTS.READY : shared.WALLET_RPC_ENDPOINTS.CHIPI;
@@ -1474,6 +1510,14 @@ var ChipiWallets = class {
             pubkeyFelts = ed25519PubkeyFelts(edPubKey);
             shhhPrivateKeyHex = Buffer.from(edPrivKey).toString("hex");
           }
+        } else if (effectiveSignerKind === "WEBAUTHN_P256" || effectiveSignerKind === "EIP191_SECP256K1") {
+          if (!params.ownerPubkeyFelts || params.ownerPubkeyFelts.length !== 4) {
+            throw new Error(
+              `SHHH ${effectiveSignerKind} ownerPubkeyFelts must be [x_low, x_high, y_low, y_high] (4 felts); got ${params.ownerPubkeyFelts?.length ?? 0}.`
+            );
+          }
+          pubkeyFelts = params.ownerPubkeyFelts.map((s) => BigInt(s));
+          shhhPrivateKeyHex = "";
         } else {
           throw new Error(
             `SHHH signerKind=${effectiveSignerKind} reached the address-derivation block without an implementation.`
@@ -1584,12 +1628,18 @@ var ChipiWallets = class {
           userSignature: userSignaturePayload,
           typedData: typedData2,
           ...encryptedPrivateKey !== void 0 && { encryptedPrivateKey },
-          // SHHH: write the signer kind to the new wallet row. P0.3's
-          // STARK-only path uses a Chipi-held STARK key, so
-          // ownerPublicKey stays unset (encryptedPrivateKey carries
-          // the same key the verifier checks against). External-rooted
-          // wallets will pass ownerPublicKey instead in a follow-up PR.
+          // SHHH: write the signer kind to the new wallet row.
           ...isShhh && { signerKind: effectiveSignerKind },
+          // External-rooted SHHH (passkey / MetaMask / Phantom): no
+          // Chipi-held key, so chipi-back needs the pubkey felts (address
+          // derivation) + `ownerPublicKey` as the credential source it
+          // stores (encryptedPrivateKey stays null). Canonical
+          // ownerPublicKey = comma-joined felts. STARK / Chipi-held kinds
+          // are untouched — encryptedPrivateKey is their credential source.
+          ...isShhh && encryptedPrivateKey === void 0 && shhhOwnerPubkeyFelts && {
+            ownerPubkeyFelts: shhhOwnerPubkeyFelts,
+            ownerPublicKey: shhhOwnerPubkeyFelts.join(",")
+          },
           ...encryptedPrivateKeyBackup && { encryptedPrivateKeyBackup },
           ...params.authMethod && { authMethod: params.authMethod },
           ...params.credentialId && { credentialId: params.credentialId },
@@ -2776,6 +2826,79 @@ var ChipiSessions = class {
     }
   }
 };
+var ChipiTreasury = class {
+  constructor(client, apiSecretKey) {
+    this.client = client;
+    this.apiSecretKey = apiSecretKey;
+  }
+  base(treasuryId) {
+    return `${shared.API_ENDPOINTS.TREASURIES}/${treasuryId}/transactions`;
+  }
+  /** Resolve a `sk_` for the secret-gated reads/execute, or fail loudly. */
+  secret(bearerToken) {
+    const token = bearerToken ?? this.apiSecretKey;
+    if (!token) {
+      throw new Error(
+        "A secret key (sk_) is required for treasury execute / list / allowance. Pass `bearerToken` to forTreasury(...) or configure the SDK with apiSecretKey. Call these from a server, never the browser."
+      );
+    }
+    return token;
+  }
+  /**
+   * Build a {@link TreasuryTransport} for one treasury + owner. Wire the
+   * returned object directly into chipi-react's `useProposeAction` /
+   * `useTreasuryProposals` `transport` prop, or call its methods yourself.
+   */
+  forTreasury(config) {
+    const { treasuryId, ownerPubkey } = config;
+    const base = this.base(treasuryId);
+    return {
+      // sk_ — read the proposal list. chipi-back returns
+      // { items, total, page, limit, hasMore }; the hook only reads `items`.
+      list: async () => {
+        const res = await this.client.get({
+          endpoint: base,
+          bearerToken: this.secret(config.bearerToken)
+        });
+        return { ...res, items: res.items ?? [] };
+      },
+      // pk_ + owner sig — no secret. `ownerPubkey` lets the backend verify the
+      // proposer envelope. `meta` (if present) is stripped server-side.
+      propose: async (body) => {
+        return this.client.post({
+          endpoint: base,
+          // Empty string → no Authorization header; the pk_ travels in
+          // x-api-key, which ApiKeyGuard accepts for propose.
+          bearerToken: "",
+          body: { ...body, ownerPubkey }
+        });
+      },
+      // pk_ + owner sig — approve an existing proposal.
+      sign: async (proposalId, body) => {
+        return this.client.post({
+          endpoint: `${base}/${proposalId}/sign`,
+          bearerToken: "",
+          body: { ...body, ownerPubkey }
+        });
+      },
+      // sk_ — relay the assembled threshold calldata through the paymaster.
+      execute: async (proposalId, calldata) => {
+        return this.client.post({
+          endpoint: `${base}/${proposalId}/execute`,
+          bearerToken: this.secret(config.bearerToken),
+          body: { calldata }
+        });
+      },
+      // sk_ — the free-execute meter (org-scoped).
+      getMultisigAllowance: async () => {
+        return this.client.get({
+          endpoint: `${shared.API_ENDPOINTS.TREASURIES}/${treasuryId}/multisig-allowance`,
+          bearerToken: this.secret(config.bearerToken)
+        });
+      }
+    };
+  }
+};
 var InMemoryNonceStore = class {
   constructor() {
     this.used = /* @__PURE__ */ new Set();
@@ -3055,6 +3178,7 @@ var ChipiSDK = class {
     this.skus = new ChipiSkus(this.client);
     this.sessions = new ChipiSessions(this.client);
     this.exchanges = new ChipiExchanges(this.client);
+    this.treasury = new ChipiTreasury(this.client, config.apiSecretKey);
     this.executeTransaction = this.executeTransaction.bind(this);
     this.executeTransactionWithSession = this.executeTransactionWithSession.bind(this);
     this.transfer = this.transfer.bind(this);
@@ -3190,9 +3314,7 @@ var ChipiSDK = class {
    * });
    * ```
    */
-  async signTypedData({
-    params
-  }) {
+  async signTypedData({ params }) {
     return signTypedData({ params });
   }
   /**
@@ -4517,6 +4639,7 @@ exports.ChipiSessions = ChipiSessions;
 exports.ChipiSkuPurchases = ChipiSkuPurchases;
 exports.ChipiSkus = ChipiSkus;
 exports.ChipiTransactions = ChipiTransactions;
+exports.ChipiTreasury = ChipiTreasury;
 exports.ChipiWallets = ChipiWallets;
 exports.DEFAULT_OP_EXPIRY_SECONDS = DEFAULT_OP_EXPIRY_SECONDS;
 exports.OP_ADD_OWNER = OP_ADD_OWNER;
@@ -4534,6 +4657,7 @@ exports.buildBootstrapSignedCall = buildBootstrapSignedCall;
 exports.buildCancelPendingOpCall = buildCancelPendingOpCall;
 exports.buildCancelRecoveryCall = buildCancelRecoveryCall;
 exports.buildEd25519Envelope = buildEd25519Envelope;
+exports.buildEd25519EnvelopeFromSignature = buildEd25519EnvelopeFromSignature;
 exports.buildEip191EnvelopeFromPrivateKey = buildEip191EnvelopeFromPrivateKey;
 exports.buildEip191EnvelopeFromSignature = buildEip191EnvelopeFromSignature;
 exports.buildExecuteAddOwnerCall = buildExecuteAddOwnerCall;