@nibgate/sdk 0.1.0

package/src/server/challenge.js

@@ -0,0 +1,51 @@
+import { normalizePaymentRail } from '../core/payment.js';
+import { normalizeServerResource as normalizeResource } from '../core/resource.js';
+import { serverEnv } from './env.js';
+
+export function createPaymentChallenge(resourceInput, options = {}) {
+  const resource = normalizeResource(resourceInput);
+  const origin = options.origin || serverEnv('NIBGATE_SITE_ORIGIN') || '';
+  const actor = options.actor || 'human';
+  const recipient = resource.recipient || resource.payTo || options.recipient || serverEnv('NIBGATE_SELLER_ADDRESS') || '';
+  const paymentRail = normalizePaymentRail(resource.paymentRail || options.paymentRail || options.paymentMode);
+  return {
+    x402Version: options.x402Version || 2,
+    status: 402,
+    scheme: 'exact',
+    paymentMode: paymentRail === 'gateway' ? (options.paymentMode || serverEnv('NIBGATE_PAYMENT_MODE') || 'unconfigured') : 'transfer',
+    paymentRail,
+    accepts: [
+      {
+        asset: resource.currency,
+        network: options.network || serverEnv('NIBGATE_PAYMENT_NETWORK') || 'eip155:5042002',
+        amount: String(resource.price),
+        recipient,
+        description: `Unlock ${resource.title}`,
+        resource: resource.url || `${origin}${resource.path}`,
+        mimeType: resource.type === 'article' ? 'text/html' : 'application/octet-stream',
+        payTo: recipient,
+        maxTimeoutSeconds: options.maxTimeoutSeconds || 120,
+        rail: paymentRail,
+        transfer: paymentRail === 'transfer' ? {
+          token: resource.currency || 'USDC',
+          chainId: options.chainId || options.network || serverEnv('NIBGATE_PAYMENT_NETWORK') || 'eip155:5042002',
+          recipient,
+          amount: String(resource.price),
+          verifier: 'creator-server'
+        } : undefined
+      }
+    ],
+    nibgate: {
+      contentId: resource.id,
+      title: resource.title,
+      contentType: resource.type,
+      price: String(resource.price),
+      currency: resource.currency,
+      path: resource.path,
+      actor,
+      access: resource.access,
+      unlock: resource.unlock,
+      paymentRail
+    }
+  };
+}

package/src/server/env.js

@@ -0,0 +1,3 @@
+export function serverEnv(name, fallback = '') {
+  return globalThis.process?.env?.[name] ?? fallback;
+}

package/src/server/gateway.js

@@ -0,0 +1,186 @@
+import { normalizeServerResource as normalizeResource } from '../core/resource.js';
+import { serverEnv } from './env.js';
+import { jsonResponse } from './response.js';
+
+async function importGatewayPackage(specifier) {
+  return import(specifier);
+}
+
+export async function payWithGateway(resourceInput, options = {}) {
+  const resource = normalizeResource(resourceInput);
+  const gatewayBuyerResult = await createGatewayBuyer(options);
+  if (!gatewayBuyerResult.ok) return gatewayBuyerResult;
+  const gatewayBuyer = gatewayBuyerResult.client;
+
+  const origin = options.origin || serverEnv('NIBGATE_SITE_ORIGIN') || '';
+  const accessUrl = options.accessUrl || `${origin.replace(/\/$/, '')}${resource.path || '/'}`;
+  const paymentResult = await gatewayBuyer.pay(accessUrl);
+  const data = paymentResult?.data || {};
+  const returnedPayment = data.payment || {};
+  return {
+    ok: true,
+    payment: {
+      paymentId: returnedPayment.paymentId || data.paymentId || data.id || paymentResult?.id || '',
+      paymentProvider: 'circle-gateway',
+      memo: returnedPayment.memo || data.memo || paymentResult?.memo || '',
+      txHash: returnedPayment.txHash || data.txHash || data.transaction || paymentResult?.transaction || '',
+      receiptUrl: returnedPayment.receiptUrl || data.receiptUrl || '',
+      chainExplorerUrl: returnedPayment.chainExplorerUrl || ((returnedPayment.txHash || data.txHash || data.transaction || paymentResult?.transaction)
+        ? `https://testnet.arcscan.app/tx/${returnedPayment.txHash || data.txHash || data.transaction || paymentResult?.transaction}`
+        : ''),
+      amount: Number(returnedPayment.amount || resource.price || 0),
+      revenue: Number(returnedPayment.revenue || returnedPayment.amount || resource.price || 0),
+      currency: returnedPayment.currency || resource.currency || 'USDC',
+      payer: returnedPayment.payer || data.payer || gatewayBuyerResult.address || '',
+      recipient: resource.recipient || resource.payTo || options.recipient || serverEnv('NIBGATE_SELLER_ADDRESS') || '',
+      network: returnedPayment.network || options.network || serverEnv('NIBGATE_PAYMENT_NETWORK') || 'eip155:5042002',
+      verified: true,
+      raw: data
+    },
+    raw: paymentResult
+  };
+}
+
+export async function createGatewayBuyer(options = {}) {
+  const buyerPrivateKey = options.buyerPrivateKey || serverEnv('NIBGATE_BUYER_PRIVATE_KEY') || '';
+  if (!buyerPrivateKey) {
+    return {
+      ok: false,
+      status: 503,
+      error: 'Gateway buyer is not configured',
+      detail: 'Set NIBGATE_BUYER_PRIVATE_KEY so this local example can execute a real Gateway payment.'
+    };
+  }
+
+  let GatewayClient;
+  try {
+    ({ GatewayClient } = await importGatewayPackage('@circle-fin/x402-batching/client'));
+  } catch (error) {
+    return {
+      ok: false,
+      status: 500,
+      error: 'Gateway client package is not available',
+      detail: error.message
+    };
+  }
+
+  const gatewayBuyer = new GatewayClient({
+    chain: options.buyerChain || serverEnv('NIBGATE_BUYER_CHAIN') || 'arcTestnet',
+    privateKey: buyerPrivateKey,
+    rpcUrl: options.buyerRpcUrl || serverEnv('NIBGATE_BUYER_RPC_URL') || undefined
+  });
+
+  return {
+    ok: true,
+    client: gatewayBuyer,
+    address: gatewayBuyer.address,
+    chain: options.buyerChain || serverEnv('NIBGATE_BUYER_CHAIN') || 'arcTestnet'
+  };
+}
+
+export async function getGatewayBalances(options = {}) {
+  const buyer = await createGatewayBuyer(options);
+  if (!buyer.ok) return buyer;
+  const balances = await buyer.client.getBalances(options.address);
+  return { ok: true, address: options.address || buyer.address, ...balances };
+}
+
+export async function depositToGateway(amount, options = {}) {
+  const buyer = await createGatewayBuyer(options);
+  if (!buyer.ok) return buyer;
+  const result = await buyer.client.deposit(String(amount), options.depositOptions || {});
+  return { ok: true, ...result };
+}
+
+export async function withdrawFromGateway(amount, options = {}) {
+  const buyer = await createGatewayBuyer(options);
+  if (!buyer.ok) return buyer;
+  const result = await buyer.client.withdraw(String(amount), {
+    chain: options.chain,
+    recipient: options.recipient,
+    maxFee: options.maxFee,
+    ...(options.withdrawOptions || {})
+  });
+  return { ok: true, ...result };
+}
+
+export async function runCircleGatewayRequirement(request, resourceInput, options = {}) {
+  let createGatewayMiddleware;
+  try {
+    ({ createGatewayMiddleware } = await importGatewayPackage('@circle-fin/x402-batching/server'));
+  } catch (error) {
+    return {
+      handled: true,
+      response: jsonResponse({
+        error: 'Gateway server package is not available',
+        detail: error.message
+      }, { status: 500 })
+    };
+  }
+
+  const resource = normalizeResource(resourceInput);
+  const recipient = resource.recipient || resource.payTo || options.recipient || serverEnv('NIBGATE_SELLER_ADDRESS') || '';
+  const middleware = createGatewayMiddleware({
+    sellerAddress: recipient,
+    facilitatorUrl: options.facilitatorUrl || serverEnv('NIBGATE_FACILITATOR_URL') || serverEnv('CIRCLE_GATEWAY_FACILITATOR_URL') || 'https://gateway-api-testnet.circle.com',
+    networks: [options.network || serverEnv('NIBGATE_PAYMENT_NETWORK') || 'eip155:5042002'],
+    description: `Unlock ${resource.title}`
+  });
+
+  let body = '';
+  const headers = {};
+  let statusCode = 200;
+  let nextCalled = false;
+  const requestHeaders = {};
+  request.headers?.forEach?.((value, key) => {
+    requestHeaders[key.toLowerCase()] = value;
+  });
+  const req = {
+    method: request.method || 'GET',
+    url: resource.url || resource.path || '/',
+    headers: requestHeaders
+  };
+  const res = {
+    get statusCode() {
+      return statusCode;
+    },
+    set statusCode(value) {
+      statusCode = value;
+    },
+    setHeader(name, value) {
+      headers[name] = value;
+    },
+    end(value = '') {
+      body = value;
+    }
+  };
+
+  await middleware.require(`$${resource.price}`)(req, res, () => {
+    nextCalled = true;
+  });
+
+  if (!nextCalled) {
+    return {
+      handled: true,
+      response: new Response(body, {
+        status: statusCode,
+        headers
+      })
+    };
+  }
+
+  return {
+    handled: false,
+    payment: {
+      paymentProvider: 'circle-gateway',
+      paymentId: request.headers.get('payment-signature') || '',
+      memo: request.headers.get('payment-memo') || '',
+      amount: Number(resource.price || 0),
+      revenue: Number(resource.price || 0),
+      currency: resource.currency || 'USDC',
+      recipient,
+      network: options.network || serverEnv('NIBGATE_PAYMENT_NETWORK') || 'eip155:5042002',
+      verified: true
+    }
+  };
+}

package/src/server/hub.js

@@ -0,0 +1,36 @@
+import { normalizeServerResource as normalizeResource } from '../core/resource.js';
+import { serverEnv } from './env.js';
+
+export async function emitHubEvent(event, resourceInput, options = {}) {
+  const resource = normalizeResource(resourceInput);
+  const siteId = options.siteId || serverEnv('NIBGATE_SITE_ID') || '';
+  const token = options.token || serverEnv('NIBGATE_SITE_TOKEN') || '';
+  const apiBaseUrl = (options.apiBaseUrl || serverEnv('NIBGATE_API_BASE') || 'http://localhost:3000').replace(/\/$/, '');
+  const origin = options.origin || serverEnv('NIBGATE_SITE_ORIGIN') || '';
+
+  if (!siteId || !token) {
+    return { skipped: true, reason: 'Missing NIBGATE_SITE_ID or NIBGATE_SITE_TOKEN' };
+  }
+
+  const response = await fetch(`${apiBaseUrl}/api/hub/track`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      ...(origin ? { origin } : {}),
+      ...(options.headers || {})
+    },
+    body: JSON.stringify({
+      siteId,
+      token,
+      event,
+      resource,
+      url: resource.url,
+      path: resource.path,
+      visitorId: options.visitorId || 'nibgate-visitor',
+      sessionId: options.sessionId || 'nibgate-session',
+      ...(options.payload || {})
+    })
+  });
+
+  return { ok: response.ok, status: response.status, body: await response.text() };
+}

package/src/server/index.js

@@ -0,0 +1,15 @@
+import { createNibgateServer } from './access.js';
+
+export { actorFromRequest, accessModeFor } from './actor.js';
+export { createPaymentChallenge } from './challenge.js';
+export { createManifest, manifestResponse } from './manifest.js';
+export { createUnlockToken, verifyUnlockToken } from './proof.js';
+export { emitHubEvent } from './hub.js';
+export { payWithGateway, createGatewayBuyer, getGatewayBalances, depositToGateway, withdrawFromGateway } from './gateway.js';
+export { createNibgateServer, protect } from './access.js';
+export { circleGatewayOptions, createCircleGatewayServer } from './presets.js';
+export { normalizeServerResource as normalizeResource, normalizeAccessPolicy, normalizeUnlockPolicy, validateResourceMetadata, UNLOCK_MODES } from '../core/resource.js';
+
+export const server = createNibgateServer();
+export { NIBGATE_CONTENT_SETTING_FIELDS, createNibgateContentSettings, settingsToAccessPolicy, settingsToUnlockPolicy } from '../core/settings.js';
+export { PAYMENT_RAILS, normalizePaymentRail } from '../core/payment.js';

package/src/server/manifest.js

@@ -0,0 +1,19 @@
+import { normalizeServerResource as normalizeResource } from '../core/resource.js';
+import { serverEnv } from './env.js';
+import { jsonResponse } from './response.js';
+
+export function createManifest(input = {}) {
+  const origin = input.origin || serverEnv('NIBGATE_SITE_ORIGIN') || '';
+  const content = (input.content || input.resources || []).map((resource) => normalizeResource(resource));
+  return {
+    name: input.name || 'Nibgate creator site',
+    origin,
+    nibgate: {
+      content
+    }
+  };
+}
+
+export function manifestResponse(input = {}) {
+  return jsonResponse(createManifest(input));
+}

package/src/server/presets.js

@@ -0,0 +1,14 @@
+import { createNibgateServer } from './access.js';
+import { serverEnv } from './env.js';
+
+export function circleGatewayOptions(options = {}) {
+  return {
+    ...options,
+    paymentMode: options.paymentMode || serverEnv('NIBGATE_PAYMENT_MODE') || 'circle-gateway',
+    network: options.network || serverEnv('NIBGATE_PAYMENT_NETWORK') || 'eip155:5042002'
+  };
+}
+
+export function createCircleGatewayServer(options = {}) {
+  return createNibgateServer(circleGatewayOptions(options));
+}

package/src/server/proof.js

@@ -0,0 +1,73 @@
+import crypto from 'node:crypto';
+import { normalizeServerResource as normalizeResource } from '../core/resource.js';
+import { serverEnv } from './env.js';
+
+export const DEFAULT_UNLOCK_SECONDS = 60 * 60 * 12;
+
+function stableJson(value) {
+  if (Array.isArray(value)) return `[${value.map((entry) => stableJson(entry)).join(',')}]`;
+  if (value && typeof value === 'object') {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(',')}}`;
+  }
+  return JSON.stringify(value);
+}
+
+function base64url(value) {
+  return Buffer.from(value).toString('base64url');
+}
+
+function fromBase64url(value) {
+  return Buffer.from(value, 'base64url').toString('utf8');
+}
+
+function sign(payload, secret) {
+  return crypto.createHmac('sha256', secret).update(payload).digest('base64url');
+}
+
+export function createUnlockToken(resourceInput, options = {}) {
+  const resource = normalizeResource(resourceInput);
+  const secret = options.secret || serverEnv('NIBGATE_SECRET') || serverEnv('NIBGATE_UNLOCK_SECRET') || 'nibgate-dev-secret';
+  const now = Math.floor(Date.now() / 1000);
+  const payment = options.payment || {};
+  const payload = {
+    contentId: resource.id,
+    paymentId: options.paymentId || '',
+    payment: {
+      paymentId: payment.paymentId || options.paymentId || '',
+      txHash: payment.txHash || '',
+      memo: payment.memo || '',
+      payer: payment.payer || '',
+      recipient: payment.recipient || resource.recipient || resource.payTo || '',
+      amount: Number(payment.amount || resource.price || 0),
+      currency: payment.currency || resource.currency || 'USDC',
+      network: payment.network || '',
+      verified: Boolean(payment.verified)
+    },
+    actor: options.actor || 'human',
+    iat: now,
+    exp: now + (options.expiresInSeconds || DEFAULT_UNLOCK_SECONDS)
+  };
+  const encoded = base64url(stableJson(payload));
+  return `${encoded}.${sign(encoded, secret)}`;
+}
+
+export function verifyUnlockToken(token, resourceInput, options = {}) {
+  if (!token || !token.includes('.')) return null;
+  const resource = normalizeResource(resourceInput);
+  const secret = options.secret || serverEnv('NIBGATE_SECRET') || serverEnv('NIBGATE_UNLOCK_SECRET') || 'nibgate-dev-secret';
+  const [encoded, signature] = token.split('.');
+  const expected = sign(encoded, secret);
+  const signatureBuffer = Buffer.from(signature || '');
+  const expectedBuffer = Buffer.from(expected);
+  if (signatureBuffer.length !== expectedBuffer.length) return null;
+  if (!crypto.timingSafeEqual(signatureBuffer, expectedBuffer)) return null;
+
+  try {
+    const payload = JSON.parse(fromBase64url(encoded));
+    if (payload.contentId !== resource.id) return null;
+    if (payload.exp && payload.exp < Math.floor(Date.now() / 1000)) return null;
+    return payload;
+  } catch (_error) {
+    return null;
+  }
+}

package/src/server/response.js

@@ -0,0 +1,9 @@
+export function jsonResponse(body, init = {}) {
+  return new Response(JSON.stringify(body), {
+    ...init,
+    headers: {
+      'content-type': 'application/json',
+      ...(init.headers || {})
+    }
+  });
+}

package/src/server/runtime.js

@@ -0,0 +1,39 @@
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const requireFromPackage = createRequire(import.meta.url);
+const requireFromCwd = createRequire(`${process.cwd()}/package.json`);
+const packageSourceDir = path.dirname(fileURLToPath(import.meta.url));
+const workspaceNodeModulesDir = path.resolve(packageSourceDir, '../../../node_modules/.pnpm/node_modules');
+const nativeImport = new Function('specifier', 'return import(specifier)');
+
+export async function runtimeImportPackage(specifier) {
+  try {
+    return await nativeImport(specifier);
+  } catch (_error) {
+    try {
+      return await nativeImport(requireFromPackage.resolve(specifier));
+    } catch (_packageError) {
+      try {
+        return await nativeImport(requireFromCwd.resolve(specifier));
+      } catch (_cwdError) {
+        if (specifier === '@circle-fin/x402-batching/client') {
+          try {
+            return await nativeImport(`${process.cwd()}/node_modules/.pnpm/node_modules/@circle-fin/x402-batching/dist/client/index.mjs`);
+          } catch {
+            return nativeImport(pathToFileURL(path.join(workspaceNodeModulesDir, '@circle-fin/x402-batching/dist/client/index.mjs')).href);
+          }
+        }
+        if (specifier === '@circle-fin/x402-batching/server') {
+          try {
+            return await nativeImport(`${process.cwd()}/node_modules/.pnpm/node_modules/@circle-fin/x402-batching/dist/server/index.mjs`);
+          } catch {
+            return nativeImport(pathToFileURL(path.join(workspaceNodeModulesDir, '@circle-fin/x402-batching/dist/server/index.mjs')).href);
+          }
+        }
+        return nativeImport(`${process.cwd()}/node_modules/.pnpm/node_modules/${specifier}`);
+      }
+    }
+  }
+}

package/src/server.d.ts

@@ -0,0 +1,212 @@
+export type NibgateServerResource = {
+  id: string;
+  title?: string;
+  type?: 'music' | 'video' | 'article' | 'image' | string;
+  contentType?: 'music' | 'video' | 'article' | 'image' | string;
+  price?: string | number;
+  paymentRail?: NibgatePaymentRail | string;
+  amount?: string | number;
+  recipient?: string;
+  receiver?: string;
+  receiverAddress?: string;
+  payTo?: string;
+  creatorWallet?: string;
+  path?: string;
+  route?: string;
+  url?: string;
+  imageUrl?: string;
+  image?: string;
+  description?: string;
+  summary?: string;
+  tags?: string[] | string;
+  currency?: string;
+  access?: NibgateAccessMode | NibgateAccessPolicy;
+  unlock?: NibgateUnlockMode | NibgateUnlockPolicy;
+  [key: string]: unknown;
+};
+
+export type NibgateMetadataValidation = {
+  ok: boolean;
+  score: number;
+  errors: string[];
+  warnings: string[];
+  resource: NibgateServerResource;
+};
+
+export type NibgateActor = 'human' | 'agent';
+export type NibgateAccessMode = 'free' | 'paid' | 'blocked';
+export type NibgateUnlockMode = 'one_time' | 'metered_stream' | 'metered_read' | 'time_pass' | 'agent_quota';
+export type NibgatePaymentRail = 'gateway' | 'transfer';
+export type NibgateAccessPolicy = {
+  humans?: NibgateAccessMode;
+  human?: NibgateAccessMode;
+  agents?: NibgateAccessMode;
+  agent?: NibgateAccessMode;
+  default?: NibgateAccessMode;
+};
+export type NibgateUnlockPolicy = {
+  mode?: NibgateUnlockMode | string;
+  type?: NibgateUnlockMode | string;
+  unit?: string;
+  pricePerUnit?: string | number;
+  duration?: string | number;
+  maxReads?: number;
+  [key: string]: unknown;
+};
+
+
+export type NibgateContentSettingField = {
+  name: string;
+  label: string;
+  type: 'boolean' | 'select' | 'text' | 'wallet' | 'textarea' | string;
+  options?: readonly string[];
+  defaultValue?: string | boolean;
+};
+export type NibgateContentSettings = {
+  publishToNibgate: boolean;
+  type: 'music' | 'video' | 'article' | 'image';
+  humanAccess: NibgateAccessMode;
+  agentAccess: NibgateAccessMode;
+  unlockMode: NibgateUnlockMode | string;
+  price: string;
+  currency: string;
+  recipient: string;
+  license: string;
+};
+export declare const NIBGATE_CONTENT_SETTING_FIELDS: readonly NibgateContentSettingField[];
+export declare function createNibgateContentSettings(input?: Record<string, unknown>): NibgateContentSettings;
+export declare function settingsToAccessPolicy(settings?: Partial<NibgateContentSettings>): Required<Pick<NibgateAccessPolicy, 'humans' | 'agents'>>;
+export declare function settingsToUnlockPolicy(settings?: Partial<NibgateContentSettings>): Required<Pick<NibgateUnlockPolicy, 'mode'>> & NibgateUnlockPolicy;
+
+export declare const PAYMENT_RAILS: readonly ['gateway', 'transfer'];
+export declare function normalizePaymentRail(value?: string, fallback?: NibgatePaymentRail): NibgatePaymentRail;
+export declare const UNLOCK_MODES: readonly ['one_time', 'metered_stream', 'metered_read', 'time_pass', 'agent_quota'];
+
+export type NibgatePaymentInput = {
+  id?: string;
+  paymentId?: string;
+  paymentProvider?: 'circle-gateway' | 'arc-testnet' | 'x402' | string;
+  receiptUrl?: string;
+  txHash?: string;
+  chainId?: string | number;
+  chainExplorerUrl?: string;
+  payer?: string;
+  recipient?: string;
+  actor?: string;
+  expiresInSeconds?: number;
+  [key: string]: unknown;
+};
+
+export type NibgateServerOptions = {
+  secret?: string;
+  origin?: string;
+  paymentMode?: string;
+  network?: string;
+  recipient?: string;
+  expiresInSeconds?: number;
+  actor?: NibgateActor;
+  defaultActor?: NibgateActor;
+  paymentRail?: NibgatePaymentRail | string;
+  verifyPayment?: (input: { resource: NibgateServerResource; payment: NibgatePaymentInput }) => boolean | Promise<boolean>;
+  verifyTransfer?: (input: { resource: NibgateServerResource; txHash: string; payment: NibgatePaymentInput; request: Request }) => boolean | Promise<boolean>;
+};
+
+export type NibgateUnlockResult =
+  | {
+      ok: true;
+      unlockProof: string;
+      expiresInSeconds: number;
+      resource: NibgateServerResource;
+      payment: NibgatePaymentInput;
+    }
+  | {
+      ok: false;
+      status: 402;
+      error: string;
+      challenge: Record<string, unknown>;
+    };
+
+export declare function createUnlockToken(resource: NibgateServerResource | string, options?: NibgateServerOptions & NibgatePaymentInput): string;
+export declare function verifyUnlockToken(token: string, resource: NibgateServerResource | string, options?: NibgateServerOptions): Record<string, unknown> | null;
+export declare function createPaymentChallenge(resource: NibgateServerResource | string, options?: NibgateServerOptions): Record<string, unknown>;
+export declare function createManifest(input?: { name?: string; origin?: string; content?: Array<NibgateServerResource | string>; resources?: Array<NibgateServerResource | string> }): Record<string, unknown>;
+export declare function manifestResponse(input?: { name?: string; origin?: string; content?: Array<NibgateServerResource | string>; resources?: Array<NibgateServerResource | string> }): Response;
+export declare function emitHubEvent(event: string, resource: NibgateServerResource | string, options?: NibgateServerOptions & {
+  siteId?: string;
+  token?: string;
+  apiBaseUrl?: string;
+  headers?: Record<string, string>;
+  visitorId?: string;
+  sessionId?: string;
+  payload?: Record<string, unknown>;
+}): Promise<Record<string, unknown>>;
+export declare function payWithGateway(resource: NibgateServerResource | string, options?: NibgateServerOptions & {
+  accessUrl?: string;
+  accessPath?: string;
+  buyerPrivateKey?: string;
+  buyerChain?: string;
+  buyerRpcUrl?: string;
+}): Promise<Record<string, unknown>>;
+export declare function createGatewayBuyer(options?: NibgateServerOptions & {
+  buyerPrivateKey?: string;
+  buyerChain?: string;
+  buyerRpcUrl?: string;
+}): Promise<Record<string, unknown>>;
+export declare function getGatewayBalances(options?: NibgateServerOptions & {
+  buyerPrivateKey?: string;
+  buyerChain?: string;
+  buyerRpcUrl?: string;
+  address?: string;
+}): Promise<Record<string, unknown>>;
+export declare function depositToGateway(amount: string | number, options?: NibgateServerOptions & {
+  buyerPrivateKey?: string;
+  buyerChain?: string;
+  buyerRpcUrl?: string;
+  depositOptions?: Record<string, unknown>;
+}): Promise<Record<string, unknown>>;
+export declare function withdrawFromGateway(amount: string | number, options?: NibgateServerOptions & {
+  buyerPrivateKey?: string;
+  buyerChain?: string;
+  buyerRpcUrl?: string;
+  chain?: string;
+  recipient?: string;
+  maxFee?: string;
+  withdrawOptions?: Record<string, unknown>;
+}): Promise<Record<string, unknown>>;
+export declare function circleGatewayOptions(options?: NibgateServerOptions): NibgateServerOptions & { paymentMode: string; network: string };
+export declare function createCircleGatewayServer(options?: NibgateServerOptions): ReturnType<typeof createNibgateServer>;
+export declare function createNibgateServer(options?: NibgateServerOptions): {
+  unlock(resource: NibgateServerResource | string, payment?: NibgatePaymentInput): Promise<NibgateUnlockResult>;
+  isUnlocked(request: Request, resource: NibgateServerResource | string, options?: { actor?: NibgateActor }): boolean;
+  accessFor(request: Request, resource: NibgateServerResource | string, options?: { actor?: NibgateActor; defaultActor?: NibgateActor }): {
+    actor: NibgateActor;
+    mode: NibgateAccessMode;
+    unlocked: boolean;
+    allowed: boolean;
+    blocked: boolean;
+    paid: boolean;
+    resource: NibgateServerResource;
+  };
+  protect(resource: NibgateServerResource | string, handler: (request: Request, context?: unknown) => Response | Promise<Response>, routeOptions?: NibgateServerOptions): (request: Request, context?: unknown) => Promise<Response>;
+  accessResponse(request: Request, resource: NibgateServerResource | string, allowedBody?: Record<string, unknown> | ((input: { access: Record<string, unknown>; resource: NibgateServerResource }) => Record<string, unknown> | Response) | null, routeOptions?: NibgateServerOptions): Promise<Response>;
+  payAndUnlockResponse(request: Request, resource: NibgateServerResource | string, routeOptions?: NibgateServerOptions & { accessUrl?: string; accessPath?: string }): Promise<Response>;
+  manifest(input?: { name?: string; origin?: string; content?: Array<NibgateServerResource | string>; resources?: Array<NibgateServerResource | string> }): Record<string, unknown>;
+  manifestResponse(input?: { name?: string; origin?: string; content?: Array<NibgateServerResource | string>; resources?: Array<NibgateServerResource | string> }): Response;
+  emitHubEvent(event: string, resource: NibgateServerResource | string, options?: Record<string, unknown>): Promise<Record<string, unknown>>;
+  getGatewayBalances(options?: Record<string, unknown>): Promise<Record<string, unknown>>;
+  depositToGateway(amount: string | number, options?: Record<string, unknown>): Promise<Record<string, unknown>>;
+  withdrawFromGateway(amount: string | number, options?: Record<string, unknown>): Promise<Record<string, unknown>>;
+  createPaymentChallenge(resource: NibgateServerResource | string, options?: NibgateServerOptions): Record<string, unknown>;
+  createUnlockToken(resource: NibgateServerResource | string, options?: NibgateServerOptions & NibgatePaymentInput): string;
+  verifyUnlockToken(token: string, resource: NibgateServerResource | string): Record<string, unknown> | null;
+  actorFromRequest(request: Request, fallback?: NibgateActor): NibgateActor;
+  accessModeFor(resource: NibgateServerResource | string, actor?: NibgateActor): NibgateAccessMode;
+};
+export declare function protect(resource: NibgateServerResource | string, handler: (request: Request, context?: unknown) => Response | Promise<Response>, options?: NibgateServerOptions): (request: Request, context?: unknown) => Promise<Response>;
+export declare const server: ReturnType<typeof createNibgateServer>;
+export declare function actorFromRequest(request: Request, fallback?: NibgateActor): NibgateActor;
+export declare function accessModeFor(resource: NibgateServerResource | string, actor?: NibgateActor): NibgateAccessMode;
+export declare function normalizeResource(resource?: NibgateServerResource | string): NibgateServerResource;
+export declare function validateResourceMetadata(resource?: NibgateServerResource | string, options?: Record<string, unknown>): NibgateMetadataValidation;
+export declare function normalizeAccessPolicy(access?: NibgateAccessMode | NibgateAccessPolicy): Required<Pick<NibgateAccessPolicy, 'humans' | 'agents'>>;
+export declare function normalizeUnlockPolicy(unlock?: NibgateUnlockMode | NibgateUnlockPolicy): Required<Pick<NibgateUnlockPolicy, 'mode'>> & NibgateUnlockPolicy;

package/src/server.js

@@ -0,0 +1 @@
+export * from './server/index.js';