@4mica/sdk 0.5.0

package/dist/client.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecipientClient = exports.UserClient = exports.Client = void 0;
+const bls_1 = require("./bls");
+const auth_1 = require("./auth");
+const contract_1 = require("./contract");
+const errors_1 = require("./errors");
+const guarantee_1 = require("./guarantee");
+const models_1 = require("./models");
+const rpc_1 = require("./rpc");
+const signing_1 = require("./signing");
+const utils_1 = require("./utils");
+const isNumericLike = (value) => typeof value === 'number' || typeof value === 'bigint' || typeof value === 'string';
+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,
+    };
+}
+class Client {
+    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 UserClient(this);
+        this.recipient = new RecipientClient(this);
+    }
+    static async new(cfg) {
+        const rpc = new rpc_1.RpcProxy(cfg.rpcUrl, cfg.adminApiKey);
+        const params = await rpc.getPublicParams();
+        const gateway = Client.buildGateway(cfg, params);
+        await Client.validateChainId(gateway, params.chainId);
+        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 buildGateway(cfg, params) {
+        const ethRpcUrl = cfg.ethereumHttpRpcUrl ?? params.ethereumHttpRpcUrl;
+        const contractAddress = cfg.contractAddress ?? params.contractAddress;
+        return new contract_1.ContractGateway(ethRpcUrl, cfg.walletPrivateKey, contractAddress, params.chainId);
+    }
+    static async validateChainId(gateway, expectedChainId) {
+        try {
+            const chainId = await gateway.getChainId();
+            if (Number(chainId) !== Number(expectedChainId)) {
+                throw new errors_1.ClientInitializationError(`chain id mismatch between core (${expectedChainId}) and provider (${chainId})`);
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            throw new errors_1.ClientInitializationError(message);
+        }
+    }
+    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;
+class UserClient {
+    constructor(client) {
+        this.client = client;
+    }
+    get guaranteeDomain() {
+        return this.client.guaranteeDomain;
+    }
+    async approveErc20(token, amount) {
+        return this.client.gateway.approveErc20(token, amount);
+    }
+    async deposit(amount, erc20Token) {
+        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.withdrawal_request_amount),
+            withdrawalRequestTimestamp: Number(a.withdrawal_request_timestamp),
+        }));
+    }
+    async getTabPaymentStatus(tabId) {
+        const status = await this.client.gateway.getPaymentStatus(tabId);
+        return 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) {
+        if (erc20Token) {
+            return this.client.gateway.payTabErc20(tabId, amount, erc20Token, recipientAddress);
+        }
+        return this.client.gateway.payTabEth(tabId, reqId, amount, recipientAddress);
+    }
+    async requestWithdrawal(amount, erc20Token) {
+        return this.client.gateway.requestWithdrawal(amount, erc20Token);
+    }
+    async cancelWithdrawal(erc20Token) {
+        return this.client.gateway.cancelWithdrawal(erc20Token);
+    }
+    async finalizeWithdrawal(erc20Token) {
+        return this.client.gateway.finalizeWithdrawal(erc20Token);
+    }
+}
+exports.UserClient = UserClient;
+class RecipientClient {
+    constructor(client) {
+        this.client = client;
+    }
+    get recipientAddress() {
+        return (0, utils_1.normalizeAddress)(this.client.gateway.wallet.address);
+    }
+    get guaranteeDomain() {
+        return this.client.guaranteeDomain;
+    }
+    checkSigner(expected) {
+        if ((0, utils_1.normalizeAddress)(expected) !== this.recipientAddress) {
+            throw new errors_1.VerificationError('signer address does not match recipient address');
+        }
+    }
+    async createTab(userAddress, recipientAddress, erc20Token, ttl) {
+        this.checkSigner(recipientAddress);
+        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 = isNumericLike(tabIdRaw) ? tabIdRaw : 0;
+        return (0, utils_1.parseU256)(tabId);
+    }
+    async getTabPaymentStatus(tabId) {
+        const status = await this.client.gateway.getPaymentStatus(tabId);
+        return tabStatusFromRpc(status);
+    }
+    async issuePaymentGuarantee(claims, signature, scheme) {
+        this.checkSigner(claims.recipientAddress);
+        const payload = {
+            claims: {
+                version: 'v1',
+                user_address: claims.userAddress,
+                recipient_address: claims.recipientAddress,
+                tab_id: (0, utils_1.serializeU256)(claims.tabId),
+                req_id: (0, utils_1.serializeU256)(claims.reqId),
+                amount: (0, utils_1.serializeU256)(claims.amount),
+                asset_address: claims.assetAddress,
+                timestamp: Number(claims.timestamp),
+            },
+            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) {
+        this.verifyPaymentGuarantee(cert);
+        const sigWords = (0, bls_1.signatureToWords)(cert.signature);
+        const claimsBytes = Buffer.from(cert.claims.replace(/^0x/, ''), 'hex');
+        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/config.d.ts

@@ -0,0 +1,36 @@
+import { EvmSigner } from './signing';
+export interface Config {
+    rpcUrl: string;
+    walletPrivateKey: string;
+    signer: EvmSigner;
+    ethereumHttpRpcUrl?: string;
+    contractAddress?: string;
+    adminApiKey?: string;
+    bearerToken?: string;
+    authUrl?: string;
+    authRefreshMarginSecs?: number;
+}
+export declare class ConfigBuilder {
+    private _rpcUrl;
+    private _walletPrivateKey;
+    private _signer;
+    private _ethereumHttpRpcUrl?;
+    private _contractAddress?;
+    private _adminApiKey?;
+    private _bearerToken?;
+    private _authEnabled;
+    private _authUrl?;
+    private _authRefreshMarginSecs?;
+    rpcUrl(value: string): ConfigBuilder;
+    walletPrivateKey(value: string): ConfigBuilder;
+    signer(value: EvmSigner): ConfigBuilder;
+    ethereumHttpRpcUrl(value: string): ConfigBuilder;
+    contractAddress(value: string): ConfigBuilder;
+    adminApiKey(value: string): ConfigBuilder;
+    bearerToken(value: string): ConfigBuilder;
+    enableAuth(): ConfigBuilder;
+    authUrl(value: string): ConfigBuilder;
+    authRefreshMarginSecs(value: number): ConfigBuilder;
+    fromEnv(): ConfigBuilder;
+    build(): Config;
+}

package/dist/config.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigBuilder = void 0;
+const errors_1 = require("./errors");
+const signing_1 = require("./signing");
+const utils_1 = require("./utils");
+class ConfigBuilder {
+    constructor() {
+        this._rpcUrl = 'http://127.0.0.1:3000';
+        this._authEnabled = false;
+    }
+    rpcUrl(value) {
+        this._rpcUrl = value;
+        return this;
+    }
+    walletPrivateKey(value) {
+        this._walletPrivateKey = value;
+        return this;
+    }
+    signer(value) {
+        this._signer = value;
+        return this;
+    }
+    ethereumHttpRpcUrl(value) {
+        this._ethereumHttpRpcUrl = value;
+        return this;
+    }
+    contractAddress(value) {
+        this._contractAddress = value;
+        return this;
+    }
+    adminApiKey(value) {
+        this._adminApiKey = value;
+        return this;
+    }
+    bearerToken(value) {
+        this._bearerToken = value;
+        return this;
+    }
+    enableAuth() {
+        this._authEnabled = true;
+        return this;
+    }
+    authUrl(value) {
+        this._authUrl = value;
+        this._authEnabled = true;
+        return this;
+    }
+    authRefreshMarginSecs(value) {
+        this._authRefreshMarginSecs = value;
+        this._authEnabled = true;
+        return this;
+    }
+    fromEnv() {
+        const env = process.env;
+        if (env['4MICA_RPC_URL'])
+            this._rpcUrl = env['4MICA_RPC_URL'];
+        if (env['4MICA_WALLET_PRIVATE_KEY'])
+            this._walletPrivateKey = env['4MICA_WALLET_PRIVATE_KEY'];
+        if (env['4MICA_ETHEREUM_HTTP_RPC_URL'])
+            this._ethereumHttpRpcUrl = env['4MICA_ETHEREUM_HTTP_RPC_URL'];
+        if (env['4MICA_CONTRACT_ADDRESS'])
+            this._contractAddress = env['4MICA_CONTRACT_ADDRESS'];
+        if (env['4MICA_ADMIN_API_KEY'])
+            this._adminApiKey = env['4MICA_ADMIN_API_KEY'];
+        if (env['4MICA_BEARER_TOKEN'])
+            this._bearerToken = env['4MICA_BEARER_TOKEN'];
+        if (env['4MICA_AUTH_URL']) {
+            this._authUrl = env['4MICA_AUTH_URL'];
+            this._authEnabled = true;
+        }
+        if (env['4MICA_AUTH_REFRESH_MARGIN_SECS']) {
+            this._authRefreshMarginSecs = Number(env['4MICA_AUTH_REFRESH_MARGIN_SECS']);
+            this._authEnabled = true;
+        }
+        return this;
+    }
+    build() {
+        if (!this._signer && !this._walletPrivateKey) {
+            throw new errors_1.ConfigError('missing signer or wallet_private_key');
+        }
+        if (!this._rpcUrl) {
+            throw new errors_1.ConfigError('missing rpc_url');
+        }
+        try {
+            const rpcUrl = (0, utils_1.validateUrl)(this._rpcUrl);
+            const walletPrivateKey = this._walletPrivateKey
+                ? (0, utils_1.normalizePrivateKey)(this._walletPrivateKey)
+                : undefined;
+            const signer = this._signer ?? (0, signing_1.createLocalSigner)(walletPrivateKey);
+            const ethereumHttpRpcUrl = this._ethereumHttpRpcUrl
+                ? (0, utils_1.validateUrl)(this._ethereumHttpRpcUrl)
+                : undefined;
+            const contractAddress = this._contractAddress
+                ? (0, utils_1.normalizeAddress)(this._contractAddress)
+                : undefined;
+            const authUrl = this._authUrl ? (0, utils_1.validateUrl)(this._authUrl) : undefined;
+            const refreshMargin = this._authRefreshMarginSecs !== undefined ? this._authRefreshMarginSecs : 60;
+            if (!Number.isFinite(refreshMargin) || refreshMargin < 0) {
+                throw new utils_1.ValidationError('invalid auth refresh margin');
+            }
+            const authEnabled = this._authEnabled;
+            return {
+                rpcUrl,
+                walletPrivateKey: walletPrivateKey ?? signer.address,
+                signer,
+                ethereumHttpRpcUrl,
+                contractAddress,
+                adminApiKey: this._adminApiKey,
+                bearerToken: this._bearerToken,
+                authUrl: authEnabled ? (authUrl ?? rpcUrl) : undefined,
+                authRefreshMarginSecs: authEnabled ? refreshMargin : undefined,
+            };
+        }
+        catch (err) {
+            if (err instanceof utils_1.ValidationError) {
+                throw new errors_1.ConfigError(err.message);
+            }
+            throw err;
+        }
+    }
+}
+exports.ConfigBuilder = ConfigBuilder;

package/dist/contract.d.ts

@@ -0,0 +1,33 @@
+import { Contract, JsonRpcProvider, Wallet } from 'ethers';
+type ContractFactory = (address: string, abi: unknown, signer: Wallet) => Contract;
+export declare class ContractGateway {
+    readonly provider: JsonRpcProvider;
+    readonly wallet: Wallet;
+    readonly contract: Contract;
+    private erc20Cache;
+    constructor(ethRpcUrl: string, privateKey: string, contractAddress: string, chainId: number | bigint, provider?: JsonRpcProvider, contractFactory?: ContractFactory);
+    getChainId(): Promise<number>;
+    private erc20;
+    private send;
+    getGuaranteeDomain(): Promise<string>;
+    approveErc20(token: string, amount: number | bigint | string): Promise<unknown>;
+    deposit(amount: number | bigint | string, erc20Token?: string): Promise<unknown>;
+    getUserAssets(): Promise<{
+        asset: string;
+        collateral: bigint;
+        withdrawal_request_timestamp: bigint;
+        withdrawal_request_amount: bigint;
+    }[]>;
+    getPaymentStatus(tabId: number | bigint): Promise<{
+        paid: bigint;
+        remunerated: boolean;
+        asset: string;
+    }>;
+    payTabEth(tabId: number | bigint, reqId: number | bigint, amount: number | bigint | string, recipient: string): Promise<unknown>;
+    payTabErc20(tabId: number | bigint, amount: number | bigint | string, erc20Token: string, recipient: string): Promise<unknown>;
+    requestWithdrawal(amount: number | bigint | string, erc20Token?: string): Promise<unknown>;
+    cancelWithdrawal(erc20Token?: string): Promise<unknown>;
+    finalizeWithdrawal(erc20Token?: string): Promise<unknown>;
+    remunerate(claimsBlob: Uint8Array, signatureWords: Uint8Array[]): Promise<unknown>;
+}
+export {};

package/dist/contract.js

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractGateway = void 0;
+const ethers_1 = require("ethers");
+const core4mica_json_1 = __importDefault(require("./abi/core4mica.json"));
+const erc20_json_1 = __importDefault(require("./abi/erc20.json"));
+const errors_1 = require("./errors");
+const utils_1 = require("./utils");
+class ContractGateway {
+    constructor(ethRpcUrl, privateKey, contractAddress, chainId, provider, contractFactory) {
+        this.erc20Cache = new Map();
+        const parsedChainId = Number(chainId);
+        if (!Number.isFinite(parsedChainId)) {
+            throw new errors_1.ContractError(`invalid chain id: ${chainId}`);
+        }
+        const networkish = { chainId: parsedChainId, name: `chain-${parsedChainId}` };
+        this.provider = provider ?? new ethers_1.JsonRpcProvider(ethRpcUrl, networkish);
+        this.wallet = new ethers_1.Wallet(privateKey, this.provider);
+        const factory = contractFactory ??
+            ((addr, abi, signer) => {
+                const resolvedAbi = abi.abi ?? abi;
+                return new ethers_1.Contract(addr, resolvedAbi, signer);
+            });
+        this.contract = factory(contractAddress, core4mica_json_1.default, this.wallet);
+    }
+    async getChainId() {
+        const network = await this.provider.getNetwork();
+        return Number(network.chainId);
+    }
+    erc20(address) {
+        const checksum = address;
+        if (!this.erc20Cache.has(checksum)) {
+            this.erc20Cache.set(checksum, new ethers_1.Contract(checksum, erc20_json_1.default.abi ?? erc20_json_1.default, this.wallet));
+        }
+        return this.erc20Cache.get(checksum);
+    }
+    async send(promise) {
+        try {
+            const tx = await promise;
+            if (typeof tx.wait === 'function') {
+                return await tx.wait();
+            }
+            return tx;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            throw new errors_1.ContractError(message);
+        }
+    }
+    async getGuaranteeDomain() {
+        return this.send(this.contract.guaranteeDomainSeparator());
+    }
+    async approveErc20(token, amount) {
+        const erc20 = this.erc20(token);
+        const { target, address } = this.contract;
+        const spender = target ?? address ?? token;
+        return this.send(erc20.approve(spender, (0, utils_1.parseU256)(amount)));
+    }
+    async deposit(amount, erc20Token) {
+        if (erc20Token) {
+            return this.send(this.contract.depositStablecoin(erc20Token, (0, utils_1.parseU256)(amount)));
+        }
+        return this.send(this.contract.deposit({
+            value: (0, utils_1.parseU256)(amount),
+        }));
+    }
+    async getUserAssets() {
+        try {
+            const result = await this.contract.getUserAllAssets(this.wallet.address);
+            return result.map((asset) => ({
+                asset: asset[0],
+                collateral: (0, utils_1.parseU256)(asset[1]),
+                withdrawal_request_timestamp: (0, utils_1.parseU256)(asset[2]),
+                withdrawal_request_amount: (0, utils_1.parseU256)(asset[3]),
+            }));
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            throw new errors_1.ContractError(message);
+        }
+    }
+    async getPaymentStatus(tabId) {
+        try {
+            const [paid, remunerated, asset] = await this.contract.getPaymentStatus((0, utils_1.parseU256)(tabId));
+            return {
+                paid: (0, utils_1.parseU256)(paid),
+                remunerated: Boolean(remunerated),
+                asset,
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            throw new errors_1.ContractError(message);
+        }
+    }
+    async payTabEth(tabId, reqId, amount, recipient) {
+        const data = Buffer.from(`tab_id:${(0, ethers_1.toBeHex)((0, utils_1.parseU256)(tabId))};req_id:${(0, ethers_1.toBeHex)((0, utils_1.parseU256)(reqId))}`);
+        const tx = {
+            to: recipient,
+            value: (0, utils_1.parseU256)(amount),
+            data: (0, ethers_1.hexlify)(data),
+        };
+        return this.send(this.wallet.sendTransaction(tx));
+    }
+    async payTabErc20(tabId, amount, erc20Token, recipient) {
+        return this.send(this.contract.payTabInERC20Token((0, utils_1.parseU256)(tabId), erc20Token, (0, utils_1.parseU256)(amount), recipient));
+    }
+    async requestWithdrawal(amount, erc20Token) {
+        if (erc20Token) {
+            return this.send(this.contract['requestWithdrawal(address,uint256)'](erc20Token, (0, utils_1.parseU256)(amount)));
+        }
+        return this.send(this.contract['requestWithdrawal(uint256)']((0, utils_1.parseU256)(amount)));
+    }
+    async cancelWithdrawal(erc20Token) {
+        if (erc20Token) {
+            return this.send(this.contract['cancelWithdrawal(address)'](erc20Token));
+        }
+        return this.send(this.contract['cancelWithdrawal()']());
+    }
+    async finalizeWithdrawal(erc20Token) {
+        if (erc20Token) {
+            return this.send(this.contract['finalizeWithdrawal(address)'](erc20Token));
+        }
+        return this.send(this.contract['finalizeWithdrawal()']());
+    }
+    async remunerate(claimsBlob, signatureWords) {
+        const sigStruct = signatureWords.map((word) => (0, ethers_1.hexlify)((0, ethers_1.getBytes)(word)));
+        return this.send(this.contract.remunerate((0, ethers_1.hexlify)(claimsBlob), sigStruct));
+    }
+}
+exports.ContractGateway = ContractGateway;

package/dist/errors.d.ts

@@ -0,0 +1,43 @@
+export declare class FourMicaError extends Error {
+    constructor(message: string);
+}
+export declare class ConfigError extends FourMicaError {
+}
+export declare class RpcError extends FourMicaError {
+    readonly status?: number;
+    readonly body?: unknown;
+    constructor(message: string, options?: {
+        status?: number;
+        body?: unknown;
+    });
+}
+export declare class ClientInitializationError extends FourMicaError {
+}
+export declare class SigningError extends FourMicaError {
+}
+export declare class ContractError extends FourMicaError {
+}
+export declare class VerificationError extends FourMicaError {
+}
+export declare class X402Error extends FourMicaError {
+}
+export declare class AuthError extends FourMicaError {
+}
+export declare class AuthUrlError extends AuthError {
+}
+export declare class AuthTransportError extends AuthError {
+}
+export declare class AuthDecodeError extends AuthError {
+}
+export declare class AuthApiError extends AuthError {
+    readonly status?: number;
+    readonly body?: unknown;
+    constructor(message: string, options?: {
+        status?: number;
+        body?: unknown;
+    });
+}
+export declare class AuthConfigError extends AuthError {
+}
+export declare class AuthMissingConfigError extends AuthConfigError {
+}

package/dist/errors.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthMissingConfigError = exports.AuthConfigError = exports.AuthApiError = exports.AuthDecodeError = exports.AuthTransportError = exports.AuthUrlError = exports.AuthError = exports.X402Error = exports.VerificationError = exports.ContractError = exports.SigningError = exports.ClientInitializationError = exports.RpcError = exports.ConfigError = exports.FourMicaError = void 0;
+class FourMicaError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+    }
+}
+exports.FourMicaError = FourMicaError;
+class ConfigError extends FourMicaError {
+}
+exports.ConfigError = ConfigError;
+class RpcError extends FourMicaError {
+    constructor(message, options) {
+        super(message);
+        this.status = options?.status;
+        this.body = options?.body;
+    }
+}
+exports.RpcError = RpcError;
+class ClientInitializationError extends FourMicaError {
+}
+exports.ClientInitializationError = ClientInitializationError;
+class SigningError extends FourMicaError {
+}
+exports.SigningError = SigningError;
+class ContractError extends FourMicaError {
+}
+exports.ContractError = ContractError;
+class VerificationError extends FourMicaError {
+}
+exports.VerificationError = VerificationError;
+class X402Error extends FourMicaError {
+}
+exports.X402Error = X402Error;
+class AuthError extends FourMicaError {
+}
+exports.AuthError = AuthError;
+class AuthUrlError extends AuthError {
+}
+exports.AuthUrlError = AuthUrlError;
+class AuthTransportError extends AuthError {
+}
+exports.AuthTransportError = AuthTransportError;
+class AuthDecodeError extends AuthError {
+}
+exports.AuthDecodeError = AuthDecodeError;
+class AuthApiError extends AuthError {
+    constructor(message, options) {
+        super(message);
+        this.status = options?.status;
+        this.body = options?.body;
+    }
+}
+exports.AuthApiError = AuthApiError;
+class AuthConfigError extends AuthError {
+}
+exports.AuthConfigError = AuthConfigError;
+class AuthMissingConfigError extends AuthConfigError {
+}
+exports.AuthMissingConfigError = AuthMissingConfigError;

package/dist/guarantee.d.ts

@@ -0,0 +1,3 @@
+import { PaymentGuaranteeClaims } from './models';
+export declare function encodeGuaranteeClaims(claims: PaymentGuaranteeClaims): string;
+export declare function decodeGuaranteeClaims(data: string | Uint8Array): PaymentGuaranteeClaims;