@nibgate/sdk 0.2.8 → 0.2.9

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "@nibgate/sdk",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "description": "Framework-agnostic browser and server package for creator-owned gated content, unlock events, and receipts.",
   "type": "module",
-  "sideEffects": ["./src/browser/client.js", "./src/browser/events.js", "./src/browser/index.js"],
+  "sideEffects": [
+    "./src/browser/client.js",
+    "./src/browser/events.js",
+    "./src/browser/index.js"
+  ],
   "main": "./src/index.js",
   "module": "./src/index.js",
   "types": "./src/index.d.ts",

package/src/browser/evm-gateway.js

@@ -11,7 +11,6 @@ export async function createCircleGatewayBrowserAdapter(options = {}) {
   return gateway.createCircleGatewayBrowserAdapter(options);
 }
 
-const DEFAULT_CIRCLE_CDN = 'https://esm.sh/@circle-fin/x402-batching@3.2.0/client?bundle';
 const HOSTED_PAY_URL = 'https://api.nibgate.xyz/api/hub/pay';
 
 function resolveAccessPath(resource, options) {
@@ -121,8 +120,7 @@ export function createEvmGatewayUnlock(resource, options = {}) {
         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);
   }
@@ -139,6 +137,9 @@ export function createEvmGatewayUnlock(resource, options = {}) {
         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
       });
       if (result.ok) {
@@ -191,7 +192,6 @@ export function createHostedUnlock(resource, options = {}) {
   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.',
   });
 }

package/src/browser/gateway.js

@@ -1,35 +1,6 @@
+import { BatchEvmScheme } from './schemes/batch-scheme.js';
 import { stringifyJson } from './json.js';
 
-let cachedCircleModule = null;
-
-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');
@@ -47,9 +18,9 @@ export async function createCircleGatewayBrowserAdapter(options = {}) {
     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) {

package/src/browser/schemes/batch-scheme.js

@@ -0,0 +1,161 @@
+export const CIRCLE_BATCHING_NAME = 'GatewayWalletBatched';
+export const CIRCLE_BATCHING_VERSION = '1';
+export const GATEWAY_MIN_AUTH_VALIDITY_SECONDS = 7 * 24 * 60 * 60;
+export const GATEWAY_AUTH_VALIDITY_WINDOW_SECONDS = GATEWAY_MIN_AUTH_VALIDITY_SECONDS + 100;
+
+const 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' }
+  ]
+};
+
+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 undefined;
+  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;
+}
+
+export class BatchEvmScheme {
+  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() / 1000);
+      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);
+  }
+}

package/src/index.d.ts

@@ -217,7 +217,6 @@ export type NibgateCircleGatewayBrowserAdapterOptions = {
   network?: string;
   chainId?: number | string;
   clientModule?: Record<string, unknown>;
-  clientModuleUrl?: string;
 };
 
 export type NibgateCircleGatewayBrowserAdapter = {
@@ -230,10 +229,15 @@ export type NibgateEvmGatewayUnlockOptions = {
   source?: string;
   hosted?: boolean;
   accessPath?: string;
+  method?: string;
+  headers?: Record<string, string>;
+  body?: BodyInit | null;
   network?: string;
   paymentProvider?: string;
   circleClientModule?: Record<string, unknown>;
+  /** @deprecated The SDK now ships a native BatchEvmScheme — no CDN needed */
   circleClientModuleUrl?: string;
+
   provider?: {
     request(args: { method: string; params?: unknown[] }): Promise<unknown>;
   };