@4mica/sdk 0.5.2 → 0.5.3

package/dist/contract.js

@@ -1,134 +1,178 @@
 "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 viem_1 = require("viem");
+const chains_1 = require("viem/chains");
+const core4mica_1 = require("./abi/core4mica");
 const utils_1 = require("./utils");
+const CHAINS = {
+    1: chains_1.mainnet,
+    11155111: chains_1.sepolia,
+    8453: chains_1.base,
+    84532: chains_1.baseSepolia,
+    137: chains_1.polygon,
+    80002: chains_1.polygonAmoy,
+};
+function getChain(chainId, rpcUrl) {
+    const chain = CHAINS[chainId];
+    if (chain)
+        return chain;
+    return {
+        id: chainId,
+        name: `local-${chainId}`,
+        nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
+        rpcUrls: {
+            default: { http: [rpcUrl] },
+            public: { http: [rpcUrl] },
+        },
+    };
+}
 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);
+    publicClient;
+    walletClient;
+    contract;
+    erc20Cache = new Map();
+    constructor(publicClient, walletClient, contract) {
+        this.publicClient = publicClient;
+        this.walletClient = walletClient;
+        this.contract = contract;
     }
-    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));
+    static async create(rpcUrl, signer, contractAddress, chainId) {
+        const chain = getChain(chainId, rpcUrl);
+        const publicClient = (0, viem_1.createPublicClient)({
+            transport: (0, viem_1.http)(rpcUrl),
+        });
+        const rpcChainId = await publicClient.getChainId();
+        if (rpcChainId !== Number(chainId)) {
+            throw new Error(`Connected to chain ${rpcChainId}, expected ${chainId}`);
         }
-        return this.erc20Cache.get(checksum);
+        const walletClient = (0, viem_1.createWalletClient)({
+            transport: (0, viem_1.http)(rpcUrl),
+            account: signer,
+            chain,
+        });
+        const contract = (0, viem_1.getContract)({
+            address: contractAddress,
+            abi: core4mica_1.core4micaAbi,
+            client: {
+                public: publicClient,
+                wallet: walletClient,
+            },
+        });
+        return new ContractGateway(publicClient, walletClient, contract);
     }
-    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);
+    erc20(token) {
+        if (!this.erc20Cache.has(token)) {
+            this.erc20Cache.set(token, (0, viem_1.getContract)({
+                address: token,
+                abi: viem_1.erc20Abi,
+                client: { public: this.publicClient, wallet: this.walletClient },
+            }));
         }
+        return this.erc20Cache.get(token);
     }
     async getGuaranteeDomain() {
-        return this.send(this.contract.guaranteeDomainSeparator());
+        return this.contract.read.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)));
+        // spender address logic
+        const spender = this.contract.address;
+        const hash = await erc20.write.approve([spender, (0, utils_1.parseU256)(amount)]);
+        return this.publicClient.waitForTransactionReceipt({ hash });
     }
     async deposit(amount, erc20Token) {
+        let hash;
         if (erc20Token) {
-            return this.send(this.contract.depositStablecoin(erc20Token, (0, utils_1.parseU256)(amount)));
+            hash = await this.contract.write.depositStablecoin([erc20Token, (0, utils_1.parseU256)(amount)]);
         }
-        return this.send(this.contract.deposit({
-            value: (0, utils_1.parseU256)(amount),
-        }));
+        else {
+            hash = await this.contract.write.deposit({ value: (0, utils_1.parseU256)(amount) });
+        }
+        return this.publicClient.waitForTransactionReceipt({ hash });
     }
     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);
-        }
+        const addr = this.walletClient.account.address;
+        const result = await this.contract.read.getUserAllAssets([addr]);
+        return result.map((a) => ({
+            asset: a.asset,
+            collateral: a.collateral,
+            withdrawalRequestTimestamp: a.withdrawalRequestTimestamp,
+            withdrawalRequestAmount: a.withdrawalRequestAmount,
+        }));
     }
     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);
-        }
+        const [paid, remunerated, asset] = await this.contract.read.getPaymentStatus([
+            (0, utils_1.parseU256)(tabId),
+        ]);
+        return {
+            paid,
+            remunerated,
+            asset,
+        };
     }
     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 = {
+        const data = new TextEncoder().encode(`tab_id:${tabId.toString(16)};req_id:${reqId.toString(16)}`);
+        const hash = await this.walletClient.sendTransaction({
             to: recipient,
             value: (0, utils_1.parseU256)(amount),
-            data: (0, ethers_1.hexlify)(data),
-        };
-        return this.send(this.wallet.sendTransaction(tx));
+            data: (0, utils_1.hexFromBytes)(data),
+        });
+        return this.publicClient.waitForTransactionReceipt({ hash });
     }
     async payTabErc20(tabId, amount, erc20Token, recipient) {
-        return this.send(this.contract.payTabInERC20Token((0, utils_1.parseU256)(tabId), erc20Token, (0, utils_1.parseU256)(amount), recipient));
+        const hash = await this.contract.write.payTabInERC20Token([
+            (0, utils_1.parseU256)(tabId),
+            erc20Token,
+            (0, utils_1.parseU256)(amount),
+            recipient,
+        ]);
+        return this.publicClient.waitForTransactionReceipt({ hash });
     }
     async requestWithdrawal(amount, erc20Token) {
+        const value = (0, utils_1.parseU256)(amount);
+        let hash;
         if (erc20Token) {
-            return this.send(this.contract['requestWithdrawal(address,uint256)'](erc20Token, (0, utils_1.parseU256)(amount)));
+            hash = await this.contract.write.requestWithdrawal([erc20Token, value]);
+        }
+        else {
+            hash = await this.contract.write.requestWithdrawal([value]);
         }
-        return this.send(this.contract['requestWithdrawal(uint256)']((0, utils_1.parseU256)(amount)));
+        return this.publicClient.waitForTransactionReceipt({ hash });
     }
     async cancelWithdrawal(erc20Token) {
+        let hash;
         if (erc20Token) {
-            return this.send(this.contract['cancelWithdrawal(address)'](erc20Token));
+            hash = await this.contract.write.cancelWithdrawal([erc20Token]);
+        }
+        else {
+            hash = await this.contract.write.cancelWithdrawal();
         }
-        return this.send(this.contract['cancelWithdrawal()']());
+        return this.publicClient.waitForTransactionReceipt({ hash });
     }
     async finalizeWithdrawal(erc20Token) {
+        let hash;
         if (erc20Token) {
-            return this.send(this.contract['finalizeWithdrawal(address)'](erc20Token));
+            hash = await this.contract.write.finalizeWithdrawal([erc20Token]);
         }
-        return this.send(this.contract['finalizeWithdrawal()']());
+        else {
+            hash = await this.contract.write.finalizeWithdrawal();
+        }
+        return this.publicClient.waitForTransactionReceipt({ hash });
     }
     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));
+        const sigStruct = {
+            x_c0_a: (0, utils_1.hexFromBytes)(signatureWords[0]),
+            x_c0_b: (0, utils_1.hexFromBytes)(signatureWords[1]),
+            x_c1_a: (0, utils_1.hexFromBytes)(signatureWords[2]),
+            x_c1_b: (0, utils_1.hexFromBytes)(signatureWords[3]),
+            y_c0_a: (0, utils_1.hexFromBytes)(signatureWords[4]),
+            y_c0_b: (0, utils_1.hexFromBytes)(signatureWords[5]),
+            y_c1_a: (0, utils_1.hexFromBytes)(signatureWords[6]),
+            y_c1_b: (0, utils_1.hexFromBytes)(signatureWords[7]),
+        };
+        const hash = await this.contract.write.remunerate([(0, utils_1.hexFromBytes)(claimsBlob), sigStruct]);
+        return this.publicClient.waitForTransactionReceipt({ hash });
     }
 }
 exports.ContractGateway = ContractGateway;

package/dist/errors.js

@@ -12,6 +12,8 @@ class ConfigError extends FourMicaError {
 }
 exports.ConfigError = ConfigError;
 class RpcError extends FourMicaError {
+    status;
+    body;
     constructor(message, options) {
         super(message);
         this.status = options?.status;
@@ -47,6 +49,8 @@ class AuthDecodeError extends AuthError {
 }
 exports.AuthDecodeError = AuthDecodeError;
 class AuthApiError extends AuthError {
+    status;
+    body;
     constructor(message, options) {
         super(message);
         this.status = options?.status;

package/dist/guarantee.js

@@ -2,24 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.encodeGuaranteeClaims = encodeGuaranteeClaims;
 exports.decodeGuaranteeClaims = decodeGuaranteeClaims;
-const ethers_1 = require("ethers");
+const viem_1 = require("viem");
 const errors_1 = require("./errors");
 const utils_1 = require("./utils");
 const CLAIM_TYPES = [
-    'bytes32',
-    'uint256',
-    'uint256',
-    'address',
-    'address',
-    'uint256',
-    'uint256',
-    'address',
-    'uint64',
-    'uint64',
+    { type: 'bytes32' },
+    { type: 'uint256' },
+    { type: 'uint256' },
+    { type: 'address' },
+    { type: 'address' },
+    { type: 'uint256' },
+    { type: 'uint256' },
+    { type: 'address' },
+    { type: 'uint64' },
+    { type: 'uint64' },
 ];
-const coder = ethers_1.AbiCoder.defaultAbiCoder();
 function ensureDomainBytes(domain) {
-    const bytes = typeof domain === 'string' ? (0, ethers_1.getBytes)(domain) : domain;
+    const bytes = typeof domain === 'string' ? (0, viem_1.toBytes)(domain) : domain;
     if (bytes.length !== 32) {
         throw new errors_1.VerificationError('domain separator must be 32 bytes');
     }
@@ -30,8 +29,8 @@ function encodeGuaranteeClaims(claims) {
         throw new errors_1.VerificationError(`unsupported guarantee claims version: ${claims.version}`);
     }
     const domain = ensureDomainBytes(claims.domain);
-    const encoded = coder.encode(CLAIM_TYPES, [
-        domain,
+    const encoded = (0, viem_1.encodeAbiParameters)(CLAIM_TYPES, [
+        (0, utils_1.hexFromBytes)(domain),
         (0, utils_1.parseU256)(claims.tabId),
         (0, utils_1.parseU256)(claims.reqId),
         claims.userAddress,
@@ -42,17 +41,17 @@ function encodeGuaranteeClaims(claims) {
         BigInt(claims.timestamp),
         BigInt(claims.version),
     ]);
-    return coder.encode(['uint64', 'bytes'], [BigInt(claims.version), encoded]);
+    return (0, viem_1.encodeAbiParameters)([{ type: 'uint64' }, { type: '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);
+    const rawBytes = typeof data === 'string' ? (0, viem_1.toBytes)(data) : data;
+    const [version, encoded] = (0, viem_1.decodeAbiParameters)([{ type: 'uint64' }, { type: '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);
+    const [domain, tabId, reqId, user, recipient, amount, totalAmount, asset, timestamp, claimsVersion,] = (0, viem_1.decodeAbiParameters)(CLAIM_TYPES, encoded);
     return {
-        domain: (0, ethers_1.getBytes)(domain),
+        domain: (0, viem_1.toBytes)(domain),
         userAddress: user,
         recipientAddress: recipient,
         tabId: (0, utils_1.parseU256)(tabId),

package/dist/models.js

@@ -12,6 +12,13 @@ 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 {
+    userAddress;
+    recipientAddress;
+    tabId;
+    reqId;
+    amount;
+    timestamp;
+    assetAddress;
     constructor(init) {
         this.userAddress = init.userAddress;
         this.recipientAddress = init.recipientAddress;
@@ -36,6 +43,9 @@ class PaymentGuaranteeRequestClaims {
 }
 exports.PaymentGuaranteeRequestClaims = PaymentGuaranteeRequestClaims;
 class UserSuspensionStatus {
+    userAddress;
+    suspended;
+    updatedAt;
     constructor(userAddress, suspended, updatedAt) {
         this.userAddress = userAddress;
         this.suspended = suspended;
@@ -47,6 +57,11 @@ class UserSuspensionStatus {
 }
 exports.UserSuspensionStatus = UserSuspensionStatus;
 class AdminApiKeyInfo {
+    id;
+    name;
+    scopes;
+    createdAt;
+    revokedAt;
     constructor(id, name, scopes, createdAt, revokedAt) {
         this.id = id;
         this.name = name;
@@ -61,6 +76,11 @@ class AdminApiKeyInfo {
 }
 exports.AdminApiKeyInfo = AdminApiKeyInfo;
 class AdminApiKeySecret {
+    id;
+    name;
+    scopes;
+    createdAt;
+    apiKey;
     constructor(id, name, scopes, createdAt, apiKey) {
         this.id = id;
         this.name = name;
@@ -81,6 +101,16 @@ function getAny(raw, ...keys) {
     return undefined;
 }
 class TabInfo {
+    tabId;
+    userAddress;
+    recipientAddress;
+    assetAddress;
+    startTimestamp;
+    ttlSeconds;
+    status;
+    settlementStatus;
+    createdAt;
+    updatedAt;
     constructor(tabId, userAddress, recipientAddress, assetAddress, startTimestamp, ttlSeconds, status, settlementStatus, createdAt, updatedAt) {
         this.tabId = tabId;
         this.userAddress = userAddress;
@@ -99,6 +129,14 @@ class TabInfo {
 }
 exports.TabInfo = TabInfo;
 class GuaranteeInfo {
+    tabId;
+    reqId;
+    fromAddress;
+    toAddress;
+    assetAddress;
+    amount;
+    timestamp;
+    certificate;
     constructor(tabId, reqId, fromAddress, toAddress, assetAddress, amount, timestamp, certificate) {
         this.tabId = tabId;
         this.reqId = reqId;
@@ -115,6 +153,8 @@ class GuaranteeInfo {
 }
 exports.GuaranteeInfo = GuaranteeInfo;
 class PendingRemunerationInfo {
+    tab;
+    latestGuarantee;
     constructor(tab, latestGuarantee) {
         this.tab = tab;
         this.latestGuarantee = latestGuarantee;
@@ -126,6 +166,15 @@ class PendingRemunerationInfo {
 }
 exports.PendingRemunerationInfo = PendingRemunerationInfo;
 class CollateralEventInfo {
+    id;
+    userAddress;
+    assetAddress;
+    amount;
+    eventType;
+    tabId;
+    reqId;
+    txId;
+    createdAt;
     constructor(id, userAddress, assetAddress, amount, eventType, tabId, reqId, txId, createdAt = 0) {
         this.id = id;
         this.userAddress = userAddress;
@@ -145,6 +194,12 @@ class CollateralEventInfo {
 }
 exports.CollateralEventInfo = CollateralEventInfo;
 class AssetBalanceInfo {
+    userAddress;
+    assetAddress;
+    total;
+    locked;
+    version;
+    updatedAt;
     constructor(userAddress, assetAddress, total, locked, version, updatedAt) {
         this.userAddress = userAddress;
         this.assetAddress = assetAddress;
@@ -159,6 +214,14 @@ class AssetBalanceInfo {
 }
 exports.AssetBalanceInfo = AssetBalanceInfo;
 class RecipientPaymentInfo {
+    userAddress;
+    recipientAddress;
+    txHash;
+    amount;
+    verified;
+    finalized;
+    failed;
+    createdAt;
     constructor(userAddress, recipientAddress, txHash, amount, verified, finalized, failed, createdAt) {
         this.userAddress = userAddress;
         this.recipientAddress = recipientAddress;

package/dist/rpc.js

@@ -8,6 +8,11 @@ function serializeTabId(tabId) {
     return `0x${BigInt(tabId).toString(16)}`;
 }
 class RpcProxy {
+    baseUrl;
+    adminApiKey;
+    bearerToken;
+    bearerTokenProvider;
+    fetchFn;
     constructor(endpoint, adminApiKey, fetchFn = fetch) {
         this.baseUrl = endpoint.endsWith('/') ? endpoint.slice(0, -1) : endpoint;
         this.adminApiKey = adminApiKey;

package/dist/signing.d.ts

@@ -1,22 +1,5 @@
+import { Account, type Hex } from 'viem';
 import { PaymentGuaranteeRequestClaims, PaymentSignature, SigningScheme } from './models';
-/**
- * ClientEvmSigner - Used by x402 clients to sign payment authorizations
- * This is typically a LocalAccount or wallet that holds private keys
- * and can sign EIP-712 typed data for payment authorizations
- */
-export type EvmSigner = {
-    readonly address: `0x${string}`;
-    signTypedData(message: {
-        domain: Record<string, unknown>;
-        types: Record<string, unknown>;
-        primaryType: string;
-        message: Record<string, unknown>;
-    }): Promise<`0x${string}`>;
-    signMessage(message: {
-        message: string;
-    }): Promise<`0x${string}`>;
-};
-export declare function createLocalSigner(privateKey: string): EvmSigner;
 export declare class CorePublicParameters {
     publicKey: Uint8Array;
     contractAddress: string;
@@ -70,12 +53,12 @@ export type GuaranteeTypedData = {
         chainId: number;
     };
     message: {
-        user: string;
-        recipient: string;
+        user: Hex;
+        recipient: Hex;
         tabId: bigint;
         reqId: bigint;
         amount: bigint;
-        asset: string;
+        asset: Hex;
         timestamp: bigint;
     };
 };
@@ -100,7 +83,7 @@ export declare function validateGuaranteeSigningContext(params: CorePublicParame
 export declare function buildGuaranteeTypedData(params: CorePublicParameters, claims: PaymentGuaranteeRequestClaims): GuaranteeTypedData;
 export declare function encodeGuaranteeEip191(claims: PaymentGuaranteeRequestClaims): string;
 export declare class PaymentSigner {
-    private signer;
-    constructor(signer: EvmSigner);
+    readonly signer: Account;
+    constructor(signer: Account);
     signRequest(params: CorePublicParameters, claims: PaymentGuaranteeRequestClaims, scheme?: SigningScheme): Promise<PaymentSignature>;
 }

package/dist/signing.js

@@ -1,31 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PaymentSigner = exports.GUARANTEE_EIP712_TYPES = exports.CorePublicParameters = void 0;
-exports.createLocalSigner = createLocalSigner;
 exports.validateGuaranteeTypedData = validateGuaranteeTypedData;
 exports.validateGuaranteeSigningContext = validateGuaranteeSigningContext;
 exports.buildGuaranteeTypedData = buildGuaranteeTypedData;
 exports.encodeGuaranteeEip191 = encodeGuaranteeEip191;
-const ethers_1 = require("ethers");
+const viem_1 = require("viem");
 const errors_1 = require("./errors");
 const models_1 = require("./models");
 const utils_1 = require("./utils");
-function createLocalSigner(privateKey) {
-    privateKey = (0, utils_1.normalizePrivateKey)(privateKey);
-    const wallet = new ethers_1.Wallet(privateKey);
-    return {
-        address: wallet.address,
-        signTypedData: async (message) => {
-            const signature = await wallet.signTypedData(message.domain, { [message.primaryType]: message.types[message.primaryType] }, message.message);
-            return signature;
-        },
-        signMessage: async ({ message }) => {
-            const signature = await wallet.signMessage(message);
-            return signature;
-        },
-    };
-}
 class CorePublicParameters {
+    publicKey;
+    contractAddress;
+    ethereumHttpRpcUrl;
+    eip712Name;
+    eip712Version;
+    chainId;
     constructor(publicKey, contractAddress, ethereumHttpRpcUrl, eip712Name, eip712Version, chainId) {
         this.publicKey = publicKey;
         this.contractAddress = contractAddress;
@@ -37,7 +27,7 @@ class CorePublicParameters {
     static fromRpc(payload) {
         const pkRaw = payload.public_key ?? payload.publicKey;
         const pk = typeof pkRaw === 'string'
-            ? (0, ethers_1.getBytes)(pkRaw)
+            ? (0, viem_1.toBytes)(pkRaw)
             : pkRaw instanceof Uint8Array
                 ? pkRaw
                 : Array.isArray(pkRaw)
@@ -176,18 +166,27 @@ function buildGuaranteeTypedData(params, claims) {
     };
 }
 function encodeGuaranteeEip191(claims) {
-    const payload = ethers_1.AbiCoder.defaultAbiCoder().encode(['address', 'address', 'uint256', 'uint256', 'uint256', 'address', 'uint64'], [
+    const payload = (0, viem_1.encodeAbiParameters)([
+        { type: 'address' },
+        { type: 'address' },
+        { type: 'uint256' },
+        { type: 'uint256' },
+        { type: 'uint256' },
+        { type: 'address' },
+        { type: 'uint64' },
+    ], [
         claims.userAddress,
         claims.recipientAddress,
         claims.tabId,
         claims.reqId,
         claims.amount,
         claims.assetAddress,
-        claims.timestamp,
+        BigInt(claims.timestamp),
     ]);
     return payload;
 }
 class PaymentSigner {
+    signer;
     constructor(signer) {
         this.signer = signer;
     }
@@ -195,6 +194,9 @@ class PaymentSigner {
         try {
             validateGuaranteeSigningContext(params, claims, { signerAddress: this.signer.address });
             if (scheme === models_1.SigningScheme.EIP712) {
+                if (!this.signer.signTypedData) {
+                    throw new errors_1.SigningError('signTypedData is not supported for this account');
+                }
                 const typed = buildGuaranteeTypedData(params, claims);
                 const signature = await this.signer.signTypedData({
                     domain: typed.domain,
@@ -205,6 +207,9 @@ class PaymentSigner {
                 return { signature, scheme };
             }
             if (scheme === models_1.SigningScheme.EIP191) {
+                if (!this.signer.signMessage) {
+                    throw new errors_1.SigningError('signMessage is not supported for this account');
+                }
                 const message = encodeGuaranteeEip191(claims);
                 const signature = await this.signer.signMessage({ message });
                 return { signature, scheme };

package/dist/utils.d.ts

@@ -1,3 +1,4 @@
+import { Hex } from 'viem';
 export declare class ValidationError extends Error {
     constructor(message: string);
 }
@@ -6,3 +7,4 @@ export declare function normalizePrivateKey(raw: string): string;
 export declare function normalizeAddress(raw: string): string;
 export declare function parseU256(value: number | bigint | string): bigint;
 export declare function serializeU256(value: number | bigint | string): string;
+export declare function hexFromBytes(bytes: Uint8Array): Hex;