@nibgate/sdk 0.2.7 → 0.2.9

package/SKILL.md

@@ -42,6 +42,25 @@ If the widget loads after app code, the SDK queues events and flushes them when
 
 **Adblocker bypass:** The widget now sends events to `/api/hub/evt` instead of `/api/hub/track` to avoid adblocker filter lists that target the word "track". The old `/api/hub/track` endpoint is preserved for backward compatibility. If you self-host the backend, ensure both routes are registered.
 
+**Hosted mode (zero backend code):** If you don't want to run your own access route, mark premium content with a data attribute and the widget handles everything:
+
+```html
+<div data-nibgate-premium="0.01" data-nibgate-recipient="0xYourWallet">
+  <p>Teaser text shown to everyone...</p>
+  <div data-nibgate-unlock-card>
+    <span data-nibgate-wallet-label>No wallet</span>
+    <button data-nibgate-connect>Connect</button>
+    <button data-nibgate-unlock-btn>Unlock for 0.01 USDC</button>
+    <p data-nibgate-status></p>
+  </div>
+  <div data-nibgate-unlocked hidden>
+    Full premium content here...
+  </div>
+</div>
+```
+
+No SDK import, no server access route, no env vars. The default wallet is set once in the Nibgate dashboard — or override per-post with `data-nibgate-recipient`. Custom price per-post: change `data-nibgate-premium="0.05"`.
+
 ---
 
 ## 2. Resource Shape (Minimal)

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;
     }
   });
 
@@ -158,6 +279,7 @@ var Nibgate = (() => {
     createCircleGatewayBrowserAdapter: () => createCircleGatewayBrowserAdapter2,
     createEvmGatewayUnlock: () => createEvmGatewayUnlock,
     createGate: () => createGate,
+    createHostedUnlock: () => createHostedUnlock,
     createNibgate: () => createNibgate,
     createNibgateContentSettings: () => createNibgateContentSettings,
     createOnchainRating: () => createOnchainRating,
@@ -803,11 +925,15 @@ 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;
+    return options.accessPath || resource.accessPath || "/api/nibgate/access";
+  }
   function createEvmGatewayUnlock(resource, options = {}) {
     const item = createGate(resource, options.gateOptions || {});
     const win = browserWindow();
-    const accessPath = options.accessPath || item.resource.accessPath || "/api/nibgate/access";
+    const accessPath = resolveAccessPath(item.resource, options);
     const source = options.source || "nibgate-evm-gateway";
     const network = options.network || "eip155:5042002";
     const statusTarget = typeof options.status === "string" ? win?.document.querySelector(options.status) : options.status;
@@ -897,8 +1023,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);
     }
@@ -915,6 +1040,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
         });
@@ -960,6 +1088,13 @@ var Nibgate = (() => {
     if (options.autoMount !== false) mount();
     return controller;
   }
+  function createHostedUnlock(resource, options = {}) {
+    return createEvmGatewayUnlock(resource, {
+      ...options,
+      hosted: true,
+      noWalletMessage: options.noWalletMessage || "Install MetaMask or another EVM wallet to unlock premium content."
+    });
+  }
 
   // src/browser/reputation.js
   var RATE_CONTENT_SELECTOR = "0xc62fad09";