@chipi-stack/backend 14.10.1 → 14.12.0

package/dist/index.js

@@ -966,8 +966,10 @@ var executePaymasterTransaction = async ({
     let walletType = wallet.walletType ?? "READY";
     if (!wallet.walletType) {
       try {
-        const resolveProvider = new starknet.RpcProvider({ nodeUrl: shared.WALLET_RPC_ENDPOINTS.CHIPI });
-        const onChainClassHash = await resolveProvider.getClassHashAt(wallet.publicKey, "latest");
+        const onChainClassHash = await shared.withRpcFallback(
+          (provider2) => provider2.getClassHashAt(wallet.publicKey, "latest"),
+          { fallbackUrl: shared.WALLET_RPC_ENDPOINTS.CHIPI }
+        );
         walletType = shared.getWalletTypeFromClassHash(onChainClassHash) ?? "READY";
       } catch {
       }
@@ -2392,18 +2394,18 @@ var ChipiSessions = class {
   async getSessionData(params) {
     const { walletAddress, sessionPublicKey } = params;
     try {
-      const provider = new starknet.RpcProvider({
-        nodeUrl: shared.WALLET_RPC_ENDPOINTS["CHIPI"]
-      });
       console.log("[ChipiSDK:Session:GetData] Querying session data", {
         walletAddress: walletAddress.slice(0, 15) + "...",
         sessionPubKey: sessionPublicKey.slice(0, 15) + "..."
       });
-      const result = await provider.callContract({
-        contractAddress: walletAddress,
-        entrypoint: shared.SESSION_ENTRYPOINTS.GET_DATA,
-        calldata: [sessionPublicKey]
-      });
+      const result = await shared.withRpcFallback(
+        (provider) => provider.callContract({
+          contractAddress: walletAddress,
+          entrypoint: shared.SESSION_ENTRYPOINTS.GET_DATA,
+          calldata: [sessionPublicKey]
+        }),
+        { fallbackUrl: shared.WALLET_RPC_ENDPOINTS["CHIPI"] }
+      );
       const resultArray = Array.isArray(result) ? result : result.result || [];
       if (resultArray.length < 4) {
         console.warn("[ChipiSDK:Session:GetData] Unexpected response format", {
@@ -2474,7 +2476,9 @@ var ChipiSessions = class {
    * 1. Generated via `createSessionKey()`
    * 2. Registered on-chain via `addSessionKeyToContract()`
    *
-   * CHIPI wallets only - will throw if wallet type is not CHIPI.
+   * CHIPI v29 and SHHH V8.4 only: both embed the SNIP-163 sessions
+   * component. Throws for any other wallet type, notably READY (Argent X),
+   * which does not. See `validateWalletSupportsSessions`.
    *
    * @param params - Session execution parameters
    * @param bearerToken - Authentication token
@@ -2690,19 +2694,19 @@ var ChipiSessions = class {
   async getSpendingPolicy(params) {
     const { walletAddress, sessionPublicKey, token } = params;
     try {
-      const provider = new starknet.RpcProvider({
-        nodeUrl: shared.WALLET_RPC_ENDPOINTS["CHIPI"]
-      });
       console.log("[ChipiSDK:Session:GetSpendingPolicy] Querying spending policy", {
         walletAddress: walletAddress.slice(0, 15) + "...",
         sessionPubKey: sessionPublicKey.slice(0, 15) + "...",
         token: token.slice(0, 15) + "..."
       });
-      const result = await provider.callContract({
-        contractAddress: walletAddress,
-        entrypoint: shared.SESSION_ENTRYPOINTS.GET_SPENDING_POLICY,
-        calldata: [sessionPublicKey, token]
-      });
+      const result = await shared.withRpcFallback(
+        (provider) => provider.callContract({
+          contractAddress: walletAddress,
+          entrypoint: shared.SESSION_ENTRYPOINTS.GET_SPENDING_POLICY,
+          calldata: [sessionPublicKey, token]
+        }),
+        { fallbackUrl: shared.WALLET_RPC_ENDPOINTS["CHIPI"] }
+      );
       const resultArray = Array.isArray(result) ? result : result.result || [];
       if (resultArray.length < 8) {
         console.warn("[ChipiSDK:Session:GetSpendingPolicy] Unexpected response format", {
@@ -2863,6 +2867,83 @@ var ChipiTreasury = class {
     }
     return token;
   }
+  /**
+   * List every treasury owned by the api key's organization (`sk_`).
+   *
+   * This is the discovery entry point for {@link ForTreasuryConfig.treasuryId}.
+   * The secret key resolves the org server-side, so there is no org id to
+   * pass and nothing to look up in the dashboard first. Use it to recover a
+   * `treasuryId` that fell out of your config, or to avoid pinning one in an
+   * environment variable at all.
+   *
+   * Server-only: it needs a `sk_`, so never call it from the browser.
+   *
+   * @example
+   * ```typescript
+   * const { items } = await sdk.treasury.list();
+   * const ops = items.find((t) => t.name === "Ops Treasury");
+   * const transport = sdk.treasury.forTreasury({
+   *   treasuryId: ops.id,
+   *   ownerPubkey,
+   * });
+   * ```
+   */
+  async list(options = {}) {
+    const { page, limit, includeArchived, bearerToken } = options;
+    const params = {};
+    if (page !== void 0) params.page = String(page);
+    if (limit !== void 0) params.limit = String(limit);
+    if (includeArchived !== void 0) {
+      params.includeArchived = String(includeArchived);
+    }
+    const res = await this.client.get({
+      endpoint: shared.API_ENDPOINTS.TREASURIES,
+      params,
+      bearerToken: this.secret(bearerToken)
+    });
+    return { ...res, items: res.items ?? [] };
+  }
+  /**
+   * Read a treasury's risk-tier quorum policy (`sk_`).
+   */
+  async getPolicy(treasuryId, options = {}) {
+    return this.client.get({
+      endpoint: `${shared.API_ENDPOINTS.TREASURIES}/${treasuryId}/policy`,
+      bearerToken: this.secret(options.bearerToken)
+    });
+  }
+  /**
+   * Set a treasury's risk-tier quorums (`sk_`).
+   *
+   * An omitted tier is left unchanged; passing `null` clears it. Configuring
+   * this used to require the dashboard, so an integrator driving governance
+   * from their own server could see a quorum applied to a proposal but never
+   * choose it.
+   *
+   * IMPORTANT: a quorum can only RAISE `requiredApprovals` above the wallet's
+   * on-chain threshold. The chain is the hard floor, so a quorum set below it
+   * produces proposals that reach `APPROVED` here and then revert at execute.
+   *
+   * Server-only: it needs a `sk_`.
+   *
+   * @example
+   * ```typescript
+   * // Founding a pool and borrowing need 3 owners; repaying needs the
+   * // wallet's own threshold.
+   * await sdk.treasury.setPolicy(treasuryId, { sensitiveQuorum: 3 });
+   * ```
+   */
+  async setPolicy(treasuryId, options = {}) {
+    const { routineQuorum, sensitiveQuorum, bearerToken } = options;
+    const body = {};
+    if (routineQuorum !== void 0) body.routineQuorum = routineQuorum;
+    if (sensitiveQuorum !== void 0) body.sensitiveQuorum = sensitiveQuorum;
+    return this.client.patch({
+      endpoint: `${shared.API_ENDPOINTS.TREASURIES}/${treasuryId}/policy`,
+      bearerToken: this.secret(bearerToken),
+      body
+    });
+  }
   /**
    * Build a {@link TreasuryTransport} for one treasury + owner. Wire the
    * returned object directly into chipi-react's `useProposeAction` /
@@ -3547,6 +3628,49 @@ var ChipiBrowserSDK = class extends ChipiSDK {
   // All methods are inherited from ChipiSDK
   // bearerToken parameter is required for each authenticated request
 };
+var DEFAULT_RETRY_INTERVAL_MS = 3e3;
+var DEFAULT_TIMEOUT_MS = 3e5;
+function isPending(finalityStatus) {
+  return finalityStatus === void 0 || finalityStatus === "RECEIVED" || finalityStatus === "PENDING" || finalityStatus === "PRE_CONFIRMED";
+}
+async function waitForTransaction(transactionHash, options = {}) {
+  const {
+    nodeUrl = shared.WALLET_RPC_ENDPOINTS.CHIPI,
+    retryIntervalMs = DEFAULT_RETRY_INTERVAL_MS,
+    timeoutMs = DEFAULT_TIMEOUT_MS
+  } = options;
+  const deadline = Date.now() + timeoutMs;
+  let lastError;
+  for (; ; ) {
+    try {
+      const receipt = await shared.withRpcFallback(
+        (provider) => provider.getTransactionReceipt(transactionHash),
+        { fallbackUrl: nodeUrl }
+      );
+      if (!isPending(receipt?.finality_status)) {
+        const reverted = receipt.execution_status === "REVERTED";
+        return {
+          transactionHash,
+          success: !reverted,
+          executionStatus: receipt.execution_status,
+          finalityStatus: receipt.finality_status,
+          ...reverted ? { revertReason: receipt.revert_reason ?? "reverted on chain" } : {},
+          events: receipt.events ?? [],
+          ...receipt.block_number !== void 0 ? { blockNumber: receipt.block_number } : {}
+        };
+      }
+    } catch (err) {
+      lastError = err;
+    }
+    if (Date.now() + retryIntervalMs >= deadline) {
+      const detail = lastError instanceof Error ? `: ${lastError.message}` : "";
+      throw new Error(
+        `Timed out after ${timeoutMs}ms waiting for ${transactionHash}${detail}. The transaction may still land; re-check before treating it as failed.`
+      );
+    }
+    await new Promise((resolve) => setTimeout(resolve, retryIntervalMs));
+  }
+}
 
 // src/index.ts
 init_encryption2();
@@ -4875,6 +4999,7 @@ exports.snip12HashToHexAsciiBytes = snip12HashToHexAsciiBytes;
 exports.starkOwnerId = starkOwnerId;
 exports.starkPubkeyFelts = starkPubkeyFelts;
 exports.submitViaAccount = submitViaAccount;
+exports.waitForTransaction = waitForTransaction;
 exports.webauthnOwnerId = webauthnOwnerId;
 exports.webauthnOwnerPubkeyParam = webauthnOwnerPubkeyParam;
 exports.webauthnPubkeyFelts = webauthnPubkeyFelts;