@4mica/sdk 0.5.2 → 0.5.3

package/dist/abi/erc20.d.ts

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

package/dist/abi/erc20.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.erc20Abi = void 0;
+exports.erc20Abi = [
+    {
+        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/auth.d.ts

@@ -1,5 +1,5 @@
+import { Account } from 'viem';
 import type { FetchFn } from './rpc';
-import { EvmSigner } from './signing';
 export type AuthTokens = {
     accessToken: string;
     refreshToken: string;
@@ -47,7 +47,7 @@ export declare class AuthSession {
     private loginPromise?;
     constructor(options: {
         authUrl: string;
-        signer: EvmSigner;
+        signer: Account;
         refreshMarginSecs?: number;
         fetchFn?: FetchFn;
     });

package/dist/auth.js

@@ -53,6 +53,8 @@ function buildSiweMessage(input) {
     return `${input.domain} wants you to sign in with your Ethereum account:\n${input.address}\n\n${input.statement}\n\nURI: ${input.uri}\nVersion: 1\nChain ID: ${chainId}\nNonce: ${input.nonce}\nIssued At: ${input.issuedAt}\nExpiration Time: ${input.expiration}`;
 }
 class AuthClient {
+    baseUrl;
+    fetchFn;
     constructor(endpoint, fetchFn = fetch) {
         try {
             const validated = (0, utils_1.validateUrl)(endpoint);
@@ -147,6 +149,12 @@ class AuthClient {
 }
 exports.AuthClient = AuthClient;
 class AuthSession {
+    authClient;
+    signer;
+    refreshMarginSecs;
+    tokens;
+    inFlight;
+    loginPromise;
     constructor(options) {
         if (!options.authUrl) {
             throw new errors_1.AuthMissingConfigError('missing auth_url');
@@ -223,6 +231,9 @@ class AuthSession {
             issuedAt: nonce.siwe.issuedAt,
             expiration: nonce.siwe.expiration,
         });
+        if (!this.signer.signMessage) {
+            throw new errors_1.SigningError('signMessage is not supported for this account');
+        }
         const signature = await this.signer.signMessage({ message });
         const tokens = await this.authClient.verify(address, message, signature);
         this.cacheTokens(tokens);

package/dist/bls.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.signatureToWords = signatureToWords;
-const ethers_1 = require("ethers");
+const viem_1 = require("viem");
 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 bytes = (0, viem_1.toBytes)(`0x${be48}`);
     const hi = new Uint8Array(32);
     hi.set(bytes.slice(0, 16), 16);
     const lo = bytes.slice(16);
@@ -38,7 +38,7 @@ function signatureToWords(signatureHex) {
         throw new errors_1.VerificationError('invalid BLS field element');
     };
     try {
-        const sigBytes = (0, ethers_1.getBytes)(signatureHex);
+        const sigBytes = (0, viem_1.toBytes)(signatureHex);
         const point = curves.bls12_381.G2.ProjectivePoint.fromHex(sigBytes);
         const affine = point.toAffine();
         const [x0, x1] = affine.x.c;

package/dist/client.d.ts

@@ -16,7 +16,6 @@ export declare class Client {
     private constructor();
     static new(cfg: Config): Promise<Client>;
     private static buildGateway;
-    private static validateChainId;
     aclose(): Promise<void>;
     login(): Promise<AuthTokens>;
 }
@@ -24,27 +23,26 @@ export declare class UserClient {
     private client;
     constructor(client: Client);
     get guaranteeDomain(): string;
-    approveErc20(token: string, amount: number | bigint | string): Promise<unknown>;
-    deposit(amount: number | bigint | string, erc20Token?: string): Promise<unknown>;
+    approveErc20(token: string, amount: number | bigint | string): Promise<import("viem").TransactionReceipt>;
+    deposit(amount: number | bigint | string, erc20Token?: string): Promise<import("viem").TransactionReceipt>;
     getUser(): Promise<UserInfo[]>;
     getTabPaymentStatus(tabId: number | bigint): Promise<TabPaymentStatus>;
     signPayment(claims: PaymentGuaranteeRequestClaims, scheme?: SigningScheme): Promise<PaymentSignature>;
-    payTab(tabId: number | bigint, reqId: number | bigint, amount: number | bigint | string, recipientAddress: string, erc20Token?: string): Promise<unknown>;
-    requestWithdrawal(amount: number | bigint | string, erc20Token?: string): Promise<unknown>;
-    cancelWithdrawal(erc20Token?: string): Promise<unknown>;
-    finalizeWithdrawal(erc20Token?: string): Promise<unknown>;
+    payTab(tabId: number | bigint, reqId: number | bigint, amount: number | bigint | string, recipientAddress: string, erc20Token?: string): Promise<import("viem").TransactionReceipt>;
+    requestWithdrawal(amount: number | bigint | string, erc20Token?: string): Promise<import("viem").TransactionReceipt>;
+    cancelWithdrawal(erc20Token?: string): Promise<import("viem").TransactionReceipt>;
+    finalizeWithdrawal(erc20Token?: string): Promise<import("viem").TransactionReceipt>;
 }
 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<unknown>;
+    remunerate(cert: BLSCert): Promise<import("viem").TransactionReceipt>;
     listSettledTabs(): Promise<TabInfo[]>;
     listPendingRemunerations(): Promise<PendingRemunerationInfo[]>;
     getTab(tabId: number | bigint): Promise<TabInfo | null>;

package/dist/client.js

@@ -22,6 +22,14 @@ function tabStatusFromRpc(status) {
     };
 }
 class Client {
+    rpc;
+    params;
+    gateway;
+    guaranteeDomain;
+    user;
+    recipient;
+    signer;
+    authSession;
     constructor(rpc, params, gateway, guaranteeDomain, signer, authSession) {
         this.rpc = rpc;
         this.params = params;
@@ -35,8 +43,7 @@ class Client {
     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 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;
@@ -55,22 +62,10 @@ class Client {
         }
         return new Client(rpc, params, gateway, guaranteeDomain, signer, authSession);
     }
-    static buildGateway(cfg, params) {
+    static async 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);
-        }
+        return contract_1.ContractGateway.create(ethRpcUrl, cfg.signer, contractAddress, params.chainId);
     }
     async aclose() {
         await this.rpc.aclose();
@@ -84,6 +79,7 @@ class Client {
 }
 exports.Client = Client;
 class UserClient {
+    client;
     constructor(client) {
         this.client = client;
     }
@@ -101,8 +97,8 @@ class UserClient {
         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),
+            withdrawalRequestAmount: (0, utils_1.parseU256)(a.withdrawalRequestAmount),
+            withdrawalRequestTimestamp: Number(a.withdrawalRequestTimestamp),
         }));
     }
     async getTabPaymentStatus(tabId) {
@@ -130,22 +126,17 @@ class UserClient {
 }
 exports.UserClient = UserClient;
 class RecipientClient {
+    client;
     constructor(client) {
         this.client = client;
     }
     get recipientAddress() {
-        return (0, utils_1.normalizeAddress)(this.client.gateway.wallet.address);
+        return (0, utils_1.normalizeAddress)(this.client.signer.signer.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),
@@ -163,7 +154,6 @@ class RecipientClient {
         return tabStatusFromRpc(status);
     }
     async issuePaymentGuarantee(claims, signature, scheme) {
-        this.checkSigner(claims.recipientAddress);
         const payload = {
             claims: {
                 version: 'v1',

package/dist/config.d.ts

@@ -1,8 +1,7 @@
-import { EvmSigner } from './signing';
+import { Account } from 'viem/accounts';
 export interface Config {
     rpcUrl: string;
-    walletPrivateKey: string;
-    signer: EvmSigner;
+    signer: Account;
     ethereumHttpRpcUrl?: string;
     contractAddress?: string;
     adminApiKey?: string;
@@ -23,7 +22,7 @@ export declare class ConfigBuilder {
     private _authRefreshMarginSecs?;
     rpcUrl(value: string): ConfigBuilder;
     walletPrivateKey(value: string): ConfigBuilder;
-    signer(value: EvmSigner): ConfigBuilder;
+    signer(value: Account): ConfigBuilder;
     ethereumHttpRpcUrl(value: string): ConfigBuilder;
     contractAddress(value: string): ConfigBuilder;
     adminApiKey(value: string): ConfigBuilder;

package/dist/config.js

@@ -1,14 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConfigBuilder = void 0;
+const accounts_1 = require("viem/accounts");
 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 = 'https://api.4mica.xyz/';
+    _walletPrivateKey;
+    _signer;
+    _ethereumHttpRpcUrl;
+    _contractAddress;
+    _adminApiKey;
+    _bearerToken;
+    _authEnabled = false;
+    _authUrl;
+    _authRefreshMarginSecs;
     rpcUrl(value) {
         this._rpcUrl = value;
         return this;
@@ -87,7 +93,7 @@ class ConfigBuilder {
             const walletPrivateKey = this._walletPrivateKey
                 ? (0, utils_1.normalizePrivateKey)(this._walletPrivateKey)
                 : undefined;
-            const signer = this._signer ?? (0, signing_1.createLocalSigner)(walletPrivateKey);
+            const signer = this._signer ?? (0, accounts_1.privateKeyToAccount)(walletPrivateKey);
             const ethereumHttpRpcUrl = this._ethereumHttpRpcUrl
                 ? (0, utils_1.validateUrl)(this._ethereumHttpRpcUrl)
                 : undefined;
@@ -102,7 +108,6 @@ class ConfigBuilder {
             const authEnabled = this._authEnabled;
             return {
                 rpcUrl,
-                walletPrivateKey: walletPrivateKey ?? signer.address,
                 signer,
                 ethereumHttpRpcUrl,
                 contractAddress,

package/dist/contract.d.ts

@@ -1,33 +1,38 @@
-import { Contract, JsonRpcProvider, Wallet } from 'ethers';
-type ContractFactory = (address: string, abi: unknown, signer: Wallet) => Contract;
+import { createPublicClient, createWalletClient, type Hex, type Chain, Account, GetContractReturnType, HttpTransport } from 'viem';
+import { core4micaAbi } from './abi/core4mica';
+type TPublicClient = ReturnType<typeof createPublicClient>;
+type TWalletClient = ReturnType<typeof createWalletClient<HttpTransport, Chain, Account>>;
+type CoreContract = GetContractReturnType<typeof core4micaAbi, {
+    public: ReturnType<typeof createPublicClient>;
+    wallet: TWalletClient;
+}>;
 export declare class ContractGateway {
-    readonly provider: JsonRpcProvider;
-    readonly wallet: Wallet;
-    readonly contract: Contract;
+    readonly publicClient: TPublicClient;
+    readonly walletClient: TWalletClient;
+    readonly contract: CoreContract;
     private erc20Cache;
-    constructor(ethRpcUrl: string, privateKey: string, contractAddress: string, chainId: number | bigint, provider?: JsonRpcProvider, contractFactory?: ContractFactory);
-    getChainId(): Promise<number>;
+    private constructor();
+    static create(rpcUrl: string, signer: Account, contractAddress: Hex, chainId: number): Promise<ContractGateway>;
     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>;
+    approveErc20(token: string, amount: number | bigint | string): Promise<import("viem").TransactionReceipt>;
+    deposit(amount: number | bigint | string, erc20Token?: string): Promise<import("viem").TransactionReceipt>;
     getUserAssets(): Promise<{
-        asset: string;
+        asset: `0x${string}`;
         collateral: bigint;
-        withdrawal_request_timestamp: bigint;
-        withdrawal_request_amount: bigint;
+        withdrawalRequestTimestamp: bigint;
+        withdrawalRequestAmount: bigint;
     }[]>;
     getPaymentStatus(tabId: number | bigint): Promise<{
         paid: bigint;
         remunerated: boolean;
-        asset: string;
+        asset: Hex;
     }>;
-    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>;
+    payTabEth(tabId: number | bigint, reqId: number | bigint, amount: number | bigint | string, recipient: string): Promise<import("viem").TransactionReceipt>;
+    payTabErc20(tabId: number | bigint, amount: number | bigint | string, erc20Token: string, recipient: string): Promise<import("viem").TransactionReceipt>;
+    requestWithdrawal(amount: number | bigint | string, erc20Token?: string): Promise<import("viem").TransactionReceipt>;
+    cancelWithdrawal(erc20Token?: string): Promise<import("viem").TransactionReceipt>;
+    finalizeWithdrawal(erc20Token?: string): Promise<import("viem").TransactionReceipt>;
+    remunerate(claimsBlob: Uint8Array, signatureWords: Uint8Array[]): Promise<import("viem").TransactionReceipt>;
 }
 export {};