@4mica/sdk 1.0.0 → 1.0.2

package/dist/src/abi/erc20.json

@@ -1,187 +0,0 @@
-{
-    "abi": [
-        {
-            "type": "function",
-            "name": "allowance",
-            "inputs": [
-                {
-                    "name": "owner",
-                    "type": "address",
-                    "internalType": "address"
-                },
-                {
-                    "name": "spender",
-                    "type": "address",
-                    "internalType": "address"
-                }
-            ],
-            "outputs": [
-                {
-                    "name": "",
-                    "type": "uint256",
-                    "internalType": "uint256"
-                }
-            ],
-            "stateMutability": "view"
-        },
-        {
-            "type": "function",
-            "name": "approve",
-            "inputs": [
-                {
-                    "name": "spender",
-                    "type": "address",
-                    "internalType": "address"
-                },
-                {
-                    "name": "value",
-                    "type": "uint256",
-                    "internalType": "uint256"
-                }
-            ],
-            "outputs": [
-                {
-                    "name": "",
-                    "type": "bool",
-                    "internalType": "bool"
-                }
-            ],
-            "stateMutability": "nonpayable"
-        },
-        {
-            "type": "function",
-            "name": "balanceOf",
-            "inputs": [
-                {
-                    "name": "account",
-                    "type": "address",
-                    "internalType": "address"
-                }
-            ],
-            "outputs": [
-                {
-                    "name": "",
-                    "type": "uint256",
-                    "internalType": "uint256"
-                }
-            ],
-            "stateMutability": "view"
-        },
-        {
-            "type": "function",
-            "name": "totalSupply",
-            "inputs": [],
-            "outputs": [
-                {
-                    "name": "",
-                    "type": "uint256",
-                    "internalType": "uint256"
-                }
-            ],
-            "stateMutability": "view"
-        },
-        {
-            "type": "function",
-            "name": "transfer",
-            "inputs": [
-                {
-                    "name": "to",
-                    "type": "address",
-                    "internalType": "address"
-                },
-                {
-                    "name": "value",
-                    "type": "uint256",
-                    "internalType": "uint256"
-                }
-            ],
-            "outputs": [
-                {
-                    "name": "",
-                    "type": "bool",
-                    "internalType": "bool"
-                }
-            ],
-            "stateMutability": "nonpayable"
-        },
-        {
-            "type": "function",
-            "name": "transferFrom",
-            "inputs": [
-                {
-                    "name": "from",
-                    "type": "address",
-                    "internalType": "address"
-                },
-                {
-                    "name": "to",
-                    "type": "address",
-                    "internalType": "address"
-                },
-                {
-                    "name": "value",
-                    "type": "uint256",
-                    "internalType": "uint256"
-                }
-            ],
-            "outputs": [
-                {
-                    "name": "",
-                    "type": "bool",
-                    "internalType": "bool"
-                }
-            ],
-            "stateMutability": "nonpayable"
-        },
-        {
-            "type": "event",
-            "name": "Approval",
-            "inputs": [
-                {
-                    "name": "owner",
-                    "type": "address",
-                    "indexed": true,
-                    "internalType": "address"
-                },
-                {
-                    "name": "spender",
-                    "type": "address",
-                    "indexed": true,
-                    "internalType": "address"
-                },
-                {
-                    "name": "value",
-                    "type": "uint256",
-                    "indexed": false,
-                    "internalType": "uint256"
-                }
-            ],
-            "anonymous": false
-        },
-        {
-            "type": "event",
-            "name": "Transfer",
-            "inputs": [
-                {
-                    "name": "from",
-                    "type": "address",
-                    "indexed": true,
-                    "internalType": "address"
-                },
-                {
-                    "name": "to",
-                    "type": "address",
-                    "indexed": true,
-                    "internalType": "address"
-                },
-                {
-                    "name": "value",
-                    "type": "uint256",
-                    "indexed": false,
-                    "internalType": "uint256"
-                }
-            ],
-            "anonymous": false
-        }
-    ]
-}

package/dist/src/bls.d.ts

@@ -1,5 +0,0 @@
-/**
- * Expand a compressed G2 signature into the tuple expected by the contract.
- * This mirrors the Python helper and requires the optional `@noble/curves` dependency.
- */
-export declare function signatureToWords(signatureHex: string): Uint8Array[];

package/dist/src/bls.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.signatureToWords = signatureToWords;
-const ethers_1 = require("ethers");
-const errors_1 = require("./errors");
-function splitFp(value) {
-    const be48 = value.toString(16).padStart(96, '0');
-    const bytes = (0, ethers_1.getBytes)(`0x${be48}`);
-    const hi = new Uint8Array(32);
-    hi.set(bytes.slice(0, 16), 16);
-    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;
-    try {
-        // Lazy require to keep the dependency optional.
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        curves = require('@noble/curves/bls12-381');
-    }
-    catch (err) {
-        throw new errors_1.VerificationError('BLS decoding requires @noble/curves; install it to enable remuneration');
-    }
-    try {
-        const sigBytes = (0, ethers_1.getBytes)(signatureHex);
-        const point = curves.bls12_381.G2.ProjectivePoint.fromHex(sigBytes);
-        const affine = point.toAffine();
-        const [x0, x1] = affine.x.c;
-        const [y0, y1] = affine.y.c;
-        const coords = [x0, x1, y0, y1].map((fp) => BigInt(fp.value ?? fp));
-        const words = [];
-        coords.forEach((coord) => {
-            const [hi, lo] = splitFp(coord);
-            words.push(hi, lo);
-        });
-        return words;
-    }
-    catch (err) {
-        throw new errors_1.VerificationError(`invalid BLS signature: ${err?.message ?? String(err)}`);
-    }
-}

package/dist/src/client.d.ts

@@ -1,55 +0,0 @@
-import { Config } from './config';
-import { ContractGateway } from './contract';
-import { AssetBalanceInfo, BLSCert, CollateralEventInfo, GuaranteeInfo, PaymentGuaranteeClaims, PaymentGuaranteeRequestClaims, PaymentSignature, PendingRemunerationInfo, RecipientPaymentInfo, SigningScheme, TabInfo, TabPaymentStatus, UserInfo } from './models';
-import { RpcProxy } from './rpc';
-import { CorePublicParameters, PaymentSigner } from './signing';
-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 constructor();
-    static new(cfg: Config): Promise<Client>;
-    private static buildGateway;
-    private static validateChainId;
-    aclose(): Promise<void>;
-}
-export declare class UserClient {
-    private client;
-    constructor(client: Client);
-    get guaranteeDomain(): string;
-    approveErc20(token: string, amount: number | bigint | string): Promise<any>;
-    deposit(amount: number | bigint | string, erc20Token?: string): Promise<any>;
-    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): Promise<any>;
-    requestWithdrawal(amount: number | bigint | string, erc20Token?: string): Promise<any>;
-    cancelWithdrawal(erc20Token?: string): Promise<any>;
-    finalizeWithdrawal(erc20Token?: string): Promise<any>;
-}
-export declare class RecipientClient {
-    private client;
-    constructor(client: Client);
-    private get recipientAddress();
-    get guaranteeDomain(): string;
-    private checkSigner;
-    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): Promise<any>;
-    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>;
-}

package/dist/src/client.js

@@ -1,214 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RecipientClient = exports.UserClient = exports.Client = void 0;
-const bls_1 = require("./bls");
-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");
-function tabStatusFromRpc(status) {
-    const paid = status.paid !== undefined ? status.paid : (status.paidAmount ?? 0);
-    const remunerated = status.remunerated !== undefined ? 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(cfg, rpc, params, gateway, guaranteeDomain, signer) {
-        this.rpc = rpc;
-        this.params = params;
-        this.gateway = gateway;
-        this.guaranteeDomain = guaranteeDomain;
-        this.signer = signer;
-        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.walletPrivateKey);
-        return new Client(cfg, rpc, params, gateway, guaranteeDomain, signer);
-    }
-    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) {
-            throw new errors_1.ClientInitializationError(err?.message ?? String(err));
-        }
-    }
-    async aclose() {
-        await this.rpc.aclose();
-    }
-}
-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);
-        return (0, utils_1.parseU256)(result.id ?? result.tabId ?? result.tab_id);
-    }
-    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),
-                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);
-        return { claims: cert.claims, signature: cert.signature };
-    }
-    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/src/config.d.ts

@@ -1,21 +0,0 @@
-export interface Config {
-    rpcUrl: string;
-    walletPrivateKey: string;
-    ethereumHttpRpcUrl?: string;
-    contractAddress?: string;
-    adminApiKey?: string;
-}
-export declare class ConfigBuilder {
-    private _rpcUrl;
-    private _walletPrivateKey;
-    private _ethereumHttpRpcUrl?;
-    private _contractAddress?;
-    private _adminApiKey?;
-    rpcUrl(value: string): ConfigBuilder;
-    walletPrivateKey(value: string): ConfigBuilder;
-    ethereumHttpRpcUrl(value: string): ConfigBuilder;
-    contractAddress(value: string): ConfigBuilder;
-    adminApiKey(value: string): ConfigBuilder;
-    fromEnv(): ConfigBuilder;
-    build(): Config;
-}

package/dist/src/config.js

@@ -1,76 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfigBuilder = void 0;
-const errors_1 = require("./errors");
-const utils_1 = require("./utils");
-class ConfigBuilder {
-    constructor() {
-        this._rpcUrl = 'https://api.4mica.xyz/';
-    }
-    rpcUrl(value) {
-        this._rpcUrl = value;
-        return this;
-    }
-    walletPrivateKey(value) {
-        this._walletPrivateKey = value;
-        return this;
-    }
-    ethereumHttpRpcUrl(value) {
-        this._ethereumHttpRpcUrl = value;
-        return this;
-    }
-    contractAddress(value) {
-        this._contractAddress = value;
-        return this;
-    }
-    adminApiKey(value) {
-        this._adminApiKey = value;
-        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'];
-        return this;
-    }
-    build() {
-        if (!this._walletPrivateKey) {
-            throw new errors_1.ConfigError('missing 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 = (0, utils_1.normalizePrivateKey)(this._walletPrivateKey);
-            const ethereumHttpRpcUrl = this._ethereumHttpRpcUrl
-                ? (0, utils_1.validateUrl)(this._ethereumHttpRpcUrl)
-                : undefined;
-            const contractAddress = this._contractAddress
-                ? (0, utils_1.normalizeAddress)(this._contractAddress)
-                : undefined;
-            return {
-                rpcUrl,
-                walletPrivateKey,
-                ethereumHttpRpcUrl,
-                contractAddress,
-                adminApiKey: this._adminApiKey,
-            };
-        }
-        catch (err) {
-            if (err instanceof utils_1.ValidationError) {
-                throw new errors_1.ConfigError(err.message);
-            }
-            throw err;
-        }
-    }
-}
-exports.ConfigBuilder = ConfigBuilder;

package/dist/src/contract.d.ts

@@ -1,33 +0,0 @@
-import { Contract, JsonRpcProvider, Wallet } from 'ethers';
-type ContractFactory = (address: string, abi: any, 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<any>;
-    deposit(amount: number | bigint | string, erc20Token?: string): Promise<any>;
-    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<any>;
-    payTabErc20(tabId: number | bigint, amount: number | bigint | string, erc20Token: string, recipient: string): Promise<any>;
-    requestWithdrawal(amount: number | bigint | string, erc20Token?: string): Promise<any>;
-    cancelWithdrawal(erc20Token?: string): Promise<any>;
-    finalizeWithdrawal(erc20Token?: string): Promise<any>;
-    remunerate(claimsBlob: Uint8Array, signatureWords: Uint8Array[]): Promise<any>;
-}
-export {};