@4mica/sdk 0.5.3 → 0.5.5

package/dist/client/recipient.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecipientClient = void 0;
+const bls_1 = require("../bls");
+const payment_1 = require("../payment");
+const guarantee_1 = require("../guarantee");
+const errors_1 = require("../errors");
+const models_1 = require("../models");
+const debug_1 = require("../debug");
+const utils_1 = require("../utils");
+const shared_1 = require("./shared");
+class RecipientClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    get recipientAddress() {
+        return (0, utils_1.normalizeAddress)(this.client.signer.signer.address);
+    }
+    get guaranteeDomain() {
+        return this.client.guaranteeDomain;
+    }
+    async createTab(userAddress, recipientAddress, erc20Token, ttl) {
+        const body = {
+            user_address: (0, utils_1.normalizeAddress)(userAddress),
+            recipient_address: (0, utils_1.normalizeAddress)(recipientAddress),
+            erc20_token: erc20Token ? (0, utils_1.normalizeAddress)(erc20Token) : null,
+            ttl: ttl ?? null,
+        };
+        const result = await this.client.rpc.createPaymentTab(body);
+        const record = result;
+        const tabIdRaw = record.id ?? record.tabId ?? record.tab_id;
+        const tabId = (0, shared_1.isNumericLike)(tabIdRaw) ? tabIdRaw : 0;
+        return (0, utils_1.parseU256)(tabId);
+    }
+    async getTabPaymentStatus(tabId) {
+        const status = await this.client.gateway.getPaymentStatus(tabId);
+        return (0, shared_1.tabStatusFromRpc)(status);
+    }
+    async issuePaymentGuarantee(claims, signature, scheme) {
+        const payload = (0, payment_1.buildPaymentPayload)(claims, signature, scheme);
+        const cert = await this.client.rpc.issueGuarantee(payload);
+        const record = cert;
+        const certClaims = typeof record.claims === 'string' ? record.claims : '';
+        const signatureOut = typeof record.signature === 'string' ? record.signature : '';
+        return { claims: certClaims, signature: signatureOut };
+    }
+    verifyPaymentGuarantee(cert) {
+        const claims = (0, guarantee_1.decodeGuaranteeClaims)(cert.claims);
+        const domainHex = this.guaranteeDomain.startsWith('0x')
+            ? this.guaranteeDomain.slice(2)
+            : Buffer.from(this.guaranteeDomain).toString('hex');
+        const claimsHex = Buffer.from(claims.domain).toString('hex');
+        if (claimsHex !== domainHex) {
+            throw new errors_1.VerificationError('guarantee domain mismatch');
+        }
+        return claims;
+    }
+    async remunerate(cert, waitOptions) {
+        this.verifyPaymentGuarantee(cert);
+        const describeValue = (value) => {
+            if (value === null)
+                return 'null';
+            if (value === undefined)
+                return 'undefined';
+            if (Array.isArray(value))
+                return `array(len=${value.length})`;
+            if (typeof value === 'object') {
+                const keys = Object.keys(value);
+                return `object(keys=${keys.slice(0, 6).join(',')}${keys.length > 6 ? ',...' : ''})`;
+            }
+            return typeof value;
+        };
+        if (debug_1.DEBUG_CERTS) {
+            const preview = typeof cert.signature === 'string' ? cert.signature.slice(0, 12) : '';
+            console.log(`  debug remunerate: signature=${describeValue(cert.signature)} ${preview}`);
+        }
+        if (typeof cert.claims !== 'string') {
+            throw new errors_1.VerificationError(`certificate.claims must be a hex string, got ${describeValue(cert.claims)}`);
+        }
+        if (typeof cert.signature !== 'string') {
+            throw new errors_1.VerificationError(`certificate.signature must be a hex string, got ${describeValue(cert.signature)}`);
+        }
+        const sigWords = await (0, bls_1.signatureToWordsAsync)(cert.signature);
+        const claimsBytes = Buffer.from(cert.claims.replace(/^0x/, ''), 'hex');
+        if (waitOptions) {
+            return this.client.gateway.remunerate(claimsBytes, sigWords, waitOptions);
+        }
+        return this.client.gateway.remunerate(claimsBytes, sigWords);
+    }
+    async listSettledTabs() {
+        const tabs = await this.client.rpc.listSettledTabs(this.recipientAddress);
+        return tabs.map((t) => models_1.TabInfo.fromRpc(t));
+    }
+    async listPendingRemunerations() {
+        const items = await this.client.rpc.listPendingRemunerations(this.recipientAddress);
+        return items.map((item) => models_1.PendingRemunerationInfo.fromRpc(item));
+    }
+    async getTab(tabId) {
+        const result = await this.client.rpc.getTab(tabId);
+        return result ? models_1.TabInfo.fromRpc(result) : null;
+    }
+    async listRecipientTabs(settlementStatuses) {
+        const tabs = await this.client.rpc.listRecipientTabs(this.recipientAddress, settlementStatuses);
+        return tabs.map((t) => models_1.TabInfo.fromRpc(t));
+    }
+    async getTabGuarantees(tabId) {
+        const guarantees = await this.client.rpc.getTabGuarantees(tabId);
+        return guarantees.map((g) => models_1.GuaranteeInfo.fromRpc(g));
+    }
+    async getLatestGuarantee(tabId) {
+        const result = await this.client.rpc.getLatestGuarantee(tabId);
+        return result ? models_1.GuaranteeInfo.fromRpc(result) : null;
+    }
+    async getGuarantee(tabId, reqId) {
+        const result = await this.client.rpc.getGuarantee(tabId, reqId);
+        return result ? models_1.GuaranteeInfo.fromRpc(result) : null;
+    }
+    async listRecipientPayments() {
+        const payments = await this.client.rpc.listRecipientPayments(this.recipientAddress);
+        return payments.map((p) => models_1.RecipientPaymentInfo.fromRpc(p));
+    }
+    async getCollateralEventsForTab(tabId) {
+        const events = await this.client.rpc.getCollateralEventsForTab(tabId);
+        return events.map((ev) => models_1.CollateralEventInfo.fromRpc(ev));
+    }
+    async getUserAssetBalance(userAddress, assetAddress) {
+        const balance = await this.client.rpc.getUserAssetBalance(userAddress, assetAddress);
+        return balance ? models_1.AssetBalanceInfo.fromRpc(balance) : null;
+    }
+}
+exports.RecipientClient = RecipientClient;

package/dist/client/shared.d.ts

@@ -0,0 +1,11 @@
+import { TabPaymentStatus } from '../models';
+export declare const isNumericLike: (value: unknown) => value is number | bigint | string;
+export type RpcTabStatus = {
+    paid?: number | bigint | string;
+    paidAmount?: number | bigint | string;
+    remunerated?: boolean;
+    paidOut?: boolean;
+    asset?: string;
+    assetAddress?: string;
+};
+export declare function tabStatusFromRpc(status: RpcTabStatus): TabPaymentStatus;

package/dist/client/shared.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNumericLike = void 0;
+exports.tabStatusFromRpc = tabStatusFromRpc;
+const utils_1 = require("../utils");
+const isNumericLike = (value) => typeof value === 'number' || typeof value === 'bigint' || typeof value === 'string';
+exports.isNumericLike = isNumericLike;
+function tabStatusFromRpc(status) {
+    const paid = status.paid !== undefined ? status.paid : (status.paidAmount ?? 0);
+    const remunerated = status.remunerated ?? status.paidOut ?? false;
+    const asset = status.asset ?? status.assetAddress ?? '';
+    return {
+        paid: (0, utils_1.parseU256)(paid),
+        remunerated: Boolean(remunerated),
+        asset,
+    };
+}

package/dist/client/user.d.ts

@@ -0,0 +1,17 @@
+import { PaymentGuaranteeRequestClaims, PaymentSignature, SigningScheme, TabPaymentStatus, UserInfo } from '../models';
+import type { TxReceiptWaitOptions } from '../contract';
+import type { Client } from './index';
+export declare class UserClient {
+    private client;
+    constructor(client: Client);
+    get guaranteeDomain(): string;
+    approveErc20(token: string, amount: number | bigint | string, waitOptions?: TxReceiptWaitOptions): Promise<import("viem").TransactionReceipt>;
+    deposit(amount: number | bigint | string, erc20Token?: string, waitOptions?: TxReceiptWaitOptions): Promise<import("viem").TransactionReceipt>;
+    getUser(): Promise<UserInfo[]>;
+    getTabPaymentStatus(tabId: number | bigint): Promise<TabPaymentStatus>;
+    signPayment(claims: PaymentGuaranteeRequestClaims, scheme?: SigningScheme): Promise<PaymentSignature>;
+    payTab(tabId: number | bigint, reqId: number | bigint, amount: number | bigint | string, recipientAddress: string, erc20Token?: string, waitOptions?: TxReceiptWaitOptions): Promise<import("viem").TransactionReceipt>;
+    requestWithdrawal(amount: number | bigint | string, erc20Token?: string, waitOptions?: TxReceiptWaitOptions): Promise<import("viem").TransactionReceipt>;
+    cancelWithdrawal(erc20Token?: string, waitOptions?: TxReceiptWaitOptions): Promise<import("viem").TransactionReceipt>;
+    finalizeWithdrawal(erc20Token?: string, waitOptions?: TxReceiptWaitOptions): Promise<import("viem").TransactionReceipt>;
+}

package/dist/client/user.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserClient = void 0;
+const models_1 = require("../models");
+const shared_1 = require("./shared");
+const utils_1 = require("../utils");
+class UserClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    get guaranteeDomain() {
+        return this.client.guaranteeDomain;
+    }
+    async approveErc20(token, amount, waitOptions) {
+        if (waitOptions) {
+            return this.client.gateway.approveErc20(token, amount, waitOptions);
+        }
+        return this.client.gateway.approveErc20(token, amount);
+    }
+    async deposit(amount, erc20Token, waitOptions) {
+        if (waitOptions) {
+            return this.client.gateway.deposit(amount, erc20Token, waitOptions);
+        }
+        return this.client.gateway.deposit(amount, erc20Token);
+    }
+    async getUser() {
+        const assets = await this.client.gateway.getUserAssets();
+        return assets.map((a) => ({
+            asset: a.asset,
+            collateral: (0, utils_1.parseU256)(a.collateral),
+            withdrawalRequestAmount: (0, utils_1.parseU256)(a.withdrawalRequestAmount),
+            withdrawalRequestTimestamp: Number(a.withdrawalRequestTimestamp),
+        }));
+    }
+    async getTabPaymentStatus(tabId) {
+        const status = await this.client.gateway.getPaymentStatus(tabId);
+        return (0, shared_1.tabStatusFromRpc)(status);
+    }
+    async signPayment(claims, scheme = models_1.SigningScheme.EIP712) {
+        return this.client.signer.signRequest(this.client.params, claims, scheme);
+    }
+    async payTab(tabId, reqId, amount, recipientAddress, erc20Token, waitOptions) {
+        if (erc20Token) {
+            if (waitOptions) {
+                return this.client.gateway.payTabErc20(tabId, amount, erc20Token, recipientAddress, waitOptions);
+            }
+            return this.client.gateway.payTabErc20(tabId, amount, erc20Token, recipientAddress);
+        }
+        if (waitOptions) {
+            return this.client.gateway.payTabEth(tabId, reqId, amount, recipientAddress, waitOptions);
+        }
+        return this.client.gateway.payTabEth(tabId, reqId, amount, recipientAddress);
+    }
+    async requestWithdrawal(amount, erc20Token, waitOptions) {
+        if (waitOptions) {
+            return this.client.gateway.requestWithdrawal(amount, erc20Token, waitOptions);
+        }
+        return this.client.gateway.requestWithdrawal(amount, erc20Token);
+    }
+    async cancelWithdrawal(erc20Token, waitOptions) {
+        if (waitOptions) {
+            return this.client.gateway.cancelWithdrawal(erc20Token, waitOptions);
+        }
+        return this.client.gateway.cancelWithdrawal(erc20Token);
+    }
+    async finalizeWithdrawal(erc20Token, waitOptions) {
+        if (waitOptions) {
+            return this.client.gateway.finalizeWithdrawal(erc20Token, waitOptions);
+        }
+        return this.client.gateway.finalizeWithdrawal(erc20Token);
+    }
+}
+exports.UserClient = UserClient;

package/dist/client.js

@@ -187,7 +187,30 @@ class RecipientClient {
     }
     async remunerate(cert) {
         this.verifyPaymentGuarantee(cert);
-        const sigWords = (0, bls_1.signatureToWords)(cert.signature);
+        const describeValue = (value) => {
+            if (value === null)
+                return 'null';
+            if (value === undefined)
+                return 'undefined';
+            if (Array.isArray(value))
+                return `array(len=${value.length})`;
+            if (typeof value === 'object') {
+                const keys = Object.keys(value);
+                return `object(keys=${keys.slice(0, 6).join(',')}${keys.length > 6 ? ',...' : ''})`;
+            }
+            return typeof value;
+        };
+        if (process.env.DEBUG_CERTS === '1') {
+            const preview = typeof cert.signature === 'string' ? cert.signature.slice(0, 12) : '';
+            console.log(`  debug remunerate: signature=${describeValue(cert.signature)} ${preview}`);
+        }
+        if (typeof cert.claims !== 'string') {
+            throw new errors_1.VerificationError(`certificate.claims must be a hex string, got ${describeValue(cert.claims)}`);
+        }
+        if (typeof cert.signature !== 'string') {
+            throw new errors_1.VerificationError(`certificate.signature must be a hex string, got ${describeValue(cert.signature)}`);
+        }
+        const sigWords = await (0, bls_1.signatureToWordsAsync)(cert.signature);
         const claimsBytes = Buffer.from(cert.claims.replace(/^0x/, ''), 'hex');
         return this.client.gateway.remunerate(claimsBytes, sigWords);
     }

package/dist/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const ADMIN_API_KEY_HEADER = "x-api-key";
+export declare const ADMIN_API_KEY_PREFIX = "ak_";
+export declare const ADMIN_SCOPE_SUSPEND_USERS = "user_suspension:write";
+export declare const ADMIN_SCOPE_MANAGE_KEYS = "admin_api_keys:manage";

package/dist/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ADMIN_SCOPE_MANAGE_KEYS = exports.ADMIN_SCOPE_SUSPEND_USERS = exports.ADMIN_API_KEY_PREFIX = exports.ADMIN_API_KEY_HEADER = void 0;
+exports.ADMIN_API_KEY_HEADER = 'x-api-key';
+exports.ADMIN_API_KEY_PREFIX = 'ak_';
+exports.ADMIN_SCOPE_SUSPEND_USERS = 'user_suspension:write';
+exports.ADMIN_SCOPE_MANAGE_KEYS = 'admin_api_keys:manage';

package/dist/contract.d.ts

@@ -6,6 +6,10 @@ type CoreContract = GetContractReturnType<typeof core4micaAbi, {
     public: ReturnType<typeof createPublicClient>;
     wallet: TWalletClient;
 }>;
+export type TxReceiptWaitOptions = {
+    timeout?: number;
+    pollingInterval?: number;
+};
 export declare class ContractGateway {
     readonly publicClient: TPublicClient;
     readonly walletClient: TWalletClient;
@@ -15,8 +19,8 @@ export declare class ContractGateway {
     static create(rpcUrl: string, signer: Account, contractAddress: Hex, chainId: number): Promise<ContractGateway>;
     private erc20;
     getGuaranteeDomain(): Promise<string>;
-    approveErc20(token: string, amount: number | bigint | string): Promise<import("viem").TransactionReceipt>;
-    deposit(amount: number | bigint | string, erc20Token?: string): Promise<import("viem").TransactionReceipt>;
+    approveErc20(token: string, amount: number | bigint | string, waitOptions?: TxReceiptWaitOptions): Promise<import("viem").TransactionReceipt>;
+    deposit(amount: number | bigint | string, erc20Token?: string, waitOptions?: TxReceiptWaitOptions): Promise<import("viem").TransactionReceipt>;
     getUserAssets(): Promise<{
         asset: `0x${string}`;
         collateral: bigint;
@@ -28,11 +32,11 @@ export declare class ContractGateway {
         remunerated: boolean;
         asset: Hex;
     }>;
-    payTabEth(tabId: number | bigint, reqId: number | bigint, amount: number | bigint | string, recipient: string): Promise<import("viem").TransactionReceipt>;
-    payTabErc20(tabId: number | bigint, amount: number | bigint | string, erc20Token: string, recipient: string): Promise<import("viem").TransactionReceipt>;
-    requestWithdrawal(amount: number | bigint | string, erc20Token?: string): Promise<import("viem").TransactionReceipt>;
-    cancelWithdrawal(erc20Token?: string): Promise<import("viem").TransactionReceipt>;
-    finalizeWithdrawal(erc20Token?: string): Promise<import("viem").TransactionReceipt>;
-    remunerate(claimsBlob: Uint8Array, signatureWords: Uint8Array[]): Promise<import("viem").TransactionReceipt>;
+    payTabEth(tabId: number | bigint, reqId: number | bigint, amount: number | bigint | string, recipient: string, waitOptions?: TxReceiptWaitOptions): Promise<import("viem").TransactionReceipt>;
+    payTabErc20(tabId: number | bigint, amount: number | bigint | string, erc20Token: string, recipient: string, waitOptions?: TxReceiptWaitOptions): Promise<import("viem").TransactionReceipt>;
+    requestWithdrawal(amount: number | bigint | string, erc20Token?: string, waitOptions?: TxReceiptWaitOptions): Promise<import("viem").TransactionReceipt>;
+    cancelWithdrawal(erc20Token?: string, waitOptions?: TxReceiptWaitOptions): Promise<import("viem").TransactionReceipt>;
+    finalizeWithdrawal(erc20Token?: string, waitOptions?: TxReceiptWaitOptions): Promise<import("viem").TransactionReceipt>;
+    remunerate(claimsBlob: Uint8Array, signatureWords: Uint8Array[], waitOptions?: TxReceiptWaitOptions): Promise<import("viem").TransactionReceipt>;
 }
 export {};

package/dist/contract.js

@@ -2,31 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContractGateway = void 0;
 const viem_1 = require("viem");
-const chains_1 = require("viem/chains");
 const core4mica_1 = require("./abi/core4mica");
+const chain_1 = require("./chain");
 const utils_1 = require("./utils");
-const CHAINS = {
-    1: chains_1.mainnet,
-    11155111: chains_1.sepolia,
-    8453: chains_1.base,
-    84532: chains_1.baseSepolia,
-    137: chains_1.polygon,
-    80002: chains_1.polygonAmoy,
-};
-function getChain(chainId, rpcUrl) {
-    const chain = CHAINS[chainId];
-    if (chain)
-        return chain;
-    return {
-        id: chainId,
-        name: `local-${chainId}`,
-        nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
-        rpcUrls: {
-            default: { http: [rpcUrl] },
-            public: { http: [rpcUrl] },
-        },
-    };
-}
 class ContractGateway {
     publicClient;
     walletClient;
@@ -38,7 +16,7 @@ class ContractGateway {
         this.contract = contract;
     }
     static async create(rpcUrl, signer, contractAddress, chainId) {
-        const chain = getChain(chainId, rpcUrl);
+        const chain = (0, chain_1.getChain)(chainId, rpcUrl);
         const publicClient = (0, viem_1.createPublicClient)({
             transport: (0, viem_1.http)(rpcUrl),
         });
@@ -74,14 +52,14 @@ class ContractGateway {
     async getGuaranteeDomain() {
         return this.contract.read.guaranteeDomainSeparator();
     }
-    async approveErc20(token, amount) {
+    async approveErc20(token, amount, waitOptions) {
         const erc20 = this.erc20(token);
         // spender address logic
         const spender = this.contract.address;
         const hash = await erc20.write.approve([spender, (0, utils_1.parseU256)(amount)]);
-        return this.publicClient.waitForTransactionReceipt({ hash });
+        return this.publicClient.waitForTransactionReceipt({ hash, ...(waitOptions ?? {}) });
     }
-    async deposit(amount, erc20Token) {
+    async deposit(amount, erc20Token, waitOptions) {
         let hash;
         if (erc20Token) {
             hash = await this.contract.write.depositStablecoin([erc20Token, (0, utils_1.parseU256)(amount)]);
@@ -89,7 +67,7 @@ class ContractGateway {
         else {
             hash = await this.contract.write.deposit({ value: (0, utils_1.parseU256)(amount) });
         }
-        return this.publicClient.waitForTransactionReceipt({ hash });
+        return this.publicClient.waitForTransactionReceipt({ hash, ...(waitOptions ?? {}) });
     }
     async getUserAssets() {
         const addr = this.walletClient.account.address;
@@ -111,25 +89,25 @@ class ContractGateway {
             asset,
         };
     }
-    async payTabEth(tabId, reqId, amount, recipient) {
+    async payTabEth(tabId, reqId, amount, recipient, waitOptions) {
         const data = new TextEncoder().encode(`tab_id:${tabId.toString(16)};req_id:${reqId.toString(16)}`);
         const hash = await this.walletClient.sendTransaction({
             to: recipient,
             value: (0, utils_1.parseU256)(amount),
             data: (0, utils_1.hexFromBytes)(data),
         });
-        return this.publicClient.waitForTransactionReceipt({ hash });
+        return this.publicClient.waitForTransactionReceipt({ hash, ...(waitOptions ?? {}) });
     }
-    async payTabErc20(tabId, amount, erc20Token, recipient) {
+    async payTabErc20(tabId, amount, erc20Token, recipient, waitOptions) {
         const hash = await this.contract.write.payTabInERC20Token([
             (0, utils_1.parseU256)(tabId),
             erc20Token,
             (0, utils_1.parseU256)(amount),
             recipient,
         ]);
-        return this.publicClient.waitForTransactionReceipt({ hash });
+        return this.publicClient.waitForTransactionReceipt({ hash, ...(waitOptions ?? {}) });
     }
-    async requestWithdrawal(amount, erc20Token) {
+    async requestWithdrawal(amount, erc20Token, waitOptions) {
         const value = (0, utils_1.parseU256)(amount);
         let hash;
         if (erc20Token) {
@@ -138,9 +116,9 @@ class ContractGateway {
         else {
             hash = await this.contract.write.requestWithdrawal([value]);
         }
-        return this.publicClient.waitForTransactionReceipt({ hash });
+        return this.publicClient.waitForTransactionReceipt({ hash, ...(waitOptions ?? {}) });
     }
-    async cancelWithdrawal(erc20Token) {
+    async cancelWithdrawal(erc20Token, waitOptions) {
         let hash;
         if (erc20Token) {
             hash = await this.contract.write.cancelWithdrawal([erc20Token]);
@@ -148,9 +126,9 @@ class ContractGateway {
         else {
             hash = await this.contract.write.cancelWithdrawal();
         }
-        return this.publicClient.waitForTransactionReceipt({ hash });
+        return this.publicClient.waitForTransactionReceipt({ hash, ...(waitOptions ?? {}) });
     }
-    async finalizeWithdrawal(erc20Token) {
+    async finalizeWithdrawal(erc20Token, waitOptions) {
         let hash;
         if (erc20Token) {
             hash = await this.contract.write.finalizeWithdrawal([erc20Token]);
@@ -158,9 +136,9 @@ class ContractGateway {
         else {
             hash = await this.contract.write.finalizeWithdrawal();
         }
-        return this.publicClient.waitForTransactionReceipt({ hash });
+        return this.publicClient.waitForTransactionReceipt({ hash, ...(waitOptions ?? {}) });
     }
-    async remunerate(claimsBlob, signatureWords) {
+    async remunerate(claimsBlob, signatureWords, waitOptions) {
         const sigStruct = {
             x_c0_a: (0, utils_1.hexFromBytes)(signatureWords[0]),
             x_c0_b: (0, utils_1.hexFromBytes)(signatureWords[1]),
@@ -172,7 +150,7 @@ class ContractGateway {
             y_c1_b: (0, utils_1.hexFromBytes)(signatureWords[7]),
         };
         const hash = await this.contract.write.remunerate([(0, utils_1.hexFromBytes)(claimsBlob), sigStruct]);
-        return this.publicClient.waitForTransactionReceipt({ hash });
+        return this.publicClient.waitForTransactionReceipt({ hash, ...(waitOptions ?? {}) });
     }
 }
 exports.ContractGateway = ContractGateway;

package/dist/debug.d.ts

@@ -0,0 +1,2 @@
+export declare const DEBUG_BLS: boolean;
+export declare const DEBUG_CERTS: boolean;

package/dist/debug.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEBUG_CERTS = exports.DEBUG_BLS = void 0;
+exports.DEBUG_BLS = process.env.DEBUG_BLS === '1';
+exports.DEBUG_CERTS = process.env.DEBUG_CERTS === '1';

package/dist/guarantee.js

@@ -5,6 +5,8 @@ exports.decodeGuaranteeClaims = decodeGuaranteeClaims;
 const viem_1 = require("viem");
 const errors_1 = require("./errors");
 const utils_1 = require("./utils");
+const CLAIMS_ENCODED_BYTES = 32 * 10;
+const WRAPPED_CLAIMS_BYTES = 32 * 2 + 32 + CLAIMS_ENCODED_BYTES;
 const CLAIM_TYPES = [
     { type: 'bytes32' },
     { type: 'uint256' },
@@ -24,6 +26,12 @@ function ensureDomainBytes(domain) {
     }
     return bytes;
 }
+function normalizeHexBytes(data) {
+    if (typeof data === 'string') {
+        return (data.startsWith('0x') ? data : `0x${data}`);
+    }
+    return (0, utils_1.hexFromBytes)(data);
+}
 function encodeGuaranteeClaims(claims) {
     if (claims.version !== 1) {
         throw new errors_1.VerificationError(`unsupported guarantee claims version: ${claims.version}`);
@@ -44,12 +52,26 @@ function encodeGuaranteeClaims(claims) {
     return (0, viem_1.encodeAbiParameters)([{ type: 'uint64' }, { type: 'bytes' }], [BigInt(claims.version), encoded]);
 }
 function decodeGuaranteeClaims(data) {
-    const rawBytes = typeof data === 'string' ? (0, viem_1.toBytes)(data) : data;
-    const [version, encoded] = (0, viem_1.decodeAbiParameters)([{ type: 'uint64' }, { type: 'bytes' }], rawBytes);
-    if (version !== 1n) {
-        throw new errors_1.VerificationError(`unsupported guarantee claims version: ${version}`);
+    const hex = normalizeHexBytes(data);
+    const byteLen = (hex.length - 2) / 2;
+    let encoded;
+    if (byteLen === CLAIMS_ENCODED_BYTES) {
+        encoded = hex;
+    }
+    else {
+        if (byteLen !== WRAPPED_CLAIMS_BYTES) {
+            throw new errors_1.VerificationError(`unexpected guarantee claims length: ${byteLen} bytes`);
+        }
+        const [version, wrapped] = (0, viem_1.decodeAbiParameters)([{ type: 'uint64' }, { type: 'bytes' }], hex);
+        if (version !== 1n) {
+            throw new errors_1.VerificationError(`unsupported guarantee claims version: ${version}`);
+        }
+        encoded = wrapped;
     }
     const [domain, tabId, reqId, user, recipient, amount, totalAmount, asset, timestamp, claimsVersion,] = (0, viem_1.decodeAbiParameters)(CLAIM_TYPES, encoded);
+    if (claimsVersion !== 1n) {
+        throw new errors_1.VerificationError(`unsupported guarantee claims version: ${claimsVersion}`);
+    }
     return {
         domain: (0, viem_1.toBytes)(domain),
         userAddress: user,

package/dist/http.d.ts

@@ -0,0 +1,11 @@
+export type FetchFn = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+type DecodeErrorFactory = (message: string, response: Response) => Error;
+type HttpErrorFactory = (message: string, response: Response, body: unknown) => Error;
+export declare function normalizeBaseUrl(endpoint: string): string;
+export declare function extractErrorMessage(payload: unknown): string;
+export declare function requestJson<T>(fetchFn: FetchFn, url: string, init: RequestInit, options: {
+    decodeError: DecodeErrorFactory;
+    httpError: HttpErrorFactory;
+    allowEmptyOk?: boolean;
+}): Promise<T>;
+export {};

package/dist/http.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeBaseUrl = normalizeBaseUrl;
+exports.extractErrorMessage = extractErrorMessage;
+exports.requestJson = requestJson;
+function normalizeBaseUrl(endpoint) {
+    return endpoint.endsWith('/') ? endpoint.slice(0, -1) : endpoint;
+}
+function extractErrorMessage(payload) {
+    if (payload && typeof payload === 'object') {
+        const record = payload;
+        const error = record.error;
+        const msg = record.message;
+        return ((typeof error === 'string' && error) ||
+            (typeof msg === 'string' && msg) ||
+            JSON.stringify(record, (_k, v) => v));
+    }
+    if (typeof payload === 'string' && payload.trim()) {
+        return payload.trim();
+    }
+    return 'unknown error';
+}
+async function requestJson(fetchFn, url, init, options) {
+    const response = await fetchFn(url, init);
+    let text = '';
+    try {
+        text = await response.text();
+    }
+    catch (err) {
+        throw options.decodeError(`invalid response from ${response.url}: ${String(err)}`, response);
+    }
+    let payload = null;
+    let parsed = false;
+    let parseError;
+    if (text) {
+        try {
+            payload = JSON.parse(text);
+            parsed = true;
+        }
+        catch (err) {
+            payload = text;
+            parseError = err;
+        }
+    }
+    if (!response.ok) {
+        const message = `${response.status}: ${extractErrorMessage(payload)}`;
+        throw options.httpError(message, response, payload);
+    }
+    if (!text && !options.allowEmptyOk) {
+        throw options.decodeError(`invalid JSON response from ${response.url}: empty response body`, response);
+    }
+    if (text && !parsed) {
+        const detail = parseError instanceof Error ? parseError.message : String(parseError);
+        throw options.decodeError(`invalid JSON response from ${response.url}: ${detail}`, response);
+    }
+    return payload;
+}

package/dist/index.d.ts

@@ -1,7 +1,9 @@
 export * from './errors';
+export * from './constants';
 export * from './config';
 export * from './utils';
 export * from './models';
+export * from './payment';
 export * from './signing';
 export * from './rpc';
 export * from './auth';

package/dist/index.js

@@ -15,9 +15,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./errors"), exports);
+__exportStar(require("./constants"), exports);
 __exportStar(require("./config"), exports);
 __exportStar(require("./utils"), exports);
 __exportStar(require("./models"), exports);
+__exportStar(require("./payment"), exports);
 __exportStar(require("./signing"), exports);
 __exportStar(require("./rpc"), exports);
 __exportStar(require("./auth"), exports);

package/dist/models.d.ts

@@ -1,11 +1,8 @@
+export { ADMIN_API_KEY_HEADER, ADMIN_API_KEY_PREFIX, ADMIN_SCOPE_MANAGE_KEYS, ADMIN_SCOPE_SUSPEND_USERS, } from './constants';
 export declare enum SigningScheme {
     EIP712 = "eip712",
     EIP191 = "eip191"
 }
-export declare const ADMIN_API_KEY_HEADER = "x-api-key";
-export declare const ADMIN_API_KEY_PREFIX = "ak_";
-export declare const ADMIN_SCOPE_SUSPEND_USERS = "user_suspension:write";
-export declare const ADMIN_SCOPE_MANAGE_KEYS = "admin_api_keys:manage";
 export interface PaymentSignature {
     signature: string;
     scheme: SigningScheme;