@yellow-org/sdk 1.0.1-alpha.0

package/dist/blockchain/evm/client.d.ts

@@ -0,0 +1,46 @@
+import { Address } from 'viem';
+import Decimal from 'decimal.js';
+import * as core from '../../core/types';
+import { AssetStore, EVMClient, WalletSigner } from './interface';
+export interface ClientOptions {
+    requireCheckAllowance?: boolean;
+    requireCheckBalance?: boolean;
+}
+export declare class Client {
+    private contractAddress;
+    private evmClient;
+    private walletSigner;
+    private blockchainId;
+    private nodeAddress;
+    private assetStore;
+    private requireCheckAllowance;
+    private requireCheckBalance;
+    constructor(contractAddress: Address, evmClient: EVMClient, walletSigner: WalletSigner, blockchainId: bigint, nodeAddress: Address, assetStore: AssetStore, options?: ClientOptions);
+    private hexToBytes32;
+    getAccountsBalances(accounts: Address[], tokens: Address[]): Promise<Decimal[][]>;
+    private getAllowance;
+    getTokenBalance(asset: string, walletAddress: Address): Promise<Decimal>;
+    checkAllowance(asset: string, owner: Address): Promise<Decimal>;
+    approve(asset: string, amount: Decimal): Promise<string>;
+    approveTokenByAddress(tokenAddress: Address, amount: bigint): Promise<string>;
+    checkAllowanceByAddress(tokenAddress: Address, owner: Address): Promise<bigint>;
+    getNodeBalance(token: Address): Promise<Decimal>;
+    getOpenChannels(user: Address): Promise<string[]>;
+    getHomeChannelData(homeChannelId: string): Promise<core.HomeChannelDataResponse>;
+    getEscrowDepositData(_escrowChannelId: string): Promise<core.EscrowDepositDataResponse>;
+    getEscrowWithdrawalData(_escrowChannelId: string): Promise<core.EscrowWithdrawalDataResponse>;
+    deposit(node: Address, token: Address, amount: Decimal): Promise<string>;
+    withdraw(node: Address, token: Address, amount: Decimal): Promise<string>;
+    create(def: core.ChannelDefinition, initState: core.State): Promise<string>;
+    checkpoint(candidate: core.State): Promise<string>;
+    challenge(candidate: core.State, challengerSig: `0x${string}`, challengerIdx?: number): Promise<string>;
+    close(candidate: core.State): Promise<string>;
+    initiateEscrowDeposit(_def: core.ChannelDefinition, _initState: core.State): Promise<string>;
+    challengeEscrowDeposit(_candidate: core.State, _challengerSig: `0x${string}`, _challengerIdx?: number): Promise<string>;
+    finalizeEscrowDeposit(_candidate: core.State): Promise<string>;
+    initiateEscrowWithdrawal(_def: core.ChannelDefinition, _initState: core.State): Promise<string>;
+    challengeEscrowWithdrawal(_candidate: core.State, _challengerSig: `0x${string}`, _challengerIdx?: number): Promise<string>;
+    finalizeEscrowWithdrawal(_candidate: core.State): Promise<string>;
+    migrateChannelHere(_def: core.ChannelDefinition, _candidate: core.State): Promise<string>;
+}
+export declare function newClient(contractAddress: Address, evmClient: EVMClient, walletSigner: WalletSigner, blockchainId: bigint, nodeAddress: Address, assetStore: AssetStore, options?: ClientOptions): Client;

package/dist/blockchain/evm/client.js

@@ -0,0 +1,428 @@
+import { hexToBytes, zeroAddress } from 'viem';
+import Decimal from 'decimal.js';
+import * as core from '../../core/types';
+import { decimalToBigInt } from '../../core/utils';
+import { ChannelHubAbi } from './channel_hub_abi';
+import { coreDefToContractDef, coreStateToContractState, contractStateToCoreState, } from './utils';
+import { newERC20 } from './erc20';
+export class Client {
+    constructor(contractAddress, evmClient, walletSigner, blockchainId, nodeAddress, assetStore, options) {
+        this.contractAddress = contractAddress;
+        this.evmClient = evmClient;
+        this.walletSigner = walletSigner;
+        this.blockchainId = blockchainId;
+        this.nodeAddress = nodeAddress;
+        this.assetStore = assetStore;
+        this.requireCheckAllowance = options?.requireCheckAllowance ?? true;
+        this.requireCheckBalance = options?.requireCheckBalance ?? true;
+    }
+    hexToBytes32(s) {
+        const bytes = hexToBytes(s);
+        if (bytes.length !== 32) {
+            throw new Error(`invalid length: expected 32 bytes, got ${bytes.length}`);
+        }
+        return `0x${Array.from(bytes)
+            .map((b) => b.toString(16).padStart(2, '0'))
+            .join('')}`;
+    }
+    async getAccountsBalances(accounts, tokens) {
+        if (accounts.length === 0 || tokens.length === 0) {
+            return [];
+        }
+        const result = [];
+        for (const account of accounts) {
+            const accountBalances = [];
+            for (const token of tokens) {
+                const balance = (await this.evmClient.readContract({
+                    address: this.contractAddress,
+                    abi: ChannelHubAbi,
+                    functionName: 'getAccountBalance',
+                    args: [account, token],
+                }));
+                accountBalances.push(new Decimal(balance.toString()));
+            }
+            result.push(accountBalances);
+        }
+        return result;
+    }
+    async getAllowance(asset, owner) {
+        const tokenAddress = await this.assetStore.getTokenAddress(asset, this.blockchainId);
+        if (tokenAddress === zeroAddress) {
+            return new Decimal('1e18');
+        }
+        const erc20 = newERC20(tokenAddress, this.evmClient);
+        const allowance = await erc20.allowance(owner, this.contractAddress);
+        const decimals = await this.assetStore.getTokenDecimals(this.blockchainId, tokenAddress);
+        return new Decimal(allowance.toString()).div(Decimal.pow(10, decimals));
+    }
+    async getTokenBalance(asset, walletAddress) {
+        const tokenAddress = await this.assetStore.getTokenAddress(asset, this.blockchainId);
+        if (tokenAddress === zeroAddress) {
+            const balance = await this.evmClient.getBalance({ address: walletAddress });
+            return new Decimal(balance.toString()).div(Decimal.pow(10, 18));
+        }
+        const erc20 = newERC20(tokenAddress, this.evmClient);
+        const balance = await erc20.balanceOf(walletAddress);
+        const decimals = await this.assetStore.getTokenDecimals(this.blockchainId, tokenAddress);
+        return new Decimal(balance.toString()).div(Decimal.pow(10, decimals));
+    }
+    async checkAllowance(asset, owner) {
+        return await this.getAllowance(asset, owner);
+    }
+    async approve(asset, amount) {
+        const tokenAddress = await this.assetStore.getTokenAddress(asset, this.blockchainId);
+        if (tokenAddress === zeroAddress) {
+            throw new Error('Native tokens do not require approval');
+        }
+        const decimals = await this.assetStore.getTokenDecimals(this.blockchainId, tokenAddress);
+        const amountBig = decimalToBigInt(amount, decimals);
+        const erc20 = newERC20(tokenAddress, this.evmClient, this.walletSigner);
+        return await erc20.approve(this.contractAddress, amountBig);
+    }
+    async approveTokenByAddress(tokenAddress, amount) {
+        const erc20 = newERC20(tokenAddress, this.evmClient, this.walletSigner);
+        return await erc20.approve(this.contractAddress, amount);
+    }
+    async checkAllowanceByAddress(tokenAddress, owner) {
+        const erc20 = newERC20(tokenAddress, this.evmClient);
+        return await erc20.allowance(owner, this.contractAddress);
+    }
+    async getNodeBalance(token) {
+        const balance = (await this.evmClient.readContract({
+            address: this.contractAddress,
+            abi: ChannelHubAbi,
+            functionName: 'getAccountBalance',
+            args: [this.nodeAddress, token],
+        }));
+        const decimals = await this.assetStore.getTokenDecimals(this.blockchainId, token);
+        return new Decimal(balance.toString()).div(Decimal.pow(10, decimals));
+    }
+    async getOpenChannels(user) {
+        const channelIds = (await this.evmClient.readContract({
+            address: this.contractAddress,
+            abi: ChannelHubAbi,
+            functionName: 'getOpenChannels',
+            args: [user],
+        }));
+        return channelIds.map((id) => id);
+    }
+    async getHomeChannelData(homeChannelId) {
+        const channelIdBytes = this.hexToBytes32(homeChannelId);
+        const data = (await this.evmClient.readContract({
+            address: this.contractAddress,
+            abi: ChannelHubAbi,
+            functionName: 'getChannelData',
+            args: [channelIdBytes],
+        }));
+        const [, definition, lastState, challengeExpiry] = Array.isArray(data) ? data : [data.status, data.definition, data.lastState, data.challengeExpiry, data.lockedFunds];
+        const coreState = contractStateToCoreState(lastState, homeChannelId);
+        return {
+            definition: {
+                nonce: definition.nonce,
+                challenge: definition.challengeDuration,
+                approvedSigValidators: '0x' + (definition.approvedSignatureValidators ?? 0n).toString(16),
+            },
+            node: definition.node,
+            lastState: coreState,
+            challengeExpiry,
+        };
+    }
+    async getEscrowDepositData(_escrowChannelId) {
+        throw new Error('getEscrowDepositData not implemented - needs contract ABI update');
+    }
+    async getEscrowWithdrawalData(_escrowChannelId) {
+        throw new Error('getEscrowWithdrawalData not implemented - needs contract ABI update');
+    }
+    async deposit(node, token, amount) {
+        const decimals = await this.assetStore.getTokenDecimals(this.blockchainId, token);
+        const amountBig = decimalToBigInt(amount, decimals);
+        console.log('💳 EVM Client - Deposit transaction:', {
+            contractAddress: this.contractAddress,
+            blockchainId: this.blockchainId.toString(),
+            node,
+            token,
+            amount: amount.toString(),
+            amountBig: amountBig.toString(),
+            walletChain: this.walletSigner.chain?.id,
+            walletChainName: this.walletSigner.chain?.name
+        });
+        try {
+            console.log('🔍 Simulating deposit...');
+            const { request } = await this.evmClient.simulateContract({
+                address: this.contractAddress,
+                abi: ChannelHubAbi,
+                functionName: 'depositToVault',
+                args: [node, token, amountBig],
+                account: this.walletSigner.account.address,
+                ...(token === zeroAddress ? { value: amountBig } : {}),
+            });
+            console.log('✅ Simulation successful - executing deposit...');
+            const hash = await this.walletSigner.writeContract(request);
+            console.log('📤 Deposit transaction submitted - hash:', hash);
+            console.log('⏳ Waiting for confirmation...');
+            const receipt = await this.evmClient.waitForTransactionReceipt({ hash });
+            console.log('✅ Deposit transaction confirmed!', {
+                blockNumber: receipt.blockNumber,
+                gasUsed: receipt.gasUsed.toString(),
+            });
+            return hash;
+        }
+        catch (error) {
+            console.error('❌ Deposit transaction failed at blockchain level');
+            if (error.message?.includes('not supported') || error.message?.includes('not available')) {
+                console.error('⚠️  RPC ENDPOINT ISSUE: The RPC endpoint does not support sending transactions.');
+                console.error('    This usually means the RPC only supports read operations (eth_call, eth_getBalance, etc.)');
+                console.error('    but not write operations (eth_sendTransaction).');
+                console.error('    Solutions:');
+                console.error('      1. Use an RPC provider that supports transactions (Infura, Alchemy, etc.)');
+                console.error('      2. Make sure your RPC endpoint includes transaction capabilities');
+            }
+            throw error;
+        }
+    }
+    async withdraw(node, token, amount) {
+        const decimals = await this.assetStore.getTokenDecimals(this.blockchainId, token);
+        const amountBig = decimalToBigInt(amount, decimals);
+        console.log('💳 EVM Client - Withdraw transaction:', {
+            contractAddress: this.contractAddress,
+            blockchainId: this.blockchainId.toString(),
+            node,
+            token,
+            amount: amount.toString(),
+            amountBig: amountBig.toString(),
+            walletChain: this.walletSigner.chain?.id,
+            walletChainName: this.walletSigner.chain?.name
+        });
+        try {
+            console.log('🔍 Simulating withdrawal...');
+            const { request } = await this.evmClient.simulateContract({
+                address: this.contractAddress,
+                abi: ChannelHubAbi,
+                functionName: 'withdrawFromVault',
+                args: [node, token, amountBig],
+                account: this.walletSigner.account.address,
+            });
+            console.log('✅ Simulation successful - executing withdrawal...');
+            const hash = await this.walletSigner.writeContract(request);
+            console.log('📤 Withdraw transaction submitted - hash:', hash);
+            console.log('⏳ Waiting for confirmation...');
+            const receipt = await this.evmClient.waitForTransactionReceipt({ hash });
+            console.log('✅ Withdraw transaction confirmed!', {
+                blockNumber: receipt.blockNumber,
+                gasUsed: receipt.gasUsed.toString(),
+            });
+            return hash;
+        }
+        catch (error) {
+            console.error('❌ Withdraw simulation/execution failed!');
+            if (error.message) {
+                console.error('   Reason:', error.message);
+            }
+            throw error;
+        }
+    }
+    async create(def, initState) {
+        const contractDef = coreDefToContractDef(def, initState.asset, initState.userWallet, this.nodeAddress);
+        const contractState = await coreStateToContractState(initState, (blockchainId, tokenAddress) => this.assetStore.getTokenDecimals(blockchainId, tokenAddress));
+        if (initState.transition.type === core.TransitionType.HomeDeposit ||
+            initState.transition.type === core.TransitionType.EscrowDeposit) {
+            if (this.requireCheckAllowance) {
+                const allowance = await this.getAllowance(initState.asset, initState.userWallet);
+                if (allowance.lessThan(initState.transition.amount)) {
+                    throw new Error('Allowance is not sufficient to cover the deposit amount');
+                }
+            }
+            if (this.requireCheckBalance) {
+                const balance = await this.getTokenBalance(initState.asset, initState.userWallet);
+                if (balance.lessThan(initState.transition.amount)) {
+                    throw new Error('Balance is not sufficient to cover the deposit amount');
+                }
+            }
+        }
+        console.log('💳 EVM Client - Create channel transaction:', {
+            contractAddress: this.contractAddress,
+            blockchainId: this.blockchainId.toString(),
+            walletChain: this.walletSigner.chain?.id,
+            walletChainName: this.walletSigner.chain?.name
+        });
+        let nativeValue;
+        if ((initState.transition.type === core.TransitionType.HomeDeposit ||
+            initState.transition.type === core.TransitionType.EscrowDeposit) &&
+            contractState.homeLedger.token === zeroAddress) {
+            nativeValue = decimalToBigInt(initState.transition.amount, contractState.homeLedger.decimals);
+        }
+        console.log('🔍 Simulating transaction...');
+        try {
+            const { request } = (await this.evmClient.simulateContract({
+                address: this.contractAddress,
+                abi: ChannelHubAbi,
+                functionName: 'createChannel',
+                args: [contractDef, contractState],
+                account: this.walletSigner.account.address,
+                ...(nativeValue != null ? { value: nativeValue } : {}),
+            }));
+            console.log('✅ Simulation successful - executing transaction...');
+            const hash = await this.walletSigner.writeContract(request);
+            console.log('📤 Transaction submitted - hash:', hash);
+            console.log('⏳ Waiting for confirmation...');
+            const receipt = await this.evmClient.waitForTransactionReceipt({ hash });
+            console.log('✅ Create channel transaction confirmed!', {
+                blockNumber: receipt.blockNumber,
+                gasUsed: receipt.gasUsed.toString(),
+            });
+            return hash;
+        }
+        catch (error) {
+            console.error('❌ Transaction simulation failed!');
+            console.error('   This means the transaction would revert on-chain.');
+            if (error.message) {
+                console.error('   Revert reason:', error.message);
+            }
+            throw error;
+        }
+    }
+    async checkpoint(candidate) {
+        if (!candidate.homeChannelId) {
+            throw new Error('Candidate state must have a home channel ID');
+        }
+        const channelIdBytes = this.hexToBytes32(candidate.homeChannelId);
+        const contractCandidate = await coreStateToContractState(candidate, (blockchainId, tokenAddress) => this.assetStore.getTokenDecimals(blockchainId, tokenAddress));
+        if (candidate.transition.type === core.TransitionType.HomeDeposit) {
+            if (this.requireCheckAllowance) {
+                const allowance = await this.getAllowance(candidate.asset, candidate.userWallet);
+                if (allowance.lessThan(candidate.transition.amount)) {
+                    throw new Error('Allowance is not sufficient to cover the deposit amount');
+                }
+            }
+            if (this.requireCheckBalance) {
+                const balance = await this.getTokenBalance(candidate.asset, candidate.userWallet);
+                if (balance.lessThan(candidate.transition.amount)) {
+                    throw new Error('Balance is not sufficient to cover the deposit amount');
+                }
+            }
+            const nativeValue = contractCandidate.homeLedger.token === zeroAddress
+                ? decimalToBigInt(candidate.transition.amount, contractCandidate.homeLedger.decimals)
+                : undefined;
+            console.log('💳 EVM Client - Deposit to channel transaction:', {
+                contractAddress: this.contractAddress,
+                blockchainId: this.blockchainId.toString(),
+                channelId: channelIdBytes,
+                walletChain: this.walletSigner.chain?.id
+            });
+            const hash = await this.walletSigner.writeContract({
+                address: this.contractAddress,
+                abi: ChannelHubAbi,
+                functionName: 'depositToChannel',
+                args: [channelIdBytes, contractCandidate],
+                gas: 5000000n,
+                ...(nativeValue != null ? { value: nativeValue } : {}),
+            });
+            console.log('✅ Deposit to channel transaction hash:', hash);
+            return hash;
+        }
+        if (candidate.transition.type === core.TransitionType.HomeWithdrawal) {
+            console.log('💳 EVM Client - Withdraw from channel transaction:', {
+                contractAddress: this.contractAddress,
+                blockchainId: this.blockchainId.toString(),
+                channelId: channelIdBytes,
+                walletChain: this.walletSigner.chain?.id
+            });
+            const hash = await this.walletSigner.writeContract({
+                address: this.contractAddress,
+                abi: ChannelHubAbi,
+                functionName: 'withdrawFromChannel',
+                args: [channelIdBytes, contractCandidate],
+                gas: 5000000n,
+            });
+            console.log('✅ Withdraw from channel transaction hash:', hash);
+            return hash;
+        }
+        console.log('💳 EVM Client - Checkpoint channel transaction:', {
+            contractAddress: this.contractAddress,
+            blockchainId: this.blockchainId.toString(),
+            channelId: channelIdBytes,
+            walletChain: this.walletSigner.chain?.id
+        });
+        const hash = await this.walletSigner.writeContract({
+            address: this.contractAddress,
+            abi: ChannelHubAbi,
+            functionName: 'checkpointChannel',
+            args: [channelIdBytes, contractCandidate],
+            gas: 5000000n,
+        });
+        console.log('✅ Checkpoint channel transaction hash:', hash);
+        return hash;
+    }
+    async challenge(candidate, challengerSig, challengerIdx = 0) {
+        if (!candidate.homeChannelId) {
+            throw new Error('Candidate state must have a home channel ID');
+        }
+        const channelIdBytes = this.hexToBytes32(candidate.homeChannelId);
+        const contractCandidate = await coreStateToContractState(candidate, (blockchainId, tokenAddress) => this.assetStore.getTokenDecimals(blockchainId, tokenAddress));
+        console.log('💳 EVM Client - Challenge channel transaction:', {
+            contractAddress: this.contractAddress,
+            blockchainId: this.blockchainId.toString(),
+            channelId: channelIdBytes,
+            walletChain: this.walletSigner.chain?.id
+        });
+        const hash = await this.walletSigner.writeContract({
+            address: this.contractAddress,
+            abi: ChannelHubAbi,
+            functionName: 'challengeChannel',
+            args: [channelIdBytes, contractCandidate, challengerSig, challengerIdx],
+            gas: 5000000n,
+        });
+        console.log('✅ Challenge channel transaction hash:', hash);
+        return hash;
+    }
+    async close(candidate) {
+        if (!candidate.homeChannelId) {
+            throw new Error('Candidate state must have a home channel ID');
+        }
+        const channelIdBytes = this.hexToBytes32(candidate.homeChannelId);
+        const contractCandidate = await coreStateToContractState(candidate, (blockchainId, tokenAddress) => this.assetStore.getTokenDecimals(blockchainId, tokenAddress));
+        if (candidate.transition.type !== core.TransitionType.Finalize) {
+            throw new Error('Unsupported intent for close');
+        }
+        console.log('💳 EVM Client - Close channel transaction:', {
+            contractAddress: this.contractAddress,
+            blockchainId: this.blockchainId.toString(),
+            channelId: channelIdBytes,
+            walletChain: this.walletSigner.chain?.id,
+            walletChainName: this.walletSigner.chain?.name
+        });
+        const hash = await this.walletSigner.writeContract({
+            address: this.contractAddress,
+            abi: ChannelHubAbi,
+            functionName: 'closeChannel',
+            args: [channelIdBytes, contractCandidate],
+            gas: 5000000n,
+        });
+        console.log('✅ Close channel transaction hash:', hash);
+        return hash;
+    }
+    async initiateEscrowDeposit(_def, _initState) {
+        throw new Error('initiateEscrowDeposit not implemented - needs contract ABI update');
+    }
+    async challengeEscrowDeposit(_candidate, _challengerSig, _challengerIdx = 0) {
+        throw new Error('challengeEscrowDeposit not implemented - needs contract ABI update');
+    }
+    async finalizeEscrowDeposit(_candidate) {
+        throw new Error('finalizeEscrowDeposit not implemented - needs contract ABI update');
+    }
+    async initiateEscrowWithdrawal(_def, _initState) {
+        throw new Error('initiateEscrowWithdrawal not implemented - needs contract ABI update');
+    }
+    async challengeEscrowWithdrawal(_candidate, _challengerSig, _challengerIdx = 0) {
+        throw new Error('challengeEscrowWithdrawal not implemented - needs contract ABI update');
+    }
+    async finalizeEscrowWithdrawal(_candidate) {
+        throw new Error('finalizeEscrowWithdrawal not implemented - needs contract ABI update');
+    }
+    async migrateChannelHere(_def, _candidate) {
+        throw new Error('migrateChannelHere not implemented - needs contract ABI update');
+    }
+}
+export function newClient(contractAddress, evmClient, walletSigner, blockchainId, nodeAddress, assetStore, options) {
+    return new Client(contractAddress, evmClient, walletSigner, blockchainId, nodeAddress, assetStore, options);
+}

package/dist/blockchain/evm/erc20.d.ts

@@ -0,0 +1,13 @@
+import { Address } from 'viem';
+import { EVMClient, WalletSigner } from './interface';
+export declare class ERC20 {
+    private tokenAddress;
+    private client;
+    private walletSigner?;
+    constructor(tokenAddress: Address, client: EVMClient, walletSigner?: WalletSigner);
+    balanceOf(account: Address): Promise<bigint>;
+    allowance(owner: Address, spender: Address): Promise<bigint>;
+    approve(spender: Address, amount: bigint): Promise<string>;
+    decimals(): Promise<number>;
+}
+export declare function newERC20(tokenAddress: Address, client: EVMClient, walletSigner?: WalletSigner): ERC20;

package/dist/blockchain/evm/erc20.js

@@ -0,0 +1,54 @@
+import { Erc20Abi } from './erc20_abi';
+export class ERC20 {
+    constructor(tokenAddress, client, walletSigner) {
+        this.tokenAddress = tokenAddress;
+        this.client = client;
+        this.walletSigner = walletSigner;
+    }
+    async balanceOf(account) {
+        return this.client.readContract({
+            address: this.tokenAddress,
+            abi: Erc20Abi,
+            functionName: 'balanceOf',
+            args: [account],
+        });
+    }
+    async allowance(owner, spender) {
+        return this.client.readContract({
+            address: this.tokenAddress,
+            abi: Erc20Abi,
+            functionName: 'allowance',
+            args: [owner, spender],
+        });
+    }
+    async approve(spender, amount) {
+        if (!this.walletSigner) {
+            throw new Error('Wallet signer is required for approve operation');
+        }
+        try {
+            const { request } = (await this.client.simulateContract({
+                address: this.tokenAddress,
+                abi: Erc20Abi,
+                functionName: 'approve',
+                args: [spender, amount],
+                account: this.walletSigner.account.address,
+            }));
+            const hash = await this.walletSigner.writeContract(request);
+            await this.client.waitForTransactionReceipt({ hash });
+            return hash;
+        }
+        catch (error) {
+            console.error('❌ Approve simulation/execution failed!');
+            if (error.message) {
+                console.error('   Reason:', error.message);
+            }
+            throw error;
+        }
+    }
+    async decimals() {
+        throw new Error('decimals() not available in minimal ERC20 ABI');
+    }
+}
+export function newERC20(tokenAddress, client, walletSigner) {
+    return new ERC20(tokenAddress, client, walletSigner);
+}

package/dist/blockchain/evm/erc20_abi.d.ts

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