@arcenpay/node 0.0.1

package/README.md

@@ -0,0 +1,117 @@
+# @arcenpay/node
+
+ArcenPay Node.js SDK for server-side billing actions, access-token minting, company APIs, entitlement checks, subscription activation, webhook verification, and optional advanced runtime services.
+
+## Install
+
+```bash
+npm install @arcenpay/node
+```
+
+## Standard server path
+
+Create the client:
+
+```ts
+import { ArcenClient } from "@arcenpay/node";
+
+const client = new ArcenClient({
+  apiKey: process.env.ARCENPAY_API_KEY!,
+});
+```
+
+Mint a short-lived access token:
+
+```ts
+const session = await client.identify({
+  company: { id: "company_123", wallet: "0xabc..." },
+  user: { id: "user_123", wallet: "0xabc..." },
+  expiresIn: 3600,
+});
+```
+
+Check access and consume usage:
+
+```ts
+const entitlement = await client.checkEntitlement("scan", {
+  id: "company_123",
+});
+const flag = await client.checkFlag("scan", { id: "company_123" });
+
+const result = await client.consumeEntitlement({
+  featureKey: "scan",
+  company: { id: "company_123" },
+  idempotencyKey: "scan-req-1",
+});
+```
+
+Activate a subscription:
+
+```ts
+const activation = await client.activateSubscription({
+  planId: "starter",
+  paymentAccount: "0xabc...",
+  company: { id: "company_123", wallet: "0xabc..." },
+});
+```
+
+Verify webhook signatures:
+
+```ts
+import { verifyWebhookSignature } from "@arcenpay/node";
+
+const rawBody = await req.text();
+const signatureHeader = req.headers.get("x-meap-signature") ?? "";
+const signature = signatureHeader.startsWith("sha256=")
+  ? signatureHeader.slice("sha256=".length)
+  : signatureHeader;
+
+if (
+  !verifyWebhookSignature(
+    rawBody,
+    signature,
+    process.env.ARCENPAY_WEBHOOK_SECRET!,
+  )
+) {
+  throw new Error("Invalid webhook signature");
+}
+```
+
+## Main exports
+
+Standard app integrations usually use:
+
+- `ArcenClient`
+- `ArcenApiError`
+- `verifyWebhookSignature`
+
+The package also exposes advanced optional services:
+
+- `x402Middleware`
+- `WebhookService`
+- `UsageService`
+- `SettlementService`
+- `SettlementWriterService`
+- `EventListenerService`
+- `BillingKeeper`
+- `TablelandService`
+- `ProofOrchestrator`
+- `AxelarTransport`
+- `CCIPTransport`
+- `InMemoryNonceStore`
+- `RedisNonceStore`
+
+## Environment variables
+
+```bash
+ARCENPAY_API_KEY=api_xxxxxxxxx
+ARCENPAY_WEBHOOK_SECRET=whsec_xxxxxxxxx
+```
+
+`ARCENPAY_BASE_URL` is optional. The SDK defaults to `http://localhost:3000`
+outside production and `https://app.arcenpay.com` in production.
+
+## Boundary
+
+Use `@arcenpay/node` for server-owned logic. For customer-facing UI, use
+`@arcenpay/react`.

package/dist/chunk-SKFD6TSD.mjs

@@ -0,0 +1,266 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/services/tableland.ts
+import { Database } from "@tableland/sdk";
+import { JsonRpcProvider, Wallet } from "ethers";
+var TablelandService = class {
+  config;
+  initialized = false;
+  dbRead = null;
+  dbWrite = null;
+  constructor(config) {
+    this.config = config;
+  }
+  async initialize() {
+    this.ensureSafeTableName();
+    this.dbRead = new Database({
+      ...this.config.gatewayUrl ? { baseUrl: this.config.gatewayUrl } : {}
+    });
+    if (this.config.privateKey && this.config.rpcUrl) {
+      const provider = new JsonRpcProvider(this.config.rpcUrl);
+      const signer = new Wallet(this.config.privateKey, provider);
+      this.dbWrite = new Database({
+        signer,
+        ...this.config.gatewayUrl ? { baseUrl: this.config.gatewayUrl } : {}
+      });
+    }
+    this.initialized = true;
+    console.log(
+      `[Tableland] Initialized table=${this.config.tableName} mode=${this.dbWrite ? "read-write" : "read-only"}`
+    );
+  }
+  async getFeatureFlags(walletAddress) {
+    this.ensureInitialized();
+    const normalized = walletAddress.toLowerCase();
+    try {
+      const statement = `SELECT feature_flags FROM ${this.config.tableName} WHERE wallet_address = ? LIMIT 1`;
+      const response = await this.dbRead.prepare(statement).bind(normalized).all();
+      const row = response.results[0];
+      if (!row?.feature_flags) return {};
+      const parsed = JSON.parse(row.feature_flags);
+      return parsed ?? {};
+    } catch (err) {
+      console.error("[Tableland] getFeatureFlags error:", err);
+      return {};
+    }
+  }
+  async setFeatureFlags(walletAddress, flags, metadata) {
+    this.ensureInitialized();
+    this.ensureWritable();
+    const normalized = walletAddress.toLowerCase();
+    const now = Math.floor(Date.now() / 1e3);
+    const nftTokenId = metadata.nft_token_id ?? 0;
+    const planTier = metadata.plan_tier ?? "starter";
+    const apiRateLimit = metadata.api_rate_limit ?? this.defaultRateLimitForTier(planTier);
+    const billingInterval = metadata.billing_interval ?? 2592e3;
+    const lastRenewed = metadata.last_renewed ?? now;
+    const expiresAt = metadata.expires_at ?? 0;
+    const chainId = metadata.chain_id ?? this.config.chainId;
+    try {
+      const statement = `
+        INSERT INTO ${this.config.tableName}
+        (wallet_address, nft_token_id, plan_tier, feature_flags, api_rate_limit, billing_interval, last_renewed, expires_at, chain_id)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT (wallet_address) DO UPDATE SET
+          nft_token_id = excluded.nft_token_id,
+          plan_tier = excluded.plan_tier,
+          feature_flags = excluded.feature_flags,
+          api_rate_limit = excluded.api_rate_limit,
+          billing_interval = excluded.billing_interval,
+          last_renewed = excluded.last_renewed,
+          expires_at = excluded.expires_at,
+          chain_id = excluded.chain_id
+      `;
+      await this.dbWrite.prepare(statement).bind(
+        normalized,
+        nftTokenId,
+        planTier,
+        JSON.stringify(flags),
+        apiRateLimit,
+        billingInterval,
+        lastRenewed,
+        expiresAt,
+        chainId
+      ).run();
+      return true;
+    } catch (err) {
+      console.error("[Tableland] setFeatureFlags error:", err);
+      return false;
+    }
+  }
+  async revokeEntitlement(walletAddress) {
+    this.ensureInitialized();
+    this.ensureWritable();
+    try {
+      const statement = `DELETE FROM ${this.config.tableName} WHERE wallet_address = ?`;
+      await this.dbWrite.prepare(statement).bind(walletAddress.toLowerCase()).run();
+      return true;
+    } catch (err) {
+      console.error("[Tableland] revokeEntitlement error:", err);
+      return false;
+    }
+  }
+  async revokeEntitlementByTokenId(tokenId) {
+    this.ensureInitialized();
+    this.ensureWritable();
+    try {
+      const statement = `DELETE FROM ${this.config.tableName} WHERE nft_token_id = ?`;
+      await this.dbWrite.prepare(statement).bind(tokenId).run();
+      return true;
+    } catch (err) {
+      console.error("[Tableland] revokeEntitlementByTokenId error:", err);
+      return false;
+    }
+  }
+  async updateEntitlementByTokenId(tokenId, updates) {
+    this.ensureInitialized();
+    this.ensureWritable();
+    const assignments = [];
+    const values = [];
+    if (updates.feature_flags) {
+      assignments.push("feature_flags = ?");
+      values.push(JSON.stringify(updates.feature_flags));
+    }
+    if (updates.plan_tier) {
+      assignments.push("plan_tier = ?");
+      values.push(updates.plan_tier);
+    }
+    if (updates.expires_at !== void 0) {
+      assignments.push("expires_at = ?");
+      values.push(updates.expires_at);
+    }
+    if (updates.last_renewed !== void 0) {
+      assignments.push("last_renewed = ?");
+      values.push(updates.last_renewed);
+    }
+    if (updates.api_rate_limit !== void 0) {
+      assignments.push("api_rate_limit = ?");
+      values.push(updates.api_rate_limit);
+    }
+    if (updates.billing_interval !== void 0) {
+      assignments.push("billing_interval = ?");
+      values.push(updates.billing_interval);
+    }
+    if (assignments.length === 0) return true;
+    try {
+      const statement = `UPDATE ${this.config.tableName} SET ${assignments.join(", ")} WHERE nft_token_id = ?`;
+      values.push(tokenId);
+      await this.dbWrite.prepare(statement).bind(...values).run();
+      return true;
+    } catch (err) {
+      console.error("[Tableland] updateEntitlementByTokenId error:", err);
+      return false;
+    }
+  }
+  async listEntitlements(limit = 100) {
+    this.ensureInitialized();
+    const safeLimit = Math.max(1, Math.min(limit, 1e3));
+    try {
+      const statement = `SELECT * FROM ${this.config.tableName} LIMIT ?`;
+      const response = await this.dbRead.prepare(statement).bind(safeLimit).all();
+      const rows = response.results || [];
+      return rows.map((row) => ({
+        wallet_address: String(row.wallet_address || ""),
+        nft_token_id: Number(row.nft_token_id || 0),
+        plan_tier: String(row.plan_tier || "starter"),
+        feature_flags: typeof row.feature_flags === "string" ? JSON.parse(row.feature_flags) : row.feature_flags || {},
+        api_rate_limit: Number(row.api_rate_limit || 0),
+        billing_interval: Number(row.billing_interval || 0),
+        last_renewed: Number(row.last_renewed || 0),
+        expires_at: Number(row.expires_at || 0),
+        chain_id: Number(row.chain_id || this.config.chainId)
+      }));
+    } catch (err) {
+      console.error("[Tableland] listEntitlements error:", err);
+      return [];
+    }
+  }
+  async syncSubscription(data) {
+    await this.setFeatureFlags(data.walletAddress, data.features, {
+      wallet_address: data.walletAddress,
+      nft_token_id: data.tokenId,
+      plan_tier: data.planTier,
+      expires_at: data.expiresAt,
+      billing_interval: data.billingInterval,
+      last_renewed: Math.floor(Date.now() / 1e3),
+      chain_id: this.config.chainId,
+      api_rate_limit: this.defaultRateLimitForTier(data.planTier),
+      feature_flags: data.features
+    });
+  }
+  async listTierFeatureFlags(providerAddress, tiers = ["starter", "pro", "enterprise"]) {
+    const matrix = {};
+    for (const tier of tiers) {
+      const key = this.buildTierMatrixKey(providerAddress, tier);
+      matrix[tier] = await this.getFeatureFlags(key);
+    }
+    return matrix;
+  }
+  async setTierFeatureFlags(providerAddress, tier, flags) {
+    const key = this.buildTierMatrixKey(providerAddress, tier);
+    return this.setFeatureFlags(key, flags, {
+      wallet_address: key,
+      nft_token_id: 0,
+      plan_tier: tier,
+      expires_at: 0,
+      billing_interval: 0,
+      last_renewed: Math.floor(Date.now() / 1e3),
+      chain_id: this.config.chainId,
+      api_rate_limit: this.defaultRateLimitForTier(tier),
+      feature_flags: flags
+    });
+  }
+  buildTierMatrixKey(providerAddress, tier) {
+    return `matrix:${providerAddress.toLowerCase()}:${tier.toLowerCase()}`;
+  }
+  defaultRateLimitForTier(tier) {
+    if (tier === "enterprise") return 1e4;
+    if (tier === "pro") return 5e3;
+    return 1e3;
+  }
+  ensureInitialized() {
+    if (!this.initialized || !this.dbRead) {
+      throw new Error("[Tableland] Service not initialized. Call initialize() first.");
+    }
+  }
+  ensureWritable() {
+    if (!this.dbWrite) {
+      throw new Error(
+        "[Tableland] Write requested without signer. Set TABLELAND_PRIVATE_KEY + TABLELAND_RPC_URL."
+      );
+    }
+  }
+  ensureSafeTableName() {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(this.config.tableName)) {
+      throw new Error(
+        `[Tableland] Unsafe table name "${this.config.tableName}". Expected alphanumeric/underscore only.`
+      );
+    }
+  }
+};
+
+export {
+  __esm,
+  __export,
+  __toCommonJS,
+  TablelandService
+};