@vleap/warps-adapter-evm 0.2.0-alpha.9 → 0.2.0-beta.44

package/dist/index.d.cts

@@ -0,0 +1,261 @@
+import { WarpChainAsset, AdapterFactory, WarpClientConfig, Adapter, WarpChain, WarpChainEnv, WarpChainInfo, WarpCache, AdapterWarpDataLoader, WarpChainAccount, WarpChainAction, WarpDataLoaderOptions, AdapterWarpExecutor, WarpExecutable, WarpActionExecutionResult, AdapterWarpExplorer, AdapterWarpOutput, Warp, WarpActionIndex, WarpAdapterGenericRemoteTransaction, ResolvedInput, WarpNativeValue, WarpExecutionOutput, AdapterWarpSerializer, WarpSerializer, WarpActionInputType, BaseWarpActionInputType, WarpAdapterGenericType, AdapterWarpWallet, WarpAdapterGenericTransaction } from '@vleap/warps';
+import { ethers } from 'ethers';
+
+declare const NativeTokenArb: WarpChainAsset;
+declare const getArbitrumAdapter: AdapterFactory;
+
+declare const NativeTokenBase: WarpChainAsset;
+declare const getBaseAdapter: AdapterFactory;
+
+declare const getAllEvmAdapters: (config: WarpClientConfig, fallback?: Adapter) => Adapter[];
+declare const getAllEvmChainNames: () => WarpChain[];
+
+declare const createEvmAdapter: (chainName: WarpChain, chainInfos: Record<WarpChainEnv, WarpChainInfo>) => AdapterFactory;
+
+declare const NativeTokenEth: WarpChainAsset;
+declare const getEthereumAdapter: AdapterFactory;
+
+declare const WarpEvmConstants: {
+    GasLimit: {
+        Default: number;
+        ContractCall: number;
+        ContractDeploy: number;
+        Transfer: number;
+        TokenTransfer: number;
+        Approve: number;
+        Swap: number;
+    };
+    GasPrice: {
+        Default: string;
+    };
+    Validation: {
+        MinGasLimit: number;
+        MaxGasLimit: number;
+    };
+};
+declare enum EthereumExplorers {
+    Etherscan = "etherscan",
+    EtherscanSepolia = "etherscan_sepolia",
+    Ethplorer = "ethplorer",
+    Blockscout = "blockscout",
+    BlockscoutSepolia = "blockscout_sepolia"
+}
+declare enum ArbitrumExplorers {
+    Arbiscan = "arbiscan",
+    ArbiscanSepolia = "arbiscan_sepolia",
+    BlockscoutArbitrum = "blockscout_arbitrum",
+    BlockscoutArbitrumSepolia = "blockscout_arbitrum_sepolia"
+}
+declare enum BaseExplorers {
+    Basescan = "basescan",
+    BasescanSepolia = "basescan_sepolia",
+    BlockscoutBase = "blockscout_base",
+    BlockscoutBaseSepolia = "blockscout_base_sepolia"
+}
+type ExplorerName = EthereumExplorers | ArbitrumExplorers | BaseExplorers;
+declare const EvmExplorers: {
+    readonly ethereum: {
+        readonly mainnet: readonly [EthereumExplorers.Etherscan, EthereumExplorers.Ethplorer, EthereumExplorers.Blockscout];
+        readonly testnet: readonly [EthereumExplorers.EtherscanSepolia, EthereumExplorers.BlockscoutSepolia];
+        readonly devnet: readonly [EthereumExplorers.EtherscanSepolia, EthereumExplorers.BlockscoutSepolia];
+    };
+    readonly arbitrum: {
+        readonly mainnet: readonly [ArbitrumExplorers.Arbiscan, ArbitrumExplorers.BlockscoutArbitrum];
+        readonly testnet: readonly [ArbitrumExplorers.ArbiscanSepolia, ArbitrumExplorers.BlockscoutArbitrumSepolia];
+        readonly devnet: readonly [ArbitrumExplorers.ArbiscanSepolia, ArbitrumExplorers.BlockscoutArbitrumSepolia];
+    };
+    readonly base: {
+        readonly mainnet: readonly [BaseExplorers.Basescan, BaseExplorers.BlockscoutBase];
+        readonly testnet: readonly [BaseExplorers.BasescanSepolia, BaseExplorers.BlockscoutBaseSepolia];
+        readonly devnet: readonly [BaseExplorers.BasescanSepolia, BaseExplorers.BlockscoutBaseSepolia];
+    };
+};
+declare const ExplorerUrls: Record<ExplorerName, string>;
+
+interface TokenMetadata {
+    name: string;
+    symbol: string;
+    decimals: number;
+    logoUrl?: string;
+}
+interface TokenBalance {
+    tokenAddress: string;
+    balance: bigint;
+    metadata: TokenMetadata;
+}
+interface TokenInfo {
+    name?: string;
+    symbol?: string;
+    logoURI?: string;
+    decimals?: number;
+}
+interface UniswapToken {
+    chainId: number;
+    address: string;
+    name: string;
+    symbol: string;
+    decimals: number;
+    logoURI: string;
+    extensions?: {
+        bridgeInfo?: Record<string, {
+            tokenAddress: string;
+        }>;
+    };
+}
+interface UniswapTokenList {
+    name: string;
+    timestamp: string;
+    version: {
+        major: number;
+        minor: number;
+        patch: number;
+    };
+    tokens: UniswapToken[];
+}
+interface TokenListResponse {
+    tokens: Array<{
+        chainId: number;
+        address: string;
+        name: string;
+        symbol: string;
+        decimals: number;
+        logoURI?: string;
+    }>;
+}
+
+declare class UniswapService {
+    private static readonly UNISWAP_TOKEN_LIST_URL;
+    private cache;
+    private chainId;
+    constructor(cache: WarpCache, chainId: number);
+    getTokenList(): Promise<UniswapTokenList>;
+    findToken(address: string): Promise<UniswapToken | null>;
+    getTokenMetadata(address: string): Promise<{
+        name: string;
+        symbol: string;
+        decimals: number;
+        logoUrl: string;
+    } | null>;
+    getBridgeInfo(address: string): Promise<Record<string, string> | null>;
+}
+
+declare const KnownTokens: Record<WarpChain, Record<string, WarpChainAsset[]>>;
+declare const findKnownTokenById: (chain: WarpChain, env: WarpChainEnv, id: string) => WarpChainAsset | null;
+declare const getKnownTokensForChain: (chainName: string, env?: string) => WarpChainAsset[];
+
+declare class WarpEvmDataLoader implements AdapterWarpDataLoader {
+    private readonly config;
+    private readonly chain;
+    private provider;
+    private cache;
+    private uniswapService;
+    constructor(config: WarpClientConfig, chain: WarpChainInfo);
+    getAccount(address: string): Promise<WarpChainAccount>;
+    getAccountAssets(address: string): Promise<WarpChainAsset[]>;
+    getAsset(identifier: string): Promise<WarpChainAsset | null>;
+    getAction(identifier: string, awaitCompleted?: boolean): Promise<WarpChainAction | null>;
+    getAccountActions(address: string, options?: WarpDataLoaderOptions): Promise<WarpChainAction[]>;
+    private getERC20TokenBalances;
+    private getTokenBalance;
+    private getTokenMetadata;
+}
+
+declare class WarpEvmExecutor implements AdapterWarpExecutor {
+    private readonly config;
+    private readonly chain;
+    private readonly serializer;
+    private readonly provider;
+    private readonly output;
+    constructor(config: WarpClientConfig, chain: WarpChainInfo);
+    createTransaction(executable: WarpExecutable): Promise<ethers.TransactionRequest>;
+    createTransferTransaction(executable: WarpExecutable): Promise<ethers.TransactionRequest>;
+    createContractCallTransaction(executable: WarpExecutable): Promise<ethers.TransactionRequest>;
+    private createTokenTransferTransaction;
+    private createSingleTokenTransfer;
+    executeQuery(executable: WarpExecutable): Promise<WarpActionExecutionResult>;
+    private estimateGasAndSetDefaults;
+    verifyMessage(message: string, signature: string): Promise<string>;
+}
+
+declare class WarpEvmExplorer implements AdapterWarpExplorer {
+    private readonly chain;
+    private readonly config;
+    constructor(chain: WarpChainInfo, config: WarpClientConfig);
+    private getExplorers;
+    private getPrimaryExplorer;
+    private getExplorerUrlByName;
+    getAccountUrl(address: string, explorer?: ExplorerName): string;
+    getTransactionUrl(hash: string, explorer?: ExplorerName): string;
+    getBlockUrl(blockNumber: string | number, explorer?: ExplorerName): string;
+    getAssetUrl(identifier: string, explorer?: ExplorerName): string;
+    getContractUrl(address: string, explorer?: ExplorerName): string;
+    getAllExplorers(): readonly ExplorerName[];
+    getExplorerByName(name: string): ExplorerName | undefined;
+    getAccountUrls(address: string): Record<ExplorerName, string>;
+    getTransactionUrls(hash: string): Record<ExplorerName, string>;
+    getAssetUrls(identifier: string): Record<ExplorerName, string>;
+    getContractUrls(address: string): Record<ExplorerName, string>;
+    getBlockUrls(blockNumber: string | number): Record<ExplorerName, string>;
+}
+
+declare class WarpEvmOutput implements AdapterWarpOutput {
+    private readonly config;
+    private readonly chain;
+    private readonly serializer;
+    private readonly provider;
+    constructor(config: WarpClientConfig, chain: WarpChainInfo);
+    getActionExecution(warp: Warp, actionIndex: WarpActionIndex, tx: WarpAdapterGenericRemoteTransaction): Promise<WarpActionExecutionResult>;
+    private createFailedExecution;
+    private handleWarpChainAction;
+    private handleTransactionReceipt;
+    extractQueryOutput(warp: Warp, typedValues: unknown[], actionIndex: number, inputs: ResolvedInput[]): Promise<{
+        values: {
+            string: string[];
+            native: WarpNativeValue[];
+        };
+        output: WarpExecutionOutput;
+    }>;
+    getTransactionStatus(txHash: string): Promise<{
+        status: 'pending' | 'confirmed' | 'failed';
+        blockNumber?: number;
+        gasUsed?: bigint;
+    }>;
+    getTransactionReceipt(txHash: string): Promise<ethers.TransactionReceipt | null>;
+}
+
+declare class WarpEvmSerializer implements AdapterWarpSerializer {
+    readonly coreSerializer: WarpSerializer;
+    constructor();
+    typedToString(value: any): string;
+    typedToNative(value: any): [WarpActionInputType, WarpNativeValue];
+    nativeToTyped(type: WarpActionInputType, value: WarpNativeValue): any;
+    nativeToType(type: BaseWarpActionInputType): WarpAdapterGenericType;
+    stringToTyped(value: string): any;
+    private parseNativeValue;
+}
+
+declare class WarpEvmWallet implements AdapterWarpWallet {
+    private config;
+    private chain;
+    private provider;
+    constructor(config: WarpClientConfig, chain: WarpChainInfo);
+    signTransaction(tx: WarpAdapterGenericTransaction): Promise<WarpAdapterGenericTransaction>;
+    signTransactions(txs: WarpAdapterGenericTransaction[]): Promise<WarpAdapterGenericTransaction[]>;
+    signMessage(message: string): Promise<string>;
+    sendTransaction(tx: WarpAdapterGenericTransaction): Promise<string>;
+    sendTransactions(txs: WarpAdapterGenericTransaction[]): Promise<string[]>;
+    create(mnemonic: string): {
+        address: string;
+        privateKey: string;
+        mnemonic: string;
+    };
+    generate(): {
+        address: string;
+        privateKey: string;
+        mnemonic: string;
+    };
+    getAddress(): string | null;
+    private getWallet;
+}
+
+export { ArbitrumExplorers, BaseExplorers, EthereumExplorers, EvmExplorers, type ExplorerName, ExplorerUrls, KnownTokens, NativeTokenArb, NativeTokenBase, NativeTokenEth, type TokenBalance, type TokenInfo, type TokenListResponse, type TokenMetadata, UniswapService, type UniswapToken, type UniswapTokenList, WarpEvmConstants, WarpEvmDataLoader, WarpEvmExecutor, WarpEvmExplorer, WarpEvmOutput, WarpEvmSerializer, WarpEvmWallet, createEvmAdapter, findKnownTokenById, getAllEvmAdapters, getAllEvmChainNames, getArbitrumAdapter, getBaseAdapter, getEthereumAdapter, getKnownTokensForChain };

package/dist/index.d.ts

@@ -1,30 +1,19 @@
-import { WarpChain, AdapterFactory, WarpClientConfig, Adapter, WarpChainEnv, AdapterWarpExecutor, WarpExecutable, WarpExecution, WarpChainInfo, WarpActionInputType, AdapterWarpExplorer, AdapterWarpResults, Warp, ResolvedInput, WarpExecutionResults, AdapterWarpSerializer, WarpSerializer, WarpNativeValue, BaseWarpActionInputType, WarpAdapterGenericType } from '@vleap/warps';
+import { WarpChainAsset, AdapterFactory, WarpClientConfig, Adapter, WarpChain, WarpChainEnv, WarpChainInfo, WarpCache, AdapterWarpDataLoader, WarpChainAccount, WarpChainAction, WarpDataLoaderOptions, AdapterWarpExecutor, WarpExecutable, WarpActionExecutionResult, AdapterWarpExplorer, AdapterWarpOutput, Warp, WarpActionIndex, WarpAdapterGenericRemoteTransaction, ResolvedInput, WarpNativeValue, WarpExecutionOutput, AdapterWarpSerializer, WarpSerializer, WarpActionInputType, BaseWarpActionInputType, WarpAdapterGenericType, AdapterWarpWallet, WarpAdapterGenericTransaction } from '@vleap/warps';
 import { ethers } from 'ethers';
 
-declare const ChainNameArbitrum: WarpChain;
+declare const NativeTokenArb: WarpChainAsset;
 declare const getArbitrumAdapter: AdapterFactory;
 
-declare const ChainNameBase: WarpChain;
+declare const NativeTokenBase: WarpChainAsset;
 declare const getBaseAdapter: AdapterFactory;
 
 declare const getAllEvmAdapters: (config: WarpClientConfig, fallback?: Adapter) => Adapter[];
 declare const getAllEvmChainNames: () => WarpChain[];
 
-declare const ChainNameEthereum: WarpChain;
-declare const getEthereumAdapter: AdapterFactory;
+declare const createEvmAdapter: (chainName: WarpChain, chainInfos: Record<WarpChainEnv, WarpChainInfo>) => AdapterFactory;
 
-interface EvmChainConfig {
-    apiUrl: string;
-    explorerUrl: string;
-    chainId: string;
-    registryAddress: string;
-    nativeToken: string;
-    blockTime?: number;
-}
-declare const EVM_CHAIN_CONFIGS: Record<string, Record<WarpChainEnv, EvmChainConfig>>;
-declare const getEvmChainConfig: (chain: string | undefined, env: WarpChainEnv) => EvmChainConfig;
-declare const getEvmApiUrl: (env: WarpChainEnv, chain?: string) => string;
-declare const getEvmExplorerUrl: (env: WarpChainEnv, chain?: string) => string;
+declare const NativeTokenEth: WarpChainAsset;
+declare const getEthereumAdapter: AdapterFactory;
 
 declare const WarpEvmConstants: {
     GasLimit: {
@@ -32,6 +21,7 @@ declare const WarpEvmConstants: {
         ContractCall: number;
         ContractDeploy: number;
         Transfer: number;
+        TokenTransfer: number;
         Approve: number;
         Swap: number;
     };
@@ -82,19 +72,109 @@ declare const EvmExplorers: {
 };
 declare const ExplorerUrls: Record<ExplorerName, string>;
 
+interface TokenMetadata {
+    name: string;
+    symbol: string;
+    decimals: number;
+    logoUrl?: string;
+}
+interface TokenBalance {
+    tokenAddress: string;
+    balance: bigint;
+    metadata: TokenMetadata;
+}
+interface TokenInfo {
+    name?: string;
+    symbol?: string;
+    logoURI?: string;
+    decimals?: number;
+}
+interface UniswapToken {
+    chainId: number;
+    address: string;
+    name: string;
+    symbol: string;
+    decimals: number;
+    logoURI: string;
+    extensions?: {
+        bridgeInfo?: Record<string, {
+            tokenAddress: string;
+        }>;
+    };
+}
+interface UniswapTokenList {
+    name: string;
+    timestamp: string;
+    version: {
+        major: number;
+        minor: number;
+        patch: number;
+    };
+    tokens: UniswapToken[];
+}
+interface TokenListResponse {
+    tokens: Array<{
+        chainId: number;
+        address: string;
+        name: string;
+        symbol: string;
+        decimals: number;
+        logoURI?: string;
+    }>;
+}
+
+declare class UniswapService {
+    private static readonly UNISWAP_TOKEN_LIST_URL;
+    private cache;
+    private chainId;
+    constructor(cache: WarpCache, chainId: number);
+    getTokenList(): Promise<UniswapTokenList>;
+    findToken(address: string): Promise<UniswapToken | null>;
+    getTokenMetadata(address: string): Promise<{
+        name: string;
+        symbol: string;
+        decimals: number;
+        logoUrl: string;
+    } | null>;
+    getBridgeInfo(address: string): Promise<Record<string, string> | null>;
+}
+
+declare const KnownTokens: Record<WarpChain, Record<string, WarpChainAsset[]>>;
+declare const findKnownTokenById: (chain: WarpChain, env: WarpChainEnv, id: string) => WarpChainAsset | null;
+declare const getKnownTokensForChain: (chainName: string, env?: string) => WarpChainAsset[];
+
+declare class WarpEvmDataLoader implements AdapterWarpDataLoader {
+    private readonly config;
+    private readonly chain;
+    private provider;
+    private cache;
+    private uniswapService;
+    constructor(config: WarpClientConfig, chain: WarpChainInfo);
+    getAccount(address: string): Promise<WarpChainAccount>;
+    getAccountAssets(address: string): Promise<WarpChainAsset[]>;
+    getAsset(identifier: string): Promise<WarpChainAsset | null>;
+    getAction(identifier: string, awaitCompleted?: boolean): Promise<WarpChainAction | null>;
+    getAccountActions(address: string, options?: WarpDataLoaderOptions): Promise<WarpChainAction[]>;
+    private getERC20TokenBalances;
+    private getTokenBalance;
+    private getTokenMetadata;
+}
+
 declare class WarpEvmExecutor implements AdapterWarpExecutor {
     private readonly config;
+    private readonly chain;
     private readonly serializer;
     private readonly provider;
-    private readonly results;
-    constructor(config: WarpClientConfig);
+    private readonly output;
+    constructor(config: WarpClientConfig, chain: WarpChainInfo);
     createTransaction(executable: WarpExecutable): Promise<ethers.TransactionRequest>;
     createTransferTransaction(executable: WarpExecutable): Promise<ethers.TransactionRequest>;
     createContractCallTransaction(executable: WarpExecutable): Promise<ethers.TransactionRequest>;
-    executeQuery(executable: WarpExecutable): Promise<WarpExecution>;
-    preprocessInput(chain: WarpChainInfo, input: string, type: WarpActionInputType, value: string): Promise<string>;
+    private createTokenTransferTransaction;
+    private createSingleTokenTransfer;
+    executeQuery(executable: WarpExecutable): Promise<WarpActionExecutionResult>;
     private estimateGasAndSetDefaults;
-    signMessage(message: string, privateKey: string): Promise<string>;
+    verifyMessage(message: string, signature: string): Promise<string>;
 }
 
 declare class WarpEvmExplorer implements AdapterWarpExplorer {
@@ -113,17 +193,34 @@ declare class WarpEvmExplorer implements AdapterWarpExplorer {
     getExplorerByName(name: string): ExplorerName | undefined;
     getAccountUrls(address: string): Record<ExplorerName, string>;
     getTransactionUrls(hash: string): Record<ExplorerName, string>;
+    getAssetUrls(identifier: string): Record<ExplorerName, string>;
+    getContractUrls(address: string): Record<ExplorerName, string>;
+    getBlockUrls(blockNumber: string | number): Record<ExplorerName, string>;
 }
 
-declare class WarpEvmResults implements AdapterWarpResults {
+declare class WarpEvmOutput implements AdapterWarpOutput {
     private readonly config;
+    private readonly chain;
     private readonly serializer;
-    constructor(config: WarpClientConfig);
-    getTransactionExecutionResults(warp: Warp, tx: ethers.TransactionReceipt): Promise<WarpExecution>;
-    extractQueryResults(warp: Warp, typedValues: any[], actionIndex: number, inputs: ResolvedInput[]): Promise<{
-        values: any[];
-        results: WarpExecutionResults;
+    private readonly provider;
+    constructor(config: WarpClientConfig, chain: WarpChainInfo);
+    getActionExecution(warp: Warp, actionIndex: WarpActionIndex, tx: WarpAdapterGenericRemoteTransaction): Promise<WarpActionExecutionResult>;
+    private createFailedExecution;
+    private handleWarpChainAction;
+    private handleTransactionReceipt;
+    extractQueryOutput(warp: Warp, typedValues: unknown[], actionIndex: number, inputs: ResolvedInput[]): Promise<{
+        values: {
+            string: string[];
+            native: WarpNativeValue[];
+        };
+        output: WarpExecutionOutput;
     }>;
+    getTransactionStatus(txHash: string): Promise<{
+        status: 'pending' | 'confirmed' | 'failed';
+        blockNumber?: number;
+        gasUsed?: bigint;
+    }>;
+    getTransactionReceipt(txHash: string): Promise<ethers.TransactionReceipt | null>;
 }
 
 declare class WarpEvmSerializer implements AdapterWarpSerializer {
@@ -137,4 +234,28 @@ declare class WarpEvmSerializer implements AdapterWarpSerializer {
     private parseNativeValue;
 }
 
-export { ArbitrumExplorers, BaseExplorers, ChainNameArbitrum, ChainNameBase, ChainNameEthereum, EVM_CHAIN_CONFIGS, EthereumExplorers, type EvmChainConfig, EvmExplorers, type ExplorerName, ExplorerUrls, WarpEvmConstants, WarpEvmExecutor, WarpEvmExplorer, WarpEvmResults, WarpEvmSerializer, getAllEvmAdapters, getAllEvmChainNames, getArbitrumAdapter, getBaseAdapter, getEthereumAdapter, getEvmApiUrl, getEvmChainConfig, getEvmExplorerUrl };
+declare class WarpEvmWallet implements AdapterWarpWallet {
+    private config;
+    private chain;
+    private provider;
+    constructor(config: WarpClientConfig, chain: WarpChainInfo);
+    signTransaction(tx: WarpAdapterGenericTransaction): Promise<WarpAdapterGenericTransaction>;
+    signTransactions(txs: WarpAdapterGenericTransaction[]): Promise<WarpAdapterGenericTransaction[]>;
+    signMessage(message: string): Promise<string>;
+    sendTransaction(tx: WarpAdapterGenericTransaction): Promise<string>;
+    sendTransactions(txs: WarpAdapterGenericTransaction[]): Promise<string[]>;
+    create(mnemonic: string): {
+        address: string;
+        privateKey: string;
+        mnemonic: string;
+    };
+    generate(): {
+        address: string;
+        privateKey: string;
+        mnemonic: string;
+    };
+    getAddress(): string | null;
+    private getWallet;
+}
+
+export { ArbitrumExplorers, BaseExplorers, EthereumExplorers, EvmExplorers, type ExplorerName, ExplorerUrls, KnownTokens, NativeTokenArb, NativeTokenBase, NativeTokenEth, type TokenBalance, type TokenInfo, type TokenListResponse, type TokenMetadata, UniswapService, type UniswapToken, type UniswapTokenList, WarpEvmConstants, WarpEvmDataLoader, WarpEvmExecutor, WarpEvmExplorer, WarpEvmOutput, WarpEvmSerializer, WarpEvmWallet, createEvmAdapter, findKnownTokenById, getAllEvmAdapters, getAllEvmChainNames, getArbitrumAdapter, getBaseAdapter, getEthereumAdapter, getKnownTokensForChain };