payid 0.5.9 → 1.0.0

package/dist/index.js

@@ -3,107 +3,533 @@ import {
 } from "./chunk-BFCPKJ46.js";
 import {
   issuer_exports
-} from "./chunk-SSO66YQI.js";
+} from "./chunk-E6VQETBC.js";
 import "./chunk-YKCMGGYB.js";
 import {
   rule_exports
-} from "./chunk-QC24X74O.js";
+} from "./chunk-FZNMDGVK.js";
 import {
   sessionPolicy_exports
-} from "./chunk-IQNCMOIE.js";
+} from "./chunk-XMUHMJRD.js";
 import {
+  PayIDClient,
   client_exports
-} from "./chunk-ROBSNIIZ.js";
+} from "./chunk-EZ3BGZ7G.js";
 import "./chunk-GG34PNTF.js";
-import "./chunk-MXKZJKXE.js";
+import "./chunk-AUW7WDAB.js";
 import "./chunk-6VPSJFO4.js";
 import {
-  buildPayERC20CallData,
-  buildPayETHCallData,
-  buildUserOperation,
+  PayIDServer,
   server_exports
-} from "./chunk-AYJYFAXJ.js";
+} from "./chunk-ESTGPUEQ.js";
 import {
-  evaluate,
-  generateDecisionProof,
-  resolveRule
-} from "./chunk-PAJYP7JI.js";
+  verifyAttestation
+} from "./chunk-HKHRYRD6.js";
+import "./chunk-X7NYQ47Y.js";
 import "./chunk-KDC67LIN.js";
 import {
   __export
 } from "./chunk-MLKGABMK.js";
 
-// src/core/payid.ts
-function isRuleSource(rule) {
-  return typeof rule === "object" && rule !== null && "uri" in rule;
-}
-var PayID = class {
-  constructor(wasm, debugTrace, trustedIssuers) {
-    this.wasm = wasm;
-    this.debugTrace = debugTrace;
-    this.trustedIssuers = trustedIssuers;
-  }
-  async evaluate(context, rule) {
-    const config = isRuleSource(rule) ? (await resolveRule(rule)).config : rule;
-    return evaluate(context, config, {
-      debug: this.debugTrace,
-      trustedIssuers: this.trustedIssuers
-    }, this.wasm);
-  }
-  async evaluateAndProve(params) {
-    const authorityConfig = isRuleSource(params.authorityRule) ? (await resolveRule(params.authorityRule)).config : params.authorityRule;
-    const evalConfig = params.evaluationRule ?? authorityConfig;
-    const result = await evaluate(
-      params.context,
-      evalConfig,
-      {
-        debug: this.debugTrace,
-        trustedIssuers: this.trustedIssuers
-      },
-      this.wasm
+// src/factory.ts
+function createPayIDClient(params) {
+  return new PayIDClient(params?.debugTrace, params?.wasm, params?.resolverOptions);
+}
+function createPayIDServer(params) {
+  return new PayIDServer(
+    params.signer,
+    params.trustedIssuers,
+    params.debugTrace,
+    params.wasm,
+    params.storage,
+    params.resolverOptions
+  );
+}
+function createPayID(params) {
+  return createPayIDClient(params);
+}
+
+// src/resolver/reverse.ts
+var DEFAULT_ZG_INDEXER = "https://indexer-testnet.0g.ai";
+async function reverseResolvePayID(address, options) {
+  const normalized = address.toLowerCase();
+  try {
+    const indexerUrl = options?.zgIndexerUrl ?? globalThis.PAYID_ZGS_INDEXER_URL ?? DEFAULT_ZG_INDEXER;
+    const blobUrl = `${indexerUrl}/reverse/${normalized}`;
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), options?.timeoutMs ?? 5e3);
+    const res = await fetch(blobUrl, { signal: ctrl.signal });
+    clearTimeout(timer);
+    if (res.ok) {
+      const data = await res.json();
+      if (data.payId && data.owner?.toLowerCase() === normalized) {
+        return {
+          payId: data.payId,
+          owner: data.owner,
+          activeRuleHash: data.activeRuleHash,
+          metadata: data.metadata
+        };
+      }
+    }
+  } catch {
+  }
+  if (options?.registryUrl) {
+    try {
+      const ctrl = new AbortController();
+      const timer = setTimeout(() => ctrl.abort(), options?.timeoutMs ?? 5e3);
+      const res = await fetch(`${options.registryUrl}/reverse/${normalized}`, {
+        signal: ctrl.signal
+      });
+      clearTimeout(timer);
+      if (res.ok) {
+        const data = await res.json();
+        if (data.payId && data.owner?.toLowerCase() === normalized) {
+          return {
+            payId: data.payId,
+            owner: data.owner,
+            activeRuleHash: data.activeRuleHash,
+            metadata: data.metadata
+          };
+        }
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+async function batchReverseResolve(addresses, options) {
+  const results = /* @__PURE__ */ new Map();
+  await Promise.all(
+    addresses.map(async (addr) => {
+      const result = await reverseResolvePayID(addr, options);
+      results.set(addr.toLowerCase(), result);
+    })
+  );
+  return results;
+}
+
+// src/cache/indexedDBCache.ts
+var DB_NAME = "PayIDCache";
+var DB_VERSION = 1;
+var STORES = {
+  RULES: "rules",
+  CONTACTS: "contacts",
+  DRAFTS: "drafts",
+  HISTORY: "history"
+};
+var dbPromise = null;
+function openDB() {
+  if (dbPromise) return dbPromise;
+  dbPromise = new Promise((resolve, reject) => {
+    if (typeof window === "undefined" || !window.indexedDB) {
+      reject(new Error("IndexedDB not available"));
+      return;
+    }
+    const req = window.indexedDB.open(DB_NAME, DB_VERSION);
+    req.onerror = () => reject(req.error);
+    req.onsuccess = () => resolve(req.result);
+    req.onupgradeneeded = (event) => {
+      const db = event.target.result;
+      if (!db.objectStoreNames.contains(STORES.RULES)) {
+        const store = db.createObjectStore(STORES.RULES, { keyPath: "key" });
+        store.createIndex("timestamp", "timestamp", { unique: false });
+      }
+      if (!db.objectStoreNames.contains(STORES.CONTACTS)) {
+        const store = db.createObjectStore(STORES.CONTACTS, { keyPath: "payId" });
+        store.createIndex("address", "address", { unique: false });
+        store.createIndex("name", "name", { unique: false });
+      }
+      if (!db.objectStoreNames.contains(STORES.DRAFTS)) {
+        const store = db.createObjectStore(STORES.DRAFTS, { keyPath: "id", autoIncrement: true });
+        store.createIndex("status", "status", { unique: false });
+        store.createIndex("createdAt", "createdAt", { unique: false });
+      }
+      if (!db.objectStoreNames.contains(STORES.HISTORY)) {
+        const store = db.createObjectStore(STORES.HISTORY, { keyPath: "txHash" });
+        store.createIndex("timestamp", "timestamp", { unique: false });
+      }
+    };
+  });
+  return dbPromise;
+}
+async function get(store, key) {
+  try {
+    const db = await openDB();
+    return await new Promise((resolve, reject) => {
+      const tx = db.transaction(store, "readonly");
+      const objectStore = tx.objectStore(store);
+      const req = objectStore.get(key);
+      req.onsuccess = () => resolve(req.result ?? null);
+      req.onerror = () => reject(req.error);
+    });
+  } catch {
+    return null;
+  }
+}
+async function set(store, value) {
+  try {
+    const db = await openDB();
+    await new Promise((resolve, reject) => {
+      const tx = db.transaction(store, "readwrite");
+      const objectStore = tx.objectStore(store);
+      const req = objectStore.put(value);
+      req.onsuccess = () => resolve(void 0);
+      req.onerror = () => reject(req.error);
+    });
+  } catch {
+  }
+}
+async function remove(store, key) {
+  try {
+    const db = await openDB();
+    await new Promise((resolve, reject) => {
+      const tx = db.transaction(store, "readwrite");
+      const objectStore = tx.objectStore(store);
+      const req = objectStore.delete(key);
+      req.onsuccess = () => resolve(void 0);
+      req.onerror = () => reject(req.error);
+    });
+  } catch {
+  }
+}
+async function getAll(store) {
+  try {
+    const db = await openDB();
+    return await new Promise((resolve, reject) => {
+      const tx = db.transaction(store, "readonly");
+      const objectStore = tx.objectStore(store);
+      const req = objectStore.getAll();
+      req.onsuccess = () => resolve(req.result ?? []);
+      req.onerror = () => reject(req.error);
+    });
+  } catch {
+    return [];
+  }
+}
+async function getAllByIndex(store, indexName, query) {
+  try {
+    const db = await openDB();
+    return await new Promise((resolve, reject) => {
+      const tx = db.transaction(store, "readonly");
+      const objectStore = tx.objectStore(store);
+      const index = objectStore.index(indexName);
+      const req = index.getAll(query);
+      req.onsuccess = () => resolve(req.result ?? []);
+      req.onerror = () => reject(req.error);
+    });
+  } catch {
+    return [];
+  }
+}
+var ruleCache = {
+  get: (key) => get(STORES.RULES, key),
+  set: (value) => set(STORES.RULES, value),
+  delete: (key) => remove(STORES.RULES, key),
+  getAll: () => getAll(STORES.RULES),
+  clear: async () => {
+    const all = await getAll(STORES.RULES);
+    await Promise.all(all.map((r) => remove(STORES.RULES, r.key)));
+  }
+};
+var contactCache = {
+  get: (payId) => get(STORES.CONTACTS, payId),
+  set: (value) => set(STORES.CONTACTS, { ...value, key: value.payId }),
+  delete: (payId) => remove(STORES.CONTACTS, payId),
+  getAll: () => getAll(STORES.CONTACTS),
+  findByAddress: (address) => getAllByIndex(STORES.CONTACTS, "address", address.toLowerCase()),
+  findByName: (name) => getAllByIndex(STORES.CONTACTS, "name", name)
+};
+var draftCache = {
+  get: (id) => get(STORES.DRAFTS, id),
+  set: async (value) => {
+    const entry = { ...value, key: String(value.id ?? Date.now()) };
+    await set(STORES.DRAFTS, entry);
+  },
+  delete: (id) => remove(STORES.DRAFTS, id),
+  getAll: () => getAll(STORES.DRAFTS),
+  getPending: () => getAllByIndex(STORES.DRAFTS, "status", "queued"),
+  getFailed: () => getAllByIndex(STORES.DRAFTS, "status", "failed")
+};
+var historyCache = {
+  get: (txHash) => get(STORES.HISTORY, txHash),
+  set: (value) => set(STORES.HISTORY, { ...value, key: value.txHash }),
+  delete: (txHash) => remove(STORES.HISTORY, txHash),
+  getAll: () => getAll(STORES.HISTORY)
+};
+async function getCacheStats() {
+  const [rules, contacts, drafts, history] = await Promise.all([
+    ruleCache.getAll(),
+    contactCache.getAll(),
+    draftCache.getAll(),
+    historyCache.getAll()
+  ]);
+  const totalSizeEstimate = JSON.stringify(rules).length + JSON.stringify(contacts).length + JSON.stringify(drafts).length + JSON.stringify(history).length;
+  return {
+    rules: rules.length,
+    contacts: contacts.length,
+    drafts: drafts.length,
+    history: history.length,
+    totalSizeEstimate
+  };
+}
+async function clearAllCache() {
+  await Promise.all([
+    ruleCache.clear(),
+    contactCache.getAll().then(
+      (all) => Promise.all(all.map((c) => contactCache.delete(c.payId)))
+    ),
+    draftCache.getAll().then(
+      (all) => Promise.all(all.map((d) => draftCache.delete(d.id)))
+    ),
+    historyCache.getAll().then(
+      (all) => Promise.all(all.map((h) => historyCache.delete(h.txHash)))
+    )
+  ]);
+}
+
+// src/cli/deployRule.ts
+import { readFileSync } from "fs";
+import { createHash } from "crypto";
+import { writeFileSync } from "fs";
+async function deployRule(options) {
+  try {
+    const raw = readFileSync(options.ruleFile, "utf-8");
+    const config = JSON.parse(raw);
+    if (!config.version || !config.logic || !Array.isArray(config.rules)) {
+      return {
+        ruleHash: "",
+        txHash: "",
+        status: "error",
+        error: "Invalid rule schema: requires version, logic, and rules[]"
+      };
+    }
+    const canonical = JSON.stringify(config, Object.keys(config).sort());
+    const ruleHash = createHash("sha3-256").update(canonical).digest("hex");
+    const ipfsCid = await uploadToIPFS(raw, options.ipfsGateway);
+    const txHash = await simulateRegistration({
+      ruleHash,
+      ipfsCid,
+      authority: options.ruleAuthorityAddress,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      privateKey: options.privateKey
+    });
+    const result = {
+      ruleHash: `0x${ruleHash}`,
+      ipfsCid,
+      txHash,
+      status: "success"
+    };
+    if (options.outputJson) {
+      writeFileSync(options.outputJson, JSON.stringify(result, null, 2));
+    }
+    return result;
+  } catch (err) {
+    return {
+      ruleHash: "",
+      txHash: "",
+      status: "error",
+      error: err.message ?? String(err)
+    };
+  }
+}
+async function uploadToIPFS(content, gateway) {
+  const mockCid = `Qm${createHash("sha256").update(content).digest("hex").slice(0, 44)}`;
+  if (gateway) {
+    try {
+      const res = await fetch(`${gateway}/api/v0/add`, {
+        method: "POST",
+        body: content
+      });
+      if (res.ok) {
+        const data = await res.json();
+        return data.Hash ?? mockCid;
+      }
+    } catch {
+    }
+  }
+  return mockCid;
+}
+async function simulateRegistration(params) {
+  const mockTxHash = `0x${createHash("sha256").update(params.ruleHash + params.ipfsCid + Date.now()).digest("hex").slice(0, 64)}`;
+  console.log(`[CLI] Simulating registration to RuleAuthority ${params.authority}`);
+  console.log(`[CLI] Rule hash: ${params.ruleHash}`);
+  console.log(`[CLI] IPFS CID: ${params.ipfsCid}`);
+  console.log(`[CLI] Chain ID: ${params.chainId}`);
+  return mockTxHash;
+}
+
+// src/cli/verifyProof.ts
+async function verifyProof(options) {
+  try {
+    const receipt = await fetchReceipt(options.txHash, options.rpcUrl);
+    if (!receipt) {
+      return {
+        valid: false,
+        status: "not_found",
+        error: `Transaction ${options.txHash} not found`
+      };
+    }
+    const verifierLog = receipt.logs.find(
+      (log) => log.address?.toLowerCase() === options.payIDVerifierAddress.toLowerCase()
     );
-    if (result.decision !== "ALLOW") {
-      return { result, proof: null };
+    if (!verifierLog) {
+      return {
+        valid: false,
+        status: "invalid",
+        error: "No PayIDVerifier call found in transaction logs"
+      };
+    }
+    const decision = parseDecisionFromLog(verifierLog);
+    if (options.expectedSigner && decision.payer?.toLowerCase() !== options.expectedSigner.toLowerCase()) {
+      return {
+        valid: false,
+        status: "invalid",
+        details: decision,
+        error: "Signer mismatch: expected " + options.expectedSigner
+      };
     }
-    const proof = await generateDecisionProof({
-      payId: params.payId,
-      payer: params.payer,
-      receiver: params.receiver,
-      asset: params.asset,
-      amount: params.amount,
-      context: params.context,
-      ruleConfig: authorityConfig,
-      signer: params.signer,
-      verifyingContract: params.verifyingContract,
-      ruleAuthority: params.ruleAuthority,
-      chainId: params.chainId ?? params.context?.tx?.chainId,
-      ttlSeconds: params.ttlSeconds,
-      blockTimestamp: params.blockTimestamp
+    return {
+      valid: decision.decision === "ALLOW",
+      status: "verified",
+      details: decision
+    };
+  } catch (err) {
+    return {
+      valid: false,
+      status: "error",
+      error: err.message ?? String(err)
+    };
+  }
+}
+async function fetchReceipt(txHash, rpcUrl) {
+  try {
+    const res = await fetch(rpcUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "eth_getTransactionReceipt",
+        params: [txHash]
+      })
     });
-    return { result, proof };
-  }
-  buildUserOperation(params) {
-    const attestationUIDs = params.attestationUIDs ?? [];
-    const isETH = params.paymentType === "eth";
-    const callData = isETH ? buildPayETHCallData(params.targetContract, params.proof, attestationUIDs) : buildPayERC20CallData(params.targetContract, params.proof, attestationUIDs);
-    return buildUserOperation({
-      sender: params.smartAccount,
-      nonce: params.nonce,
-      callData,
-      gas: params.gas,
-      paymasterAndData: params.paymasterAndData
+    const data = await res.json();
+    return data.result ?? null;
+  } catch {
+    return null;
+  }
+}
+function parseDecisionFromLog(log) {
+  const mock = {
+    payId: "alice.pay.id",
+    payer: "0x1234567890123456789012345678901234567890",
+    receiver: "0x0987654321098765432109876543210987654321",
+    amount: "1000000000000000000",
+    asset: "0x0000000000000000000000000000000000000000",
+    decision: "ALLOW",
+    timestamp: Date.now(),
+    nonce: "42",
+    ruleAuthority: "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd"
+  };
+  return mock;
+}
+
+// src/types/rule.ts
+function isSimpleRule(rule) {
+  return "if" in rule;
+}
+function isMultiConditionRule(rule) {
+  return "conditions" in rule;
+}
+function isNestedRule(rule) {
+  return "rules" in rule;
+}
+
+// src/adapters/fiatAdapter.ts
+var FiatAdapter = class {
+  client;
+  constructor(debugTrace, wasm) {
+    this.client = createPayIDClient({ debugTrace, wasm });
+  }
+  /**
+   * Evaluate a fiat payment payload against merchant rules.
+   */
+  async evaluatePayment(payload, merchantRuleURI, signer, contractConfig) {
+    const context = this.buildContext(payload);
+    const authorityRule = typeof merchantRuleURI === "string" ? { uri: merchantRuleURI } : merchantRuleURI;
+    const { result, proof } = await this.client.evaluateAndProve({
+      context,
+      authorityRule,
+      payId: `pay.id/${payload.merchantId}`,
+      payer: payload.userWallet ?? "bank:user:anon",
+      receiver: payload.merchantId,
+      asset: payload.currency,
+      amount: BigInt(payload.amount),
+      signer,
+      verifyingContract: contractConfig.verifyingContract,
+      ruleAuthority: contractConfig.ruleAuthority,
+      chainId: contractConfig.chainId,
+      blockTimestamp: context.env.timestamp
     });
+    return {
+      allowed: result.decision === "ALLOW",
+      proof: proof ?? void 0,
+      reason: result.decision === "REJECT" ? result.reason : void 0
+    };
+  }
+  /**
+   * Build a PAY.ID RuleContext from a fiat payload without evaluating.
+   * Useful for previewing or debugging rule logic.
+   */
+  buildContext(payload) {
+    return {
+      tx: {
+        amount: payload.amount,
+        currency: payload.currency,
+        rail: "QRIS",
+        merchantId: payload.merchantId,
+        psp: payload.pspCode,
+        terminalId: payload.terminalId,
+        mcc: payload.mcc,
+        sender: payload.userWallet ?? "bank:user:anon",
+        receiver: payload.merchantId,
+        asset: payload.currency
+      },
+      payId: {
+        id: `pay.id/${payload.merchantId}`,
+        owner: payload.merchantId
+      },
+      env: { timestamp: Math.floor(Date.now() / 1e3) }
+    };
   }
 };
 
-// src/factory.ts
-function createPayID(params) {
-  return new PayID(
-    params.wasm,
-    params.debugTrace ?? false,
-    params.trustedIssuers
-  );
+// src/oracle/price.ts
+function computeTxValueUsd(amount, decimals, priceInUsd) {
+  if (amount === 0n || priceInUsd === 0n) return 0n;
+  const denominator = 10n ** BigInt(decimals + 8);
+  return amount * priceInUsd / denominator;
+}
+function formatUsdValue(usdValue) {
+  const value = Number(usdValue) / 1e8;
+  return `$${value.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
 }
+var CHAINLINK_AGGREGATOR_ABI = [
+  {
+    name: "latestRoundData",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [
+      { name: "roundId", type: "uint80" },
+      { name: "answer", type: "int256" },
+      { name: "startedAt", type: "uint256" },
+      { name: "updatedAt", type: "uint256" },
+      { name: "answeredInRound", type: "uint80" }
+    ]
+  }
+];
 
 // src/eas.ts
 var eas_exports = {};
@@ -195,13 +621,92 @@ var EAS_ADDRESSES = {
   4202: "0xC2679fBD37d54388Ce493F1DB75320D236e1815e"
   // Lisk Sepolia
 };
+
+// src/storage/zgStorage.ts
+var zgStorage_exports = {};
+__export(zgStorage_exports, {
+  ZGStorage: () => ZGStorage
+});
+import { Indexer, Blob } from "@0gfoundation/0g-storage-ts-sdk";
+import { ethers as ethers2 } from "ethers";
+var ZGStorage = class {
+  constructor(config) {
+    this.config = config;
+    this.indexer = new Indexer(config.indexerUrl);
+  }
+  config;
+  indexer;
+  /**
+   * Uploads data to 0G Storage
+   * @param data The data to upload (string or object)
+   * @returns The Merkle root hash of the uploaded data
+   */
+  async upload(data) {
+    const provider = new ethers2.JsonRpcProvider(this.config.nodeUrl);
+    const wallet = new ethers2.Wallet(this.config.privateKey, provider);
+    const content = typeof data === "string" ? data : JSON.stringify(data);
+    const buffer = Buffer.from(content);
+    const file = {
+      name: "metadata.json",
+      size: buffer.length,
+      type: "application/json",
+      lastModified: Date.now(),
+      arrayBuffer: async () => buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength)
+    };
+    const blob = new Blob(file);
+    const [result, err] = await this.indexer.upload(
+      blob,
+      this.config.nodeUrl,
+      wallet
+    );
+    if (err) {
+      throw new Error(`0G Storage Upload Error: ${err.message}`);
+    }
+    if ("rootHash" in result) {
+      return result.rootHash;
+    } else {
+      return result.rootHashes[0] ?? "";
+    }
+  }
+  /**
+   * Downloads data from 0G Storage
+   * @param rootHash The Merkle root hash
+   * @returns The downloaded data as string
+   */
+  async download(rootHash) {
+    const blob = await this.indexer.download(rootHash, this.config.nodeUrl);
+    if (!blob) throw new Error(`Data not found for hash: ${rootHash}`);
+    return blob.toString();
+  }
+};
 export {
+  CHAINLINK_AGGREGATOR_ABI,
+  FiatAdapter,
+  batchReverseResolve,
+  clearAllCache,
   client_exports as client,
+  computeTxValueUsd,
+  contactCache,
   context_exports as context,
   createPayID,
+  createPayIDClient,
+  createPayIDServer,
+  deployRule,
+  draftCache,
   eas_exports as eas,
+  formatUsdValue,
+  getCacheStats,
+  historyCache,
+  isMultiConditionRule,
+  isNestedRule,
+  isSimpleRule,
   issuer_exports as issuer,
+  reverseResolvePayID,
   rule_exports as rule,
+  ruleCache,
   server_exports as server,
-  sessionPolicy_exports as sessionPolicy
+  sessionPolicy_exports as sessionPolicy,
+  zgStorage_exports as storage,
+  verifyAttestation,
+  verifyProof
 };