@nibgate/sdk 0.2.8 → 0.2.10

package/dist/nibgate.js

@@ -33,32 +33,156 @@ var Nibgate = (() => {
     }
   });
 
+  // src/browser/schemes/batch-scheme.js
+  function supportsBatching(requirements) {
+    const extra = requirements.extra;
+    if (!extra) return false;
+    return extra.name === CIRCLE_BATCHING_NAME && extra.version === CIRCLE_BATCHING_VERSION;
+  }
+  function getVerifyingContract(requirements) {
+    if (!supportsBatching(requirements)) return void 0;
+    return requirements.extra?.verifyingContract;
+  }
+  function createNonce() {
+    const bytes = new Uint8Array(32);
+    crypto.getRandomValues(bytes);
+    return "0x" + Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  function getAddress(value) {
+    return value && typeof value === "string" && value.startsWith("0x") ? value.toLowerCase() : value;
+  }
+  var CIRCLE_BATCHING_NAME, CIRCLE_BATCHING_VERSION, GATEWAY_MIN_AUTH_VALIDITY_SECONDS, GATEWAY_AUTH_VALIDITY_WINDOW_SECONDS, authorizationTypes, BatchEvmScheme;
+  var init_batch_scheme = __esm({
+    "src/browser/schemes/batch-scheme.js"() {
+      CIRCLE_BATCHING_NAME = "GatewayWalletBatched";
+      CIRCLE_BATCHING_VERSION = "1";
+      GATEWAY_MIN_AUTH_VALIDITY_SECONDS = 7 * 24 * 60 * 60;
+      GATEWAY_AUTH_VALIDITY_WINDOW_SECONDS = GATEWAY_MIN_AUTH_VALIDITY_SECONDS + 100;
+      authorizationTypes = {
+        TransferWithAuthorization: [
+          { name: "from", type: "address" },
+          { name: "to", type: "address" },
+          { name: "value", type: "uint256" },
+          { name: "validAfter", type: "uint256" },
+          { name: "validBefore", type: "uint256" },
+          { name: "nonce", type: "bytes32" }
+        ]
+      };
+      BatchEvmScheme = class {
+        constructor(signer) {
+          this.signer = signer;
+          this.scheme = CIRCLE_BATCHING_NAME;
+          this._beforeHooks = [];
+          this._afterHooks = [];
+          this._failureHooks = [];
+        }
+        onBeforePaymentCreation(hook) {
+          this._beforeHooks.push(hook);
+          return this;
+        }
+        onAfterPaymentCreation(hook) {
+          this._afterHooks.push(hook);
+          return this;
+        }
+        onPaymentCreationFailure(hook) {
+          this._failureHooks.push(hook);
+          return this;
+        }
+        async createPaymentPayload(x402Version, paymentRequirements) {
+          const context = {
+            paymentRequired: { x402Version, accepts: [paymentRequirements] },
+            selectedRequirements: paymentRequirements
+          };
+          for (const hook of this._beforeHooks) {
+            const result = await hook(context);
+            if (result && result.abort) {
+              throw new Error("Payment creation aborted: " + result.reason);
+            }
+          }
+          try {
+            if (!supportsBatching(paymentRequirements)) {
+              throw new Error(
+                'BatchEvmScheme can only handle Circle batching options. Expected extra.name="' + CIRCLE_BATCHING_NAME + '" and extra.version="' + CIRCLE_BATCHING_VERSION + '"'
+              );
+            }
+            const verifyingContract = getVerifyingContract(paymentRequirements);
+            if (!verifyingContract) {
+              throw new Error(
+                "Circle batching option missing extra.verifyingContract (GatewayWallet address)"
+              );
+            }
+            const nonce = createNonce();
+            const now = Math.floor(Date.now() / 1e3);
+            const validityWindowSeconds = Math.max(
+              paymentRequirements.maxTimeoutSeconds || 0,
+              GATEWAY_AUTH_VALIDITY_WINDOW_SECONDS
+            );
+            const authorization = {
+              from: getAddress(this.signer.address),
+              to: getAddress(paymentRequirements.payTo),
+              value: paymentRequirements.amount,
+              validAfter: String(now - 600),
+              validBefore: String(now + validityWindowSeconds),
+              nonce
+            };
+            const signature = await this.signAuthorization(authorization, paymentRequirements, verifyingContract);
+            const payload = { authorization, signature };
+            const result = { x402Version, payload };
+            const createdContext = { ...context, paymentPayload: result };
+            for (const hook of this._afterHooks) {
+              try {
+                await hook(createdContext);
+              } catch {
+              }
+            }
+            return result;
+          } catch (error) {
+            const failureContext = { ...context, error };
+            for (const hook of this._failureHooks) {
+              const result = await hook(failureContext);
+              if (result && result.recovered) {
+                return { x402Version: result.payload.x402Version, payload: result.payload.payload };
+              }
+            }
+            throw error;
+          }
+        }
+        async signAuthorization(authorization, requirements, verifyingContract) {
+          if (!requirements.network.startsWith("eip155:")) {
+            throw new Error('BatchEvmScheme: unsupported network format "' + requirements.network + '". Expected "eip155:<chainId>"');
+          }
+          const chainId = parseInt(requirements.network.split(":")[1], 10);
+          const domain = {
+            name: CIRCLE_BATCHING_NAME,
+            version: CIRCLE_BATCHING_VERSION,
+            chainId,
+            verifyingContract: getAddress(verifyingContract)
+          };
+          const message = {
+            from: getAddress(authorization.from),
+            to: getAddress(authorization.to),
+            value: BigInt(authorization.value),
+            validAfter: BigInt(authorization.validAfter),
+            validBefore: BigInt(authorization.validBefore),
+            nonce: authorization.nonce
+          };
+          const typedData = {
+            domain,
+            types: authorizationTypes,
+            primaryType: "TransferWithAuthorization",
+            message
+          };
+          return this.signer.signTypedData(typedData);
+        }
+      };
+    }
+  });
+
   // src/browser/gateway.js
   var gateway_exports = {};
   __export(gateway_exports, {
     createCircleGatewayBrowserAdapter: () => createCircleGatewayBrowserAdapter
   });
-  async function getCircleClient(options = {}) {
-    if (cachedCircleModule) return cachedCircleModule;
-    if (options.clientModule) {
-      cachedCircleModule = options.clientModule;
-      return cachedCircleModule;
-    }
-    const moduleUrl = options.clientModuleUrl || "@circle-fin/x402-batching/client";
-    try {
-      cachedCircleModule = await import(moduleUrl);
-      return cachedCircleModule;
-    } catch (error) {
-      if (!options.clientModuleUrl) {
-        throw new Error(
-          `Could not load @circle-fin/x402-batching/client from node_modules. Provide a clientModuleUrl option (e.g. "https://esm.sh/@circle-fin/x402-batching@3.2.0/client?bundle") to load from CDN. Original error: ${error.message}`
-        );
-      }
-      throw new Error(
-        `Could not load Circle Gateway client from CDN: ${error.message}. Check that ${options.clientModuleUrl} is reachable.`
-      );
-    }
-  }
   function encodeBase64(value) {
     const text = typeof value === "string" ? value : stringifyJson(value);
     if (typeof Buffer !== "undefined") return Buffer.from(text).toString("base64");
@@ -73,9 +197,7 @@ var Nibgate = (() => {
     if (!signer?.address || typeof signer.signTypedData !== "function") {
       throw new Error("Circle Gateway browser adapter requires an EVM signer with address and signTypedData.");
     }
-    const circleClientModule = await getCircleClient(options);
-    const { BatchEvmScheme } = circleClientModule;
-    const scheme = new BatchEvmScheme(signer);
+    const scheme = options.clientModule?.BatchEvmScheme ? new options.clientModule.BatchEvmScheme(signer) : new BatchEvmScheme(signer);
     const network = options.network || options.chainId && `eip155:${options.chainId}` || "eip155:5042002";
     function parsePaymentRequired(input) {
       if (input && typeof input === "object") return input;
@@ -131,11 +253,10 @@ var Nibgate = (() => {
       }
     };
   }
-  var cachedCircleModule;
   var init_gateway = __esm({
     "src/browser/gateway.js"() {
+      init_batch_scheme();
       init_json();
-      cachedCircleModule = null;
     }
   });
 
@@ -353,7 +474,6 @@ var Nibgate = (() => {
     }
     if (isPaidResource(normalized)) {
       if (!hasValue(normalized.price)) errors.push("Paid content requires price.");
-      if (!hasValue(normalized.recipient || normalized.payTo)) warnings.push("Paid content should include recipient/payTo (server value from 402 challenge is used for actual payment).");
     }
     const score = Math.max(0, 100 - errors.length * 20 - warnings.length * 8);
     return {
@@ -804,7 +924,6 @@ var Nibgate = (() => {
     const gateway = await Promise.resolve().then(() => (init_gateway(), gateway_exports));
     return gateway.createCircleGatewayBrowserAdapter(options);
   }
-  var DEFAULT_CIRCLE_CDN = "https://esm.sh/@circle-fin/x402-batching@3.2.0/client?bundle";
   var HOSTED_PAY_URL = "https://api.nibgate.xyz/api/hub/pay";
   function resolveAccessPath(resource, options) {
     if (options.hosted || options.accessPath === "hosted") return HOSTED_PAY_URL;
@@ -903,8 +1022,7 @@ var Nibgate = (() => {
           address: walletAddress,
           signTypedData: (typedData) => evm.request({ method: "eth_signTypedData_v4", params: [walletAddress, stringifyJson(typedData)] })
         },
-        clientModule: options.circleClientModule,
-        clientModuleUrl: options.circleClientModuleUrl || DEFAULT_CIRCLE_CDN
+        clientModule: options.circleClientModule
       });
       return gatewayWallet.pay(input);
     }
@@ -921,6 +1039,9 @@ var Nibgate = (() => {
           challengeMessage: options.challengeMessage || "Gateway payment required. Connect your wallet to continue...",
           paymentMessage: options.paymentMessage || "Approve the Gateway payment proof in your wallet...",
           successMessage: options.successMessage || `Unlocked ${item.resource.title || "content"}.`,
+          method: options.method,
+          headers: options.headers,
+          body: options.body,
           checkout,
           onStatus: setStatus
         });
@@ -970,7 +1091,6 @@ var Nibgate = (() => {
     return createEvmGatewayUnlock(resource, {
       ...options,
       hosted: true,
-      circleClientModuleUrl: options.circleClientModuleUrl || DEFAULT_CIRCLE_CDN,
       noWalletMessage: options.noWalletMessage || "Install MetaMask or another EVM wallet to unlock premium content."
     });
   }