@4mica/sdk 0.5.3 → 0.5.5

package/README.md

@@ -38,9 +38,9 @@ The SDK requires a signing key and can use sensible defaults for the rest:
 - `authUrl` and `authRefreshMarginSecs` (optional): SIWE auth config. Only used when auth is
   enabled via `enableAuth()` or by setting either value (defaults to `rpcUrl` and 60 seconds).
 
-> Note: `ethereumHttpRpcUrl` and `contractAddress` are fetched from the core service and validated
-> against the connected Ethereum provider automatically. Only override these if you need to use
-> different values than the server defaults.
+> Note: `ethereumHttpRpcUrl` and `contractAddress` are fetched from the core service by default.
+> The SDK validates the connected chain ID but does not verify the contract address or code. Only
+> override these if you need to use different values than the server defaults.
 
 ### 1) Using ConfigBuilder
 
@@ -153,6 +153,7 @@ X-PAYMENT header (and optional `/settle` call) that the facilitator will accept.
 
 At minimum you need:
 - `scheme` and `network` (scheme must include `4mica`, e.g. `4mica-credit`)
+- `payTo` (recipient address), `asset`, and `maxAmountRequired` (v1) or `amount` (v2)
 - `extra.tabEndpoint` for tab resolution
 
 `X402Flow` will refresh the tab by calling `extra.tabEndpoint` before signing.
@@ -258,6 +259,7 @@ Notes:
 - `signPayment` and `signPaymentV2` always use EIP-712 signing and will error if the scheme is not 4mica.
 - `UserClient.signPayment` supports `SigningScheme.EIP712` (default) and `SigningScheme.EIP191`.
 - `settlePayment` only hits `/settle`; resource servers should still call `/verify` first when enforcing access.
+- `RecipientClient.remunerate` requires the optional `@noble/curves` dependency for BLS decoding.
 
 ### API Methods Summary
 
@@ -303,8 +305,7 @@ Available under `client.rpc` (requires an admin API key):
 ## Error Handling
 
 All SDK errors extend `FourMicaError`. Common error types include `ConfigError`, `RpcError`,
-`ClientInitializationError`, `ContractError`, `SigningError`, `VerificationError`, `X402Error`, and
-`AuthError`.
+`SigningError`, `VerificationError`, `X402Error`, and `AuthError`.
 
 ## License
 

package/dist/auth.js

@@ -2,48 +2,32 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AuthSession = exports.AuthClient = void 0;
 exports.buildSiweMessage = buildSiweMessage;
+const http_1 = require("./http");
 const errors_1 = require("./errors");
 const utils_1 = require("./utils");
-const isRecord = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-const readString = (value, label) => {
-    if (typeof value === 'string' && value.trim()) {
-        return value;
-    }
-    throw new errors_1.AuthDecodeError(`invalid auth response: missing ${label}`);
-};
-const readNumber = (value, label) => {
-    if (typeof value === 'number' && Number.isFinite(value)) {
-        return value;
-    }
-    if (typeof value === 'string' && value.trim()) {
-        const parsed = Number(value);
-        if (Number.isFinite(parsed)) {
-            return parsed;
-        }
-    }
-    throw new errors_1.AuthDecodeError(`invalid auth response: missing ${label}`);
-};
+const serde_1 = require("./serde");
+const missingField = (label) => new errors_1.AuthDecodeError(`invalid auth response: missing ${label}`);
 const parseTokens = (payload) => {
-    const accessToken = readString(payload.access_token ?? payload.accessToken, 'access_token');
-    const refreshToken = readString(payload.refresh_token ?? payload.refreshToken, 'refresh_token');
-    const expiresIn = readNumber(payload.expires_in ?? payload.expiresIn, 'expires_in');
+    const accessToken = (0, serde_1.readString)(payload.access_token ?? payload.accessToken, 'access_token', missingField);
+    const refreshToken = (0, serde_1.readString)(payload.refresh_token ?? payload.refreshToken, 'refresh_token', missingField);
+    const expiresIn = (0, serde_1.readNumber)(payload.expires_in ?? payload.expiresIn, 'expires_in', missingField);
     return { accessToken, refreshToken, expiresIn };
 };
 const parseSiweTemplate = (payload) => {
-    const domain = readString(payload.domain, 'siwe.domain');
-    const uri = readString(payload.uri, 'siwe.uri');
-    const chainId = readNumber(payload.chain_id ?? payload.chainId, 'siwe.chain_id');
-    const statement = readString(payload.statement, 'siwe.statement');
-    const expiration = readString(payload.expiration, 'siwe.expiration');
-    const issuedAt = readString(payload.issued_at ?? payload.issuedAt, 'siwe.issued_at');
+    const domain = (0, serde_1.readString)(payload.domain, 'siwe.domain', missingField);
+    const uri = (0, serde_1.readString)(payload.uri, 'siwe.uri', missingField);
+    const chainId = (0, serde_1.readNumber)(payload.chain_id ?? payload.chainId, 'siwe.chain_id', missingField);
+    const statement = (0, serde_1.readString)(payload.statement, 'siwe.statement', missingField);
+    const expiration = (0, serde_1.readString)(payload.expiration, 'siwe.expiration', missingField);
+    const issuedAt = (0, serde_1.readString)(payload.issued_at ?? payload.issuedAt, 'siwe.issued_at', missingField);
     return { domain, uri, chainId, statement, expiration, issuedAt };
 };
 const parseNonceResponse = (payload) => {
-    if (!isRecord(payload)) {
+    if (!(0, serde_1.isRecord)(payload)) {
         throw new errors_1.AuthDecodeError('invalid auth response: nonce payload');
     }
-    const nonce = readString(payload.nonce, 'nonce');
-    if (!isRecord(payload.siwe)) {
+    const nonce = (0, serde_1.readString)(payload.nonce, 'nonce', missingField);
+    if (!(0, serde_1.isRecord)(payload.siwe)) {
         throw new errors_1.AuthDecodeError('invalid auth response: missing siwe template');
     }
     return { nonce, siwe: parseSiweTemplate(payload.siwe) };
@@ -58,7 +42,7 @@ class AuthClient {
     constructor(endpoint, fetchFn = fetch) {
         try {
             const validated = (0, utils_1.validateUrl)(endpoint);
-            this.baseUrl = validated.endsWith('/') ? validated.slice(0, -1) : validated;
+            this.baseUrl = (0, http_1.normalizeBaseUrl)(validated);
         }
         catch (err) {
             if (err instanceof utils_1.ValidationError) {
@@ -74,14 +58,14 @@ class AuthClient {
     }
     async verify(address, message, signature) {
         const payload = await this.post('/auth/verify', { address, message, signature });
-        if (!isRecord(payload)) {
+        if (!(0, serde_1.isRecord)(payload)) {
             throw new errors_1.AuthDecodeError('invalid auth response: verify payload');
         }
         return parseTokens(payload);
     }
     async refresh(refreshToken) {
         const payload = await this.post('/auth/refresh', { refresh_token: refreshToken });
-        if (!isRecord(payload)) {
+        if (!(0, serde_1.isRecord)(payload)) {
             throw new errors_1.AuthDecodeError('invalid auth response: refresh payload');
         }
         return parseTokens(payload);
@@ -97,54 +81,22 @@ class AuthClient {
         });
     }
     async request(path, init) {
-        let response;
         try {
-            response = await this.fetchFn(`${this.baseUrl}${path}`, init);
+            return await (0, http_1.requestJson)(this.fetchFn, `${this.baseUrl}${path}`, init, {
+                decodeError: (message) => new errors_1.AuthDecodeError(message),
+                httpError: (message, response, body) => new errors_1.AuthApiError(message, {
+                    status: response.status,
+                    body,
+                }),
+                allowEmptyOk: true,
+            });
         }
         catch (err) {
-            throw new errors_1.AuthTransportError(`auth request failed: ${String(err)}`);
-        }
-        let text;
-        try {
-            text = await response.text();
-        }
-        catch (err) {
-            throw new errors_1.AuthDecodeError(`invalid response from ${response.url}: ${String(err)}`);
-        }
-        let payload = text;
-        if (text) {
-            try {
-                payload = JSON.parse(text);
-            }
-            catch (err) {
-                if (response.ok) {
-                    throw new errors_1.AuthDecodeError(`invalid JSON response from ${response.url}: ${String(err)}`);
-                }
+            if (err instanceof errors_1.AuthError) {
+                throw err;
             }
+            throw new errors_1.AuthTransportError(`auth request failed: ${String(err)}`);
         }
-        else {
-            payload = null;
-        }
-        if (response.ok) {
-            return payload;
-        }
-        let message = 'unknown error';
-        if (payload && typeof payload === 'object') {
-            const record = payload;
-            const error = record.error;
-            const msg = record.message;
-            message =
-                (typeof error === 'string' && error) ||
-                    (typeof msg === 'string' && msg) ||
-                    JSON.stringify(record, (_k, v) => v);
-        }
-        else if (typeof payload === 'string' && payload.trim()) {
-            message = payload.trim();
-        }
-        throw new errors_1.AuthApiError(`${response.status}: ${message}`, {
-            status: response.status,
-            body: payload,
-        });
     }
 }
 exports.AuthClient = AuthClient;

package/dist/bls.d.ts

@@ -3,3 +3,4 @@
  * This mirrors the Python helper and requires the optional `@noble/curves` dependency.
  */
 export declare function signatureToWords(signatureHex: string): Uint8Array[];
+export declare function signatureToWordsAsync(signatureHex: string): Promise<Uint8Array[]>;

package/dist/bls.js

@@ -1,8 +1,45 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.signatureToWords = signatureToWords;
+exports.signatureToWordsAsync = signatureToWordsAsync;
 const viem_1 = require("viem");
+const debug_1 = require("./debug");
 const errors_1 = require("./errors");
+let curvesCache = null;
+let curvesPromise = null;
 function splitFp(value) {
     const be48 = value.toString(16).padStart(96, '0');
     const bytes = (0, viem_1.toBytes)(`0x${be48}`);
@@ -11,20 +48,114 @@ function splitFp(value) {
     const lo = bytes.slice(16);
     return [hi, lo];
 }
-/**
- * Expand a compressed G2 signature into the tuple expected by the contract.
- * This mirrors the Python helper and requires the optional `@noble/curves` dependency.
- */
-function signatureToWords(signatureHex) {
-    let curves;
+const normalizeBlsImportError = (err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    if (message.includes('ERR_PACKAGE_PATH_NOT_EXPORTED')) {
+        return new errors_1.VerificationError('BLS decoding requires @noble/curves; use the .js subpath (bls12-381.js) or update the SDK.');
+    }
+    if (message.includes('ERR_REQUIRE_ESM') || message.includes('require() of ES Module')) {
+        return new errors_1.VerificationError('BLS decoding requires @noble/curves; ESM install detected. Use signatureToWordsAsync or run in CJS.');
+    }
+    return new errors_1.VerificationError('BLS decoding requires @noble/curves; install it to enable remuneration');
+};
+const loadCurvesSync = () => {
+    if (curvesCache)
+        return curvesCache;
     try {
         // Lazy require to keep the dependency optional.
         // eslint-disable-next-line @typescript-eslint/no-require-imports
-        curves = require('@noble/curves/bls12-381');
+        curvesCache = require('@noble/curves/bls12-381');
+        return curvesCache;
     }
     catch {
-        throw new errors_1.VerificationError('BLS decoding requires @noble/curves; install it to enable remuneration');
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            curvesCache = require('@noble/curves/bls12-381.js');
+            return curvesCache;
+        }
+        catch (err2) {
+            throw normalizeBlsImportError(err2);
+        }
+    }
+};
+const loadCurvesAsync = async () => {
+    if (curvesCache)
+        return curvesCache;
+    if (curvesPromise)
+        return curvesPromise;
+    curvesPromise = (async () => {
+        try {
+            // Try CJS first.
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            return require('@noble/curves/bls12-381');
+        }
+        catch {
+            const mod = (await Promise.resolve().then(() => __importStar(require('@noble/curves/bls12-381.js'))));
+            return mod;
+        }
+    })();
+    curvesCache = await curvesPromise;
+    return curvesCache;
+};
+const normalizeSignature = (input) => {
+    if (debug_1.DEBUG_BLS) {
+        const type = input && typeof input === 'object'
+            ? `object(keys=${Object.keys(input)
+                .slice(0, 6)
+                .join(',')})`
+            : typeof input;
+        console.log(`  debug bls: normalizeSignature input=${type}`);
+    }
+    if (typeof input === 'string') {
+        const raw = input.startsWith('0x') ? input.slice(2) : input;
+        const bytes = (0, viem_1.toBytes)(`0x${raw}`);
+        return { hex: raw, bytes };
+    }
+    if (input instanceof Uint8Array) {
+        const hex = Buffer.from(input).toString('hex');
+        return { hex, bytes: input };
+    }
+    if (typeof Buffer !== 'undefined' && Buffer.isBuffer(input)) {
+        const hex = input.toString('hex');
+        return { hex, bytes: new Uint8Array(input) };
+    }
+    if (input instanceof ArrayBuffer) {
+        const bytes = new Uint8Array(input);
+        const hex = Buffer.from(bytes).toString('hex');
+        return { hex, bytes };
+    }
+    if (ArrayBuffer.isView(input)) {
+        const bytes = new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+        const hex = Buffer.from(bytes).toString('hex');
+        return { hex, bytes };
+    }
+    if (Array.isArray(input)) {
+        const bytes = Uint8Array.from(input);
+        const hex = Buffer.from(bytes).toString('hex');
+        return { hex, bytes };
     }
+    if (input && typeof input === 'object') {
+        const record = input;
+        if (Array.isArray(record.data)) {
+            const bytes = Uint8Array.from(record.data);
+            const hex = Buffer.from(bytes).toString('hex');
+            return { hex, bytes };
+        }
+        if ('bytes' in record) {
+            return normalizeSignature(record.bytes);
+        }
+        if ('signature' in record) {
+            return normalizeSignature(record.signature);
+        }
+    }
+    const label = input && typeof input === 'object'
+        ? `object(keys=${Object.keys(input)
+            .slice(0, 6)
+            .join(',')})`
+        : typeof input;
+    throw new errors_1.VerificationError(`expected signature hex string or bytes, got ${label}`);
+};
+const signatureToWordsWith = (curves, signatureHex) => {
     const toBigint = (field) => {
         if (typeof field === 'bigint' || typeof field === 'number' || typeof field === 'string') {
             return BigInt(field);
@@ -37,12 +168,47 @@ function signatureToWords(signatureHex) {
         }
         throw new errors_1.VerificationError('invalid BLS field element');
     };
+    const readFp2 = (value) => {
+        if (!value || typeof value !== 'object') {
+            throw new errors_1.VerificationError('invalid BLS field element');
+        }
+        const record = value;
+        if (Array.isArray(record.c) && record.c.length >= 2) {
+            return [record.c[0], record.c[1]];
+        }
+        if ('c0' in record && 'c1' in record) {
+            return [record.c0, record.c1];
+        }
+        if (Array.isArray(record.coeffs)) {
+            const coeffs = record.coeffs;
+            if (coeffs.length >= 2)
+                return [coeffs[0], coeffs[1]];
+        }
+        throw new errors_1.VerificationError('invalid BLS field element');
+    };
     try {
-        const sigBytes = (0, viem_1.toBytes)(signatureHex);
-        const point = curves.bls12_381.G2.ProjectivePoint.fromHex(sigBytes);
+        const sig = normalizeSignature(signatureHex);
+        const g2 = curves.bls12_381.G2;
+        const pointCtor = g2.Point ?? g2.ProjectivePoint;
+        if (!pointCtor?.fromHex) {
+            throw new errors_1.VerificationError('unsupported @noble/curves BLS export');
+        }
+        let point;
+        try {
+            point = pointCtor.fromHex(sig.bytes);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (message.includes('hex string expected')) {
+                point = pointCtor.fromHex(sig.hex);
+            }
+            else {
+                throw err;
+            }
+        }
         const affine = point.toAffine();
-        const [x0, x1] = affine.x.c;
-        const [y0, y1] = affine.y.c;
+        const [x0, x1] = readFp2(affine.x);
+        const [y0, y1] = readFp2(affine.y);
         const coords = [x0, x1, y0, y1].map((fp) => toBigint(fp));
         const words = [];
         coords.forEach((coord) => {
@@ -55,4 +221,16 @@ function signatureToWords(signatureHex) {
         const message = err instanceof Error ? err.message : String(err);
         throw new errors_1.VerificationError(`invalid BLS signature: ${message}`);
     }
+};
+/**
+ * Expand a compressed G2 signature into the tuple expected by the contract.
+ * This mirrors the Python helper and requires the optional `@noble/curves` dependency.
+ */
+function signatureToWords(signatureHex) {
+    const curves = loadCurvesSync();
+    return signatureToWordsWith(curves, signatureHex);
+}
+async function signatureToWordsAsync(signatureHex) {
+    const curves = await loadCurvesAsync();
+    return signatureToWordsWith(curves, signatureHex);
 }

package/dist/chain.d.ts

@@ -0,0 +1,2 @@
+import type { Chain } from 'viem';
+export declare function getChain(chainId: number, rpcUrl: string): Chain;

package/dist/chain.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChain = getChain;
+const chains_1 = require("viem/chains");
+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] },
+        },
+    };
+}

package/dist/client/index.d.ts

@@ -0,0 +1,24 @@
+import type { AuthTokens } from '../auth';
+import { Config } from '../config';
+import { ContractGateway } from '../contract';
+import { RpcProxy } from '../rpc';
+import { CorePublicParameters, PaymentSigner } from '../signing';
+import { RecipientClient } from './recipient';
+import { UserClient } from './user';
+export declare class Client {
+    readonly rpc: RpcProxy;
+    readonly params: CorePublicParameters;
+    readonly gateway: ContractGateway;
+    readonly guaranteeDomain: string;
+    readonly user: UserClient;
+    readonly recipient: RecipientClient;
+    readonly signer: PaymentSigner;
+    private authSession?;
+    private constructor();
+    static new(cfg: Config): Promise<Client>;
+    private static buildGateway;
+    aclose(): Promise<void>;
+    login(): Promise<AuthTokens>;
+}
+export { UserClient } from './user';
+export { RecipientClient } from './recipient';

package/dist/client/index.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecipientClient = exports.UserClient = exports.Client = void 0;
+const auth_1 = require("../auth");
+const contract_1 = require("../contract");
+const errors_1 = require("../errors");
+const rpc_1 = require("../rpc");
+const signing_1 = require("../signing");
+const recipient_1 = require("./recipient");
+const user_1 = require("./user");
+class Client {
+    rpc;
+    params;
+    gateway;
+    guaranteeDomain;
+    user;
+    recipient;
+    signer;
+    authSession;
+    constructor(rpc, params, gateway, guaranteeDomain, signer, authSession) {
+        this.rpc = rpc;
+        this.params = params;
+        this.gateway = gateway;
+        this.guaranteeDomain = guaranteeDomain;
+        this.signer = signer;
+        this.authSession = authSession;
+        this.user = new user_1.UserClient(this);
+        this.recipient = new recipient_1.RecipientClient(this);
+    }
+    static async new(cfg) {
+        const rpc = new rpc_1.RpcProxy(cfg.rpcUrl, cfg.adminApiKey);
+        const params = await rpc.getPublicParams();
+        const gateway = await Client.buildGateway(cfg, params);
+        const guaranteeDomain = await gateway.getGuaranteeDomain();
+        const signer = new signing_1.PaymentSigner(cfg.signer);
+        const authEnabled = cfg.authUrl !== undefined || cfg.authRefreshMarginSecs !== undefined;
+        const authSession = cfg.bearerToken || !authEnabled
+            ? undefined
+            : new auth_1.AuthSession({
+                authUrl: cfg.authUrl ?? cfg.rpcUrl,
+                signer: cfg.signer,
+                refreshMarginSecs: cfg.authRefreshMarginSecs ?? 60,
+            });
+        if (cfg.bearerToken) {
+            rpc.withBearerToken(cfg.bearerToken);
+        }
+        else if (authSession) {
+            rpc.withTokenProvider(() => authSession.accessToken());
+        }
+        return new Client(rpc, params, gateway, guaranteeDomain, signer, authSession);
+    }
+    static async buildGateway(cfg, params) {
+        const ethRpcUrl = cfg.ethereumHttpRpcUrl ?? params.ethereumHttpRpcUrl;
+        const contractAddress = cfg.contractAddress ?? params.contractAddress;
+        return contract_1.ContractGateway.create(ethRpcUrl, cfg.signer, contractAddress, params.chainId);
+    }
+    async aclose() {
+        await this.rpc.aclose();
+    }
+    async login() {
+        if (!this.authSession) {
+            throw new errors_1.AuthMissingConfigError('auth is not enabled');
+        }
+        return this.authSession.login();
+    }
+}
+exports.Client = Client;
+var user_2 = require("./user");
+Object.defineProperty(exports, "UserClient", { enumerable: true, get: function () { return user_2.UserClient; } });
+var recipient_2 = require("./recipient");
+Object.defineProperty(exports, "RecipientClient", { enumerable: true, get: function () { return recipient_2.RecipientClient; } });

package/dist/client/recipient.d.ts

@@ -0,0 +1,24 @@
+import { AssetBalanceInfo, BLSCert, CollateralEventInfo, GuaranteeInfo, PaymentGuaranteeClaims, PaymentGuaranteeRequestClaims, PendingRemunerationInfo, RecipientPaymentInfo, SigningScheme, TabInfo, TabPaymentStatus } from '../models';
+import type { TxReceiptWaitOptions } from '../contract';
+import type { Client } from './index';
+export declare class RecipientClient {
+    private client;
+    constructor(client: Client);
+    private get recipientAddress();
+    get guaranteeDomain(): string;
+    createTab(userAddress: string, recipientAddress: string, erc20Token: string | undefined | null, ttl?: number | null): Promise<bigint>;
+    getTabPaymentStatus(tabId: number | bigint): Promise<TabPaymentStatus>;
+    issuePaymentGuarantee(claims: PaymentGuaranteeRequestClaims, signature: string, scheme: SigningScheme): Promise<BLSCert>;
+    verifyPaymentGuarantee(cert: BLSCert): PaymentGuaranteeClaims;
+    remunerate(cert: BLSCert, waitOptions?: TxReceiptWaitOptions): Promise<import("viem").TransactionReceipt>;
+    listSettledTabs(): Promise<TabInfo[]>;
+    listPendingRemunerations(): Promise<PendingRemunerationInfo[]>;
+    getTab(tabId: number | bigint): Promise<TabInfo | null>;
+    listRecipientTabs(settlementStatuses?: string[]): Promise<TabInfo[]>;
+    getTabGuarantees(tabId: number | bigint): Promise<GuaranteeInfo[]>;
+    getLatestGuarantee(tabId: number | bigint): Promise<GuaranteeInfo | null>;
+    getGuarantee(tabId: number | bigint, reqId: number | bigint): Promise<GuaranteeInfo | null>;
+    listRecipientPayments(): Promise<RecipientPaymentInfo[]>;
+    getCollateralEventsForTab(tabId: number | bigint): Promise<CollateralEventInfo[]>;
+    getUserAssetBalance(userAddress: string, assetAddress: string): Promise<AssetBalanceInfo | null>;
+}