@chipi-stack/chipi-react 14.15.1 → 14.17.0

package/dist/index.js

@@ -1340,6 +1340,22 @@ function useSignTypedData() {
     reset: mutation.reset
   };
 }
+function useExternalSignerExecute() {
+  const { chipiSDK } = useChipiContext();
+  const mutation = reactQuery.useMutation({
+    mutationFn: async (input) => chipiSDK.executeWithExternalSigner(input)
+  });
+  return {
+    execute: mutation.mutate,
+    executeAsync: mutation.mutateAsync,
+    data: mutation.data,
+    isLoading: mutation.isPending,
+    isError: mutation.isError,
+    error: mutation.error,
+    isSuccess: mutation.isSuccess,
+    reset: mutation.reset
+  };
+}
 
 // ../node_modules/.pnpm/@starknet-io+types-js@0.9.2/node_modules/@starknet-io/types-js/dist/esm/index.js
 var esm_exports = {};
@@ -20418,6 +20434,41 @@ function hexEq(a, b) {
     return a === b;
   }
 }
+function parseCapAmount(value, field, token) {
+  try {
+    const v = typeof value === "bigint" ? value : BigInt(String(value).trim());
+    if (v < 0n) throw new Error("negative");
+    return v;
+  } catch {
+    throw new Error(
+      `session_spend_cap_invalid: ${field} for token ${token} must be a non-negative integer in base units (got "${String(value)}")`
+    );
+  }
+}
+function toSpendingPolicies(caps, lifetimeSeconds) {
+  return caps.map((cap) => {
+    const policy = "maxPerWindow" in cap ? {
+      token: cap.token,
+      maxPerCall: parseCapAmount(cap.maxPerCall, "maxPerCall", cap.token),
+      maxPerWindow: parseCapAmount(cap.maxPerWindow, "maxPerWindow", cap.token),
+      windowSeconds: cap.windowSeconds
+    } : (() => {
+      const amount = parseCapAmount(cap.amount, "amount", cap.token);
+      return {
+        token: cap.token,
+        maxPerCall: amount,
+        maxPerWindow: amount,
+        windowSeconds: Math.max(1, lifetimeSeconds)
+      };
+    })();
+    if (policy.maxPerWindow === 0n) {
+      throw new Error(
+        `session_spend_cap_zero: the cap for token ${cap.token} resolves to maxPerWindow = 0, which means unlimited on-chain. Use a positive cap.`
+      );
+    }
+    return policy;
+  });
+}
 function sessionCovers(policy, calls) {
   if (!policy?.allowedCalls?.length) return false;
   return calls.every(
@@ -20432,6 +20483,10 @@ function useChipiWalletObject(config3) {
   const { signTypedDataAsync } = useSignTypedData();
   const { createSessionKeyAsync } = useCreateSessionKey();
   const { addSessionKeyToContractAsync } = useAddSessionKeyToContract();
+  const { chipiSDK } = useChipiContext();
+  const sdk = React.useRef(chipiSDK);
+  sdk.current = chipiSDK;
+  const warnedMissingApproval = React.useRef(false);
   const cfg = React.useRef(config3);
   cfg.current = config3;
   const requireWallet = () => {
@@ -20444,28 +20499,33 @@ function useChipiWalletObject(config3) {
       if (policy.validUntil <= nowSec()) throw new Error("session_policy_expired");
       const c = cfg.current;
       const wallet = requireWallet();
+      const lifetimeSeconds = Math.max(1, policy.validUntil - nowSec());
+      const spendingPolicies = policy.spendCaps?.length ? toSpendingPolicies(policy.spendCaps, lifetimeSeconds) : [];
       const encryptKey = await c.getEncryptKey();
       const session = await createSessionKeyAsync({
         encryptKey,
-        durationSeconds: Math.max(1, policy.validUntil - nowSec())
+        durationSeconds: lifetimeSeconds
       });
       const bearerToken = await c.getBearerToken();
-      await addSessionKeyToContractAsync({
-        params: {
-          encryptKey,
-          wallet,
-          sessionConfig: {
-            sessionPublicKey: session.publicKey,
-            validUntil: policy.validUntil,
-            maxCalls: 1e3,
-            // selectors; empty = all entrypoints allowed
-            allowedEntrypoints: policy.allowedCalls.map(
-              (a) => hash_exports.getSelectorFromName(a.entrypoint)
-            )
-          }
-        },
-        bearerToken
-      });
+      const params = {
+        encryptKey,
+        wallet,
+        sessionConfig: {
+          sessionPublicKey: session.publicKey,
+          validUntil: policy.validUntil,
+          maxCalls: 1e3,
+          // Selectors; empty = all entrypoints allowed. On-chain this is a
+          // per-selector whitelist, NOT scoped to allowedCalls' contracts.
+          allowedEntrypoints: policy.allowedCalls.map(
+            (a) => hash_exports.getSelectorFromName(a.entrypoint)
+          )
+        }
+      };
+      if (spendingPolicies.length > 0) {
+        await sdk.current.sessions.setupSession({ ...params, spendingPolicies }, bearerToken);
+      } else {
+        await addSessionKeyToContractAsync({ params, bearerToken });
+      }
       return session;
     },
     [createSessionKeyAsync, addSessionKeyToContractAsync]
@@ -20505,12 +20565,23 @@ function useChipiWalletObject(config3) {
         return signTypedDataAsync({ encryptKey, wallet, typedData });
       },
       getDeploymentData: async () => {
-        throw new Error("account_already_deployed");
+        if (cfg.current.isDeployed === true) throw new Error("account_already_deployed");
+        throw new Error("account_deployment_data_unavailable");
       },
       createSession: async (policy) => {
         await createSession(policy);
       },
-      requestApproval: (req) => cfg.current.requestApproval?.(req) ?? Promise.resolve(true)
+      requestApproval: (req) => {
+        const gate = cfg.current.requestApproval;
+        if (gate) return gate(req);
+        if (!warnedMissingApproval.current) {
+          warnedMissingApproval.current = true;
+          console.warn(
+            "[ChipiSDK:Connect] No `requestApproval` was provided to useChipiWalletObject, so every approval (connect, execute, signTypedData, session) is denied. Pass `requestApproval` to show the user an approval UI and resolve true/false."
+          );
+        }
+        return Promise.resolve(false);
+      }
     }),
     [callAnyContractAsync, executeWithSessionAsync, signTypedDataAsync, createSession]
   );
@@ -21189,11 +21260,35 @@ var RpcError2 = class extends Error {
 var USER_REFUSED_OP = 113;
 var INVALID_REQUEST_PAYLOAD = 114;
 var ACCOUNT_ALREADY_DEPLOYED = 115;
+var NO_DEPLOYMENT_DATA = 116;
 var UNKNOWN_ERROR = 163;
+var MISSING_APPROVAL_WARNING = "[ChipiSDK:Connect] No `requestApproval` was provided, so every approval (connect, execute, signTypedData, session) is denied. Pass `requestApproval` to show the user an approval UI and resolve true/false.";
+function normalizeChainId(value) {
+  try {
+    if (typeof value === "bigint") return value;
+    if (typeof value === "number") {
+      return Number.isSafeInteger(value) && value >= 0 ? BigInt(value) : null;
+    }
+    if (typeof value !== "string" || value.length === 0) return null;
+    if (/^0x[0-9a-f]+$/i.test(value) || /^[0-9]+$/.test(value)) return BigInt(value);
+    return BigInt(shortString_exports.encodeShortString(value));
+  } catch {
+    return null;
+  }
+}
 function createChipiWindowObject(deps) {
   const accountListeners = /* @__PURE__ */ new Set();
   const networkListeners = /* @__PURE__ */ new Set();
-  const approve = deps.requestApproval ?? (async () => true);
+  let approved = false;
+  let pendingConnect = null;
+  let warnedMissingApproval = false;
+  const approve = deps.requestApproval ?? (async () => {
+    if (!warnedMissingApproval) {
+      warnedMissingApproval = true;
+      console.warn(MISSING_APPROVAL_WARNING);
+    }
+    return false;
+  });
   async function requireApproval(req) {
     const ok = await approve(req);
     if (!ok) throw new RpcError2(USER_REFUSED_OP, "User refused the operation");
@@ -21201,19 +21296,27 @@ function createChipiWindowObject(deps) {
   const request = (async (call) => {
     switch (call.type) {
       case "wallet_requestAccounts": {
-        const accounts = await deps.getAccounts();
-        if (accounts.length === 0) {
-          await requireApproval({ type: "connect" });
-          return deps.getAccounts();
+        if (call.params?.silent_mode) {
+          return approved ? deps.getAccounts() : [];
         }
-        return accounts;
+        if (approved) {
+          const accounts = await deps.getAccounts();
+          if (accounts.length > 0) return accounts;
+        }
+        if (!pendingConnect) {
+          pendingConnect = requireApproval({ type: "connect" }).then(() => {
+            approved = true;
+          }).finally(() => {
+            pendingConnect = null;
+          });
+        }
+        await pendingConnect;
+        return deps.getAccounts();
       }
       case "wallet_requestChainId":
         return deps.chainId;
-      case "wallet_getPermissions": {
-        const accounts = await deps.getAccounts();
-        return accounts.length > 0 ? ["accounts"] : [];
-      }
+      case "wallet_getPermissions":
+        return approved ? ["accounts"] : [];
       case "wallet_addInvokeTransaction": {
         const wireCalls = call.params?.calls ?? [];
         if (wireCalls.length === 0) {
@@ -21226,14 +21329,38 @@ function createChipiWindowObject(deps) {
       }
       case "wallet_signTypedData": {
         const typedData = call.params;
+        const domainChainId = typedData?.domain?.chainId;
+        if (domainChainId === void 0 || domainChainId === null) {
+          throw new RpcError2(
+            INVALID_REQUEST_PAYLOAD,
+            `wallet_signTypedData: domain.chainId is required (the wallet chain is ${deps.chainId})`
+          );
+        }
+        const expected = normalizeChainId(deps.chainId);
+        const actual = normalizeChainId(domainChainId);
+        if (actual === null || expected === null || actual !== expected) {
+          throw new RpcError2(
+            INVALID_REQUEST_PAYLOAD,
+            `wallet_signTypedData: domain.chainId ${String(domainChainId)} does not match the wallet chain ${deps.chainId}`
+          );
+        }
         await requireApproval({ type: "signTypedData", typedData });
         return deps.signTypedData(typedData);
       }
       case "wallet_deploymentData":
         try {
           return await deps.getDeploymentData();
-        } catch {
-          throw new RpcError2(ACCOUNT_ALREADY_DEPLOYED, "Account already deployed");
+        } catch (err2) {
+          if (err2 instanceof Error && err2.message === "account_already_deployed") {
+            throw new RpcError2(ACCOUNT_ALREADY_DEPLOYED, "Account already deployed");
+          }
+          if (err2 instanceof Error && err2.message === "account_deployment_data_unavailable") {
+            throw new RpcError2(NO_DEPLOYMENT_DATA, "Account deployment data is not available");
+          }
+          throw new RpcError2(
+            UNKNOWN_ERROR,
+            err2 instanceof Error ? err2.message : "Could not read deployment data"
+          );
         }
       case "wallet_supportedSpecs":
         return SUPPORTED_SPECS;
@@ -21550,6 +21677,7 @@ exports.useChipiWalletObject = useChipiWalletObject;
 exports.useCreateSessionKey = useCreateSessionKey;
 exports.useCreateWallet = useCreateWallet;
 exports.useExecuteWithSession = useExecuteWithSession;
+exports.useExternalSignerExecute = useExternalSignerExecute;
 exports.useGetSessionData = useGetSessionData;
 exports.useGetSku = useGetSku;
 exports.useGetSkuList = useGetSkuList;