@4mica/sdk 0.5.0

package/dist/guarantee.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeGuaranteeClaims = encodeGuaranteeClaims;
+exports.decodeGuaranteeClaims = decodeGuaranteeClaims;
+const ethers_1 = require("ethers");
+const errors_1 = require("./errors");
+const utils_1 = require("./utils");
+const CLAIM_TYPES = [
+    'bytes32',
+    'uint256',
+    'uint256',
+    'address',
+    'address',
+    'uint256',
+    'uint256',
+    'address',
+    'uint64',
+    'uint64',
+];
+const coder = ethers_1.AbiCoder.defaultAbiCoder();
+function ensureDomainBytes(domain) {
+    const bytes = typeof domain === 'string' ? (0, ethers_1.getBytes)(domain) : domain;
+    if (bytes.length !== 32) {
+        throw new errors_1.VerificationError('domain separator must be 32 bytes');
+    }
+    return bytes;
+}
+function encodeGuaranteeClaims(claims) {
+    if (claims.version !== 1) {
+        throw new errors_1.VerificationError(`unsupported guarantee claims version: ${claims.version}`);
+    }
+    const domain = ensureDomainBytes(claims.domain);
+    const encoded = coder.encode(CLAIM_TYPES, [
+        domain,
+        (0, utils_1.parseU256)(claims.tabId),
+        (0, utils_1.parseU256)(claims.reqId),
+        claims.userAddress,
+        claims.recipientAddress,
+        (0, utils_1.parseU256)(claims.amount),
+        (0, utils_1.parseU256)(claims.totalAmount),
+        claims.assetAddress,
+        BigInt(claims.timestamp),
+        BigInt(claims.version),
+    ]);
+    return coder.encode(['uint64', 'bytes'], [BigInt(claims.version), encoded]);
+}
+function decodeGuaranteeClaims(data) {
+    const rawBytes = typeof data === 'string' ? (0, ethers_1.getBytes)(data) : data;
+    const [version, encoded] = coder.decode(['uint64', 'bytes'], rawBytes);
+    if (version !== 1n) {
+        throw new errors_1.VerificationError(`unsupported guarantee claims version: ${version}`);
+    }
+    const [domain, tabId, reqId, user, recipient, amount, totalAmount, asset, timestamp, claimsVersion,] = coder.decode(CLAIM_TYPES, encoded);
+    return {
+        domain: (0, ethers_1.getBytes)(domain),
+        userAddress: user,
+        recipientAddress: recipient,
+        tabId: (0, utils_1.parseU256)(tabId),
+        reqId: (0, utils_1.parseU256)(reqId),
+        amount: (0, utils_1.parseU256)(amount),
+        totalAmount: (0, utils_1.parseU256)(totalAmount),
+        assetAddress: asset,
+        timestamp: Number(timestamp),
+        version: Number(claimsVersion),
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export * from './errors';
+export * from './config';
+export * from './utils';
+export * from './models';
+export * from './signing';
+export * from './rpc';
+export * from './auth';
+export * from './contract';
+export * from './guarantee';
+export * from './bls';
+export * from './x402/index';
+export * from './client';

package/dist/index.js

@@ -0,0 +1,28 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./errors"), exports);
+__exportStar(require("./config"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./models"), exports);
+__exportStar(require("./signing"), exports);
+__exportStar(require("./rpc"), exports);
+__exportStar(require("./auth"), exports);
+__exportStar(require("./contract"), exports);
+__exportStar(require("./guarantee"), exports);
+__exportStar(require("./bls"), exports);
+__exportStar(require("./x402/index"), exports);
+__exportStar(require("./client"), exports);

package/dist/models.d.ts

@@ -0,0 +1,150 @@
+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;
+}
+export declare class PaymentGuaranteeRequestClaims {
+    userAddress: string;
+    recipientAddress: string;
+    tabId: bigint;
+    reqId: bigint;
+    amount: bigint;
+    timestamp: number;
+    assetAddress: string;
+    constructor(init: {
+        userAddress: string;
+        recipientAddress: string;
+        tabId: bigint;
+        reqId?: bigint;
+        amount: bigint;
+        timestamp: number;
+        assetAddress: string;
+    });
+    static new(userAddress: string, recipientAddress: string, tabId: number | bigint | string, amount: number | bigint | string, timestamp: number, erc20Token?: string | null, reqId?: number | bigint | string): PaymentGuaranteeRequestClaims;
+}
+export interface PaymentGuaranteeClaims {
+    domain: Uint8Array;
+    userAddress: string;
+    recipientAddress: string;
+    tabId: bigint;
+    reqId: bigint;
+    amount: bigint;
+    totalAmount: bigint;
+    assetAddress: string;
+    timestamp: number;
+    version: number;
+}
+export interface BLSCert {
+    claims: string;
+    signature: string;
+}
+export interface TabPaymentStatus {
+    paid: bigint;
+    remunerated: boolean;
+    asset: string;
+}
+export interface UserInfo {
+    asset: string;
+    collateral: bigint;
+    withdrawalRequestAmount: bigint;
+    withdrawalRequestTimestamp: number;
+}
+export declare class UserSuspensionStatus {
+    userAddress: string;
+    suspended: boolean;
+    updatedAt: number;
+    constructor(userAddress: string, suspended: boolean, updatedAt: number);
+    static fromRpc(raw: Record<string, unknown>): UserSuspensionStatus;
+}
+export declare class AdminApiKeyInfo {
+    id: string;
+    name: string;
+    scopes: string[];
+    createdAt: number;
+    revokedAt?: number | null | undefined;
+    constructor(id: string, name: string, scopes: string[], createdAt: number, revokedAt?: number | null | undefined);
+    static fromRpc(raw: Record<string, unknown>): AdminApiKeyInfo;
+}
+export declare class AdminApiKeySecret {
+    id: string;
+    name: string;
+    scopes: string[];
+    createdAt: number;
+    apiKey: string;
+    constructor(id: string, name: string, scopes: string[], createdAt: number, apiKey: string);
+    static fromRpc(raw: Record<string, unknown>): AdminApiKeySecret;
+}
+export declare class TabInfo {
+    tabId: bigint;
+    userAddress: string;
+    recipientAddress: string;
+    assetAddress: string;
+    startTimestamp: number;
+    ttlSeconds: number;
+    status: string;
+    settlementStatus: string;
+    createdAt: number;
+    updatedAt: number;
+    constructor(tabId: bigint, userAddress: string, recipientAddress: string, assetAddress: string, startTimestamp: number, ttlSeconds: number, status: string, settlementStatus: string, createdAt: number, updatedAt: number);
+    static fromRpc(raw: Record<string, unknown>): TabInfo;
+}
+export declare class GuaranteeInfo {
+    tabId: bigint;
+    reqId: bigint;
+    fromAddress: string;
+    toAddress: string;
+    assetAddress: string;
+    amount: bigint;
+    timestamp: number;
+    certificate?: string | null | undefined;
+    constructor(tabId: bigint, reqId: bigint, fromAddress: string, toAddress: string, assetAddress: string, amount: bigint, timestamp: number, certificate?: string | null | undefined);
+    static fromRpc(raw: Record<string, unknown>): GuaranteeInfo;
+}
+export declare class PendingRemunerationInfo {
+    tab: TabInfo;
+    latestGuarantee?: (GuaranteeInfo | null) | undefined;
+    constructor(tab: TabInfo, latestGuarantee?: (GuaranteeInfo | null) | undefined);
+    static fromRpc(raw: Record<string, unknown>): PendingRemunerationInfo;
+}
+export declare class CollateralEventInfo {
+    id: string;
+    userAddress: string;
+    assetAddress: string;
+    amount: bigint;
+    eventType: string;
+    tabId?: bigint | null | undefined;
+    reqId?: bigint | null | undefined;
+    txId?: string | null | undefined;
+    createdAt: number;
+    constructor(id: string, userAddress: string, assetAddress: string, amount: bigint, eventType: string, tabId?: bigint | null | undefined, reqId?: bigint | null | undefined, txId?: string | null | undefined, createdAt?: number);
+    static fromRpc(raw: Record<string, unknown>): CollateralEventInfo;
+}
+export declare class AssetBalanceInfo {
+    userAddress: string;
+    assetAddress: string;
+    total: bigint;
+    locked: bigint;
+    version: number;
+    updatedAt: number;
+    constructor(userAddress: string, assetAddress: string, total: bigint, locked: bigint, version: number, updatedAt: number);
+    static fromRpc(raw: Record<string, unknown>): AssetBalanceInfo;
+}
+export declare class RecipientPaymentInfo {
+    userAddress: string;
+    recipientAddress: string;
+    txHash: string;
+    amount: bigint;
+    verified: boolean;
+    finalized: boolean;
+    failed: boolean;
+    createdAt: number;
+    constructor(userAddress: string, recipientAddress: string, txHash: string, amount: bigint, verified: boolean, finalized: boolean, failed: boolean, createdAt: number);
+    static fromRpc(raw: Record<string, unknown>): RecipientPaymentInfo;
+}

package/dist/models.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecipientPaymentInfo = exports.AssetBalanceInfo = exports.CollateralEventInfo = exports.PendingRemunerationInfo = exports.GuaranteeInfo = exports.TabInfo = exports.AdminApiKeySecret = exports.AdminApiKeyInfo = exports.UserSuspensionStatus = exports.PaymentGuaranteeRequestClaims = exports.ADMIN_SCOPE_MANAGE_KEYS = exports.ADMIN_SCOPE_SUSPEND_USERS = exports.ADMIN_API_KEY_PREFIX = exports.ADMIN_API_KEY_HEADER = exports.SigningScheme = void 0;
+const utils_1 = require("./utils");
+var SigningScheme;
+(function (SigningScheme) {
+    SigningScheme["EIP712"] = "eip712";
+    SigningScheme["EIP191"] = "eip191";
+})(SigningScheme || (exports.SigningScheme = SigningScheme = {}));
+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';
+class PaymentGuaranteeRequestClaims {
+    constructor(init) {
+        this.userAddress = init.userAddress;
+        this.recipientAddress = init.recipientAddress;
+        this.tabId = init.tabId;
+        this.reqId = init.reqId ?? 0n;
+        this.amount = init.amount;
+        this.timestamp = init.timestamp;
+        this.assetAddress = init.assetAddress;
+    }
+    static new(userAddress, recipientAddress, tabId, amount, timestamp, erc20Token, reqId) {
+        const asset = erc20Token ?? '0x0000000000000000000000000000000000000000';
+        return new PaymentGuaranteeRequestClaims({
+            userAddress: (0, utils_1.normalizeAddress)(userAddress),
+            recipientAddress: (0, utils_1.normalizeAddress)(recipientAddress),
+            tabId: (0, utils_1.parseU256)(tabId),
+            reqId: reqId !== undefined ? (0, utils_1.parseU256)(reqId) : 0n,
+            amount: (0, utils_1.parseU256)(amount),
+            timestamp: Number(timestamp),
+            assetAddress: (0, utils_1.normalizeAddress)(asset),
+        });
+    }
+}
+exports.PaymentGuaranteeRequestClaims = PaymentGuaranteeRequestClaims;
+class UserSuspensionStatus {
+    constructor(userAddress, suspended, updatedAt) {
+        this.userAddress = userAddress;
+        this.suspended = suspended;
+        this.updatedAt = updatedAt;
+    }
+    static fromRpc(raw) {
+        return new UserSuspensionStatus((getAny(raw, 'user_address', 'userAddress') ?? ''), Boolean(getAny(raw, 'suspended')), Number(getAny(raw, 'updated_at', 'updatedAt') ?? 0));
+    }
+}
+exports.UserSuspensionStatus = UserSuspensionStatus;
+class AdminApiKeyInfo {
+    constructor(id, name, scopes, createdAt, revokedAt) {
+        this.id = id;
+        this.name = name;
+        this.scopes = scopes;
+        this.createdAt = createdAt;
+        this.revokedAt = revokedAt;
+    }
+    static fromRpc(raw) {
+        const revoked = getAny(raw, 'revoked_at', 'revokedAt');
+        return new AdminApiKeyInfo((getAny(raw, 'id') ?? ''), (getAny(raw, 'name') ?? ''), (getAny(raw, 'scopes') ?? []).map(String), Number(getAny(raw, 'created_at', 'createdAt') ?? 0), revoked === undefined || revoked === null ? null : Number(revoked));
+    }
+}
+exports.AdminApiKeyInfo = AdminApiKeyInfo;
+class AdminApiKeySecret {
+    constructor(id, name, scopes, createdAt, apiKey) {
+        this.id = id;
+        this.name = name;
+        this.scopes = scopes;
+        this.createdAt = createdAt;
+        this.apiKey = apiKey;
+    }
+    static fromRpc(raw) {
+        return new AdminApiKeySecret((getAny(raw, 'id') ?? ''), (getAny(raw, 'name') ?? ''), (getAny(raw, 'scopes') ?? []).map(String), Number(getAny(raw, 'created_at', 'createdAt') ?? 0), (getAny(raw, 'api_key', 'apiKey') ?? ''));
+    }
+}
+exports.AdminApiKeySecret = AdminApiKeySecret;
+function getAny(raw, ...keys) {
+    for (const key of keys) {
+        if (key in raw)
+            return raw[key];
+    }
+    return undefined;
+}
+class TabInfo {
+    constructor(tabId, userAddress, recipientAddress, assetAddress, startTimestamp, ttlSeconds, status, settlementStatus, createdAt, updatedAt) {
+        this.tabId = tabId;
+        this.userAddress = userAddress;
+        this.recipientAddress = recipientAddress;
+        this.assetAddress = assetAddress;
+        this.startTimestamp = startTimestamp;
+        this.ttlSeconds = ttlSeconds;
+        this.status = status;
+        this.settlementStatus = settlementStatus;
+        this.createdAt = createdAt;
+        this.updatedAt = updatedAt;
+    }
+    static fromRpc(raw) {
+        return new TabInfo((0, utils_1.parseU256)((getAny(raw, 'tab_id', 'tabId') ?? 0)), (getAny(raw, 'user_address', 'userAddress') ?? ''), (getAny(raw, 'recipient_address', 'recipientAddress') ?? ''), (getAny(raw, 'asset_address', 'assetAddress') ?? ''), Number(getAny(raw, 'start_timestamp', 'startTimestamp')), Number(getAny(raw, 'ttl_seconds', 'ttlSeconds')), (getAny(raw, 'status') ?? ''), (getAny(raw, 'settlement_status', 'settlementStatus') ?? ''), Number(getAny(raw, 'created_at', 'createdAt')), Number(getAny(raw, 'updated_at', 'updatedAt')));
+    }
+}
+exports.TabInfo = TabInfo;
+class GuaranteeInfo {
+    constructor(tabId, reqId, fromAddress, toAddress, assetAddress, amount, timestamp, certificate) {
+        this.tabId = tabId;
+        this.reqId = reqId;
+        this.fromAddress = fromAddress;
+        this.toAddress = toAddress;
+        this.assetAddress = assetAddress;
+        this.amount = amount;
+        this.timestamp = timestamp;
+        this.certificate = certificate;
+    }
+    static fromRpc(raw) {
+        return new GuaranteeInfo((0, utils_1.parseU256)((getAny(raw, 'tab_id', 'tabId') ?? 0)), (0, utils_1.parseU256)((getAny(raw, 'req_id', 'reqId') ?? 0)), (getAny(raw, 'from_address', 'fromAddress') ?? ''), (getAny(raw, 'to_address', 'toAddress') ?? ''), (getAny(raw, 'asset_address', 'assetAddress') ?? ''), (0, utils_1.parseU256)((getAny(raw, 'amount') ?? 0)), Number(getAny(raw, 'start_timestamp', 'startTimestamp', 'timestamp') ?? 0), getAny(raw, 'certificate'));
+    }
+}
+exports.GuaranteeInfo = GuaranteeInfo;
+class PendingRemunerationInfo {
+    constructor(tab, latestGuarantee) {
+        this.tab = tab;
+        this.latestGuarantee = latestGuarantee;
+    }
+    static fromRpc(raw) {
+        const latest = getAny(raw, 'latest_guarantee', 'latestGuarantee');
+        return new PendingRemunerationInfo(TabInfo.fromRpc(getAny(raw, 'tab') ?? {}), latest ? GuaranteeInfo.fromRpc(latest) : null);
+    }
+}
+exports.PendingRemunerationInfo = PendingRemunerationInfo;
+class CollateralEventInfo {
+    constructor(id, userAddress, assetAddress, amount, eventType, tabId, reqId, txId, createdAt = 0) {
+        this.id = id;
+        this.userAddress = userAddress;
+        this.assetAddress = assetAddress;
+        this.amount = amount;
+        this.eventType = eventType;
+        this.tabId = tabId;
+        this.reqId = reqId;
+        this.txId = txId;
+        this.createdAt = createdAt;
+    }
+    static fromRpc(raw) {
+        const tabId = getAny(raw, 'tab_id', 'tabId');
+        const reqId = getAny(raw, 'req_id', 'reqId');
+        return new CollateralEventInfo((getAny(raw, 'id') ?? ''), (getAny(raw, 'user_address', 'userAddress') ?? ''), (getAny(raw, 'asset_address', 'assetAddress') ?? ''), (0, utils_1.parseU256)((getAny(raw, 'amount') ?? 0)), (getAny(raw, 'event_type', 'eventType') ?? ''), tabId !== undefined && tabId !== null ? (0, utils_1.parseU256)(tabId) : null, reqId !== undefined && reqId !== null ? (0, utils_1.parseU256)(reqId) : null, getAny(raw, 'tx_id', 'txId'), Number(getAny(raw, 'created_at', 'createdAt') ?? 0));
+    }
+}
+exports.CollateralEventInfo = CollateralEventInfo;
+class AssetBalanceInfo {
+    constructor(userAddress, assetAddress, total, locked, version, updatedAt) {
+        this.userAddress = userAddress;
+        this.assetAddress = assetAddress;
+        this.total = total;
+        this.locked = locked;
+        this.version = version;
+        this.updatedAt = updatedAt;
+    }
+    static fromRpc(raw) {
+        return new AssetBalanceInfo((getAny(raw, 'user_address', 'userAddress') ?? ''), (getAny(raw, 'asset_address', 'assetAddress') ?? ''), (0, utils_1.parseU256)((getAny(raw, 'total') ?? 0)), (0, utils_1.parseU256)((getAny(raw, 'locked') ?? 0)), Number(getAny(raw, 'version') ?? 0), Number(getAny(raw, 'updated_at', 'updatedAt') ?? 0));
+    }
+}
+exports.AssetBalanceInfo = AssetBalanceInfo;
+class RecipientPaymentInfo {
+    constructor(userAddress, recipientAddress, txHash, amount, verified, finalized, failed, createdAt) {
+        this.userAddress = userAddress;
+        this.recipientAddress = recipientAddress;
+        this.txHash = txHash;
+        this.amount = amount;
+        this.verified = verified;
+        this.finalized = finalized;
+        this.failed = failed;
+        this.createdAt = createdAt;
+    }
+    static fromRpc(raw) {
+        return new RecipientPaymentInfo((getAny(raw, 'user_address', 'userAddress') ?? ''), (getAny(raw, 'recipient_address', 'recipientAddress') ?? ''), (getAny(raw, 'tx_hash', 'txHash') ?? ''), (0, utils_1.parseU256)((getAny(raw, 'amount') ?? 0)), Boolean(getAny(raw, 'verified')), Boolean(getAny(raw, 'finalized')), Boolean(getAny(raw, 'failed')), Number(getAny(raw, 'created_at', 'createdAt') ?? 0));
+    }
+}
+exports.RecipientPaymentInfo = RecipientPaymentInfo;

package/dist/rpc.d.ts

@@ -0,0 +1,37 @@
+import { AdminApiKeyInfo, AdminApiKeySecret, UserSuspensionStatus } from './models';
+import { CorePublicParameters } from './signing';
+export type FetchFn = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export type BearerTokenProvider = () => string | Promise<string>;
+export declare class RpcProxy {
+    private baseUrl;
+    private adminApiKey?;
+    private bearerToken?;
+    private bearerTokenProvider?;
+    private fetchFn;
+    constructor(endpoint: string, adminApiKey?: string, fetchFn?: FetchFn);
+    aclose(): Promise<void>;
+    withBearerToken(token: string): RpcProxy;
+    withTokenProvider(provider: BearerTokenProvider): RpcProxy;
+    private headers;
+    private resolveBearerToken;
+    private decode;
+    private get;
+    private post;
+    getPublicParams(): Promise<CorePublicParameters>;
+    issueGuarantee(body: Record<string, unknown>): Promise<Record<string, unknown>>;
+    createPaymentTab(body: Record<string, unknown>): Promise<Record<string, unknown>>;
+    listSettledTabs(recipientAddress: string): Promise<Record<string, unknown>[]>;
+    listPendingRemunerations(recipientAddress: string): Promise<Record<string, unknown>[]>;
+    getTab(tabId: number | bigint): Promise<Record<string, unknown> | null>;
+    listRecipientTabs(recipientAddress: string, settlementStatuses?: string[]): Promise<Record<string, unknown>[]>;
+    getTabGuarantees(tabId: number | bigint): Promise<Record<string, unknown>[]>;
+    getLatestGuarantee(tabId: number | bigint): Promise<Record<string, unknown> | null>;
+    getGuarantee(tabId: number | bigint, reqId: number | bigint): Promise<Record<string, unknown> | null>;
+    listRecipientPayments(recipientAddress: string): Promise<Record<string, unknown>[]>;
+    getCollateralEventsForTab(tabId: number | bigint): Promise<Record<string, unknown>[]>;
+    getUserAssetBalance(userAddress: string, assetAddress: string): Promise<Record<string, unknown> | null>;
+    updateUserSuspension(userAddress: string, suspended: boolean): Promise<UserSuspensionStatus>;
+    createAdminApiKey(body: Record<string, unknown>): Promise<AdminApiKeySecret>;
+    listAdminApiKeys(): Promise<AdminApiKeyInfo[]>;
+    revokeAdminApiKey(keyId: string): Promise<AdminApiKeyInfo>;
+}

package/dist/rpc.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcProxy = void 0;
+const models_1 = require("./models");
+const signing_1 = require("./signing");
+const errors_1 = require("./errors");
+function serializeTabId(tabId) {
+    return `0x${BigInt(tabId).toString(16)}`;
+}
+class RpcProxy {
+    constructor(endpoint, adminApiKey, fetchFn = fetch) {
+        this.baseUrl = endpoint.endsWith('/') ? endpoint.slice(0, -1) : endpoint;
+        this.adminApiKey = adminApiKey;
+        this.fetchFn = fetchFn;
+    }
+    async aclose() {
+        // no-op for symmetry with Python SDK
+    }
+    withBearerToken(token) {
+        this.bearerToken = token;
+        return this;
+    }
+    withTokenProvider(provider) {
+        this.bearerTokenProvider = provider;
+        return this;
+    }
+    async headers() {
+        const headers = {};
+        if (this.adminApiKey) {
+            headers[models_1.ADMIN_API_KEY_HEADER] = this.adminApiKey;
+        }
+        const token = await this.resolveBearerToken();
+        if (token) {
+            headers['Authorization'] = token;
+        }
+        return headers;
+    }
+    async resolveBearerToken() {
+        let token = this.bearerToken;
+        if (!token && this.bearerTokenProvider) {
+            token = await this.bearerTokenProvider();
+        }
+        if (!token) {
+            return undefined;
+        }
+        const trimmed = token.trim();
+        if (/^bearer\s+/i.test(trimmed)) {
+            return trimmed;
+        }
+        return `Bearer ${trimmed}`;
+    }
+    async decode(response) {
+        let payload;
+        try {
+            payload = await response.json();
+        }
+        catch (err) {
+            if (response.ok) {
+                throw new errors_1.RpcError(`invalid JSON response from ${response.url}: ${String(err)}`);
+            }
+            payload = await response.text();
+        }
+        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.RpcError(`${response.status}: ${message}`, {
+            status: response.status,
+            body: payload,
+        });
+    }
+    async get(path) {
+        const resp = await this.fetchFn(`${this.baseUrl}${path}`, {
+            headers: await this.headers(),
+            method: 'GET',
+        });
+        return this.decode(resp);
+    }
+    async post(path, body) {
+        const resp = await this.fetchFn(`${this.baseUrl}${path}`, {
+            headers: { 'content-type': 'application/json', ...(await this.headers()) },
+            method: 'POST',
+            body: JSON.stringify(body),
+        });
+        return this.decode(resp);
+    }
+    async getPublicParams() {
+        const data = await this.get('/core/public-params');
+        return signing_1.CorePublicParameters.fromRpc(data);
+    }
+    async issueGuarantee(body) {
+        return this.post('/core/guarantees', body);
+    }
+    async createPaymentTab(body) {
+        return this.post('/core/payment-tabs', body);
+    }
+    async listSettledTabs(recipientAddress) {
+        return this.get(`/core/recipients/${recipientAddress}/settled-tabs`);
+    }
+    async listPendingRemunerations(recipientAddress) {
+        return this.get(`/core/recipients/${recipientAddress}/pending-remunerations`);
+    }
+    async getTab(tabId) {
+        return this.get(`/core/tabs/${serializeTabId(tabId)}`);
+    }
+    async listRecipientTabs(recipientAddress, settlementStatuses) {
+        let query = '';
+        if (settlementStatuses?.length) {
+            query =
+                '?' + settlementStatuses.map((s) => `settlement_status=${encodeURIComponent(s)}`).join('&');
+        }
+        return this.get(`/core/recipients/${recipientAddress}/tabs${query}`);
+    }
+    async getTabGuarantees(tabId) {
+        return this.get(`/core/tabs/${serializeTabId(tabId)}/guarantees`);
+    }
+    async getLatestGuarantee(tabId) {
+        return this.get(`/core/tabs/${serializeTabId(tabId)}/guarantees/latest`);
+    }
+    async getGuarantee(tabId, reqId) {
+        return this.get(`/core/tabs/${serializeTabId(tabId)}/guarantees/${reqId}`);
+    }
+    async listRecipientPayments(recipientAddress) {
+        return this.get(`/core/recipients/${recipientAddress}/payments`);
+    }
+    async getCollateralEventsForTab(tabId) {
+        return this.get(`/core/tabs/${serializeTabId(tabId)}/collateral-events`);
+    }
+    async getUserAssetBalance(userAddress, assetAddress) {
+        return this.get(`/core/users/${userAddress}/assets/${assetAddress}`);
+    }
+    async updateUserSuspension(userAddress, suspended) {
+        const data = await this.post(`/core/users/${userAddress}/suspension`, {
+            suspended,
+        });
+        return models_1.UserSuspensionStatus.fromRpc(data);
+    }
+    async createAdminApiKey(body) {
+        const data = await this.post('/core/admin/api-keys', body);
+        return models_1.AdminApiKeySecret.fromRpc(data);
+    }
+    async listAdminApiKeys() {
+        const data = await this.get('/core/admin/api-keys');
+        return data.map((entry) => models_1.AdminApiKeyInfo.fromRpc(entry));
+    }
+    async revokeAdminApiKey(keyId) {
+        const data = await this.post(`/core/admin/api-keys/${keyId}/revoke`, {});
+        return models_1.AdminApiKeyInfo.fromRpc(data);
+    }
+}
+exports.RpcProxy = RpcProxy;