@vleap/warps-adapter-evm 0.2.0-alpha.4 → 0.2.0-alpha.41

package/dist/index.d.cts

@@ -0,0 +1,261 @@
+import { WarpChainAsset, AdapterFactory, WarpClientConfig, Adapter, WarpChain, WarpChainEnv, WarpChainInfo, WarpCache, AdapterWarpDataLoader, WarpChainAccount, WarpChainAction, WarpDataLoaderOptions, AdapterWarpExecutor, WarpExecutable, WarpActionExecution, AdapterWarpExplorer, AdapterWarpResults, Warp, WarpActionIndex, WarpAdapterGenericRemoteTransaction, ResolvedInput, WarpNativeValue, WarpExecutionResults, 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 results;
+    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<WarpActionExecution>;
+    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 WarpEvmResults implements AdapterWarpResults {
+    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<WarpActionExecution>;
+    private createFailedExecution;
+    private handleWarpChainAction;
+    private handleTransactionReceipt;
+    extractQueryResults(warp: Warp, typedValues: unknown[], actionIndex: number, inputs: ResolvedInput[]): Promise<{
+        values: {
+            string: string[];
+            native: WarpNativeValue[];
+        };
+        results: WarpExecutionResults;
+    }>;
+    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, WarpEvmResults, WarpEvmSerializer, WarpEvmWallet, createEvmAdapter, findKnownTokenById, getAllEvmAdapters, getAllEvmChainNames, getArbitrumAdapter, getBaseAdapter, getEthereumAdapter, getKnownTokensForChain };

package/dist/index.d.ts

@@ -1,12 +1,27 @@
-import { WarpExplorerName, WarpChainEnv, AdapterFactory, WarpClientConfig, Adapter, CombinedWarpBuilder, Warp, BaseWarpBuilder, WarpCacheConfig, AdapterWarpExecutor, WarpExecutable, WarpExecution, WarpChainInfo, WarpActionInputType, AdapterWarpExplorer, AdapterWarpResults, 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, WarpActionExecution, AdapterWarpExplorer, AdapterWarpResults, Warp, WarpActionIndex, WarpAdapterGenericRemoteTransaction, ResolvedInput, WarpNativeValue, WarpExecutionResults, 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;
     };
@@ -37,108 +52,175 @@ declare enum BaseExplorers {
     BlockscoutBase = "blockscout_base",
     BlockscoutBaseSepolia = "blockscout_base_sepolia"
 }
-declare enum LocalExplorers {
-    LocalBlockscout = "local_blockscout"
-}
-type ExplorerName = EthereumExplorers | ArbitrumExplorers | BaseExplorers | (LocalExplorers & WarpExplorerName);
+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 [LocalExplorers];
+        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 [LocalExplorers];
+        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 [LocalExplorers];
+        readonly devnet: readonly [BaseExplorers.BasescanSepolia, BaseExplorers.BlockscoutBaseSepolia];
     };
 };
 declare const ExplorerUrls: Record<ExplorerName, string>;
 
-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 getEvmExplorers: (chain: string | undefined, env: WarpChainEnv) => readonly ExplorerName[];
-declare const getPrimaryEvmExplorer: (chain: string | undefined, env: WarpChainEnv) => ExplorerName;
-declare const getEvmExplorerUrlByName: (explorerName: ExplorerName) => string;
-declare const getEvmExplorerByName: (chain: string | undefined, env: WarpChainEnv, name: string) => ExplorerName | undefined;
+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 getEthereumAdapter: AdapterFactory;
-declare const getArbitrumAdapter: AdapterFactory;
-declare const getBaseAdapter: AdapterFactory;
-declare const getAllEvmAdapters: (config: WarpClientConfig, fallback?: Adapter) => Adapter[];
+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 WarpEvmBuilder implements CombinedWarpBuilder {
+declare class WarpEvmDataLoader implements AdapterWarpDataLoader {
     private readonly config;
-    private warp;
-    private actions;
-    constructor(config: WarpClientConfig);
-    createFromRaw(encoded: string): Promise<Warp>;
-    setTitle(title: string): BaseWarpBuilder;
-    setDescription(description: string): BaseWarpBuilder;
-    setPreview(preview: string): BaseWarpBuilder;
-    setActions(actions: any[]): BaseWarpBuilder;
-    addAction(action: any): BaseWarpBuilder;
-    build(): Promise<Warp>;
-    createInscriptionTransaction(warp: Warp): ethers.TransactionRequest;
-    createFromTransaction(tx: ethers.TransactionResponse, validate?: boolean): Promise<Warp>;
-    createFromTransactionHash(hash: string, cache?: WarpCacheConfig): Promise<Warp | null>;
+    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);
+    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<WarpActionExecution>;
     private estimateGasAndSetDefaults;
-    signMessage(message: string, privateKey: string): Promise<string>;
+    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;
-    getTokenUrl(tokenAddress: string, explorer?: ExplorerName): string;
-    getContractUrl(contractAddress: string, 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 WarpEvmResults implements AdapterWarpResults {
     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[];
+    private readonly provider;
+    constructor(config: WarpClientConfig, chain: WarpChainInfo);
+    getActionExecution(warp: Warp, actionIndex: WarpActionIndex, tx: WarpAdapterGenericRemoteTransaction): Promise<WarpActionExecution>;
+    private createFailedExecution;
+    private handleWarpChainAction;
+    private handleTransactionReceipt;
+    extractQueryResults(warp: Warp, typedValues: unknown[], actionIndex: number, inputs: ResolvedInput[]): Promise<{
+        values: {
+            string: string[];
+            native: WarpNativeValue[];
+        };
         results: WarpExecutionResults;
     }>;
+    getTransactionStatus(txHash: string): Promise<{
+        status: 'pending' | 'confirmed' | 'failed';
+        blockNumber?: number;
+        gasUsed?: bigint;
+    }>;
+    getTransactionReceipt(txHash: string): Promise<ethers.TransactionReceipt | null>;
 }
 
 declare class WarpEvmSerializer implements AdapterWarpSerializer {
@@ -152,4 +234,28 @@ declare class WarpEvmSerializer implements AdapterWarpSerializer {
     private parseNativeValue;
 }
 
-export { ArbitrumExplorers, BaseExplorers, EVM_CHAIN_CONFIGS, EthereumExplorers, type EvmChainConfig, EvmExplorers, type ExplorerName, ExplorerUrls, LocalExplorers, WarpEvmBuilder, WarpEvmConstants, WarpEvmExecutor, WarpEvmExplorer, WarpEvmResults, WarpEvmSerializer, getAllEvmAdapters, getArbitrumAdapter, getBaseAdapter, getEthereumAdapter, getEvmApiUrl, getEvmChainConfig, getEvmExplorerByName, getEvmExplorerUrl, getEvmExplorerUrlByName, getEvmExplorers, getPrimaryEvmExplorer };
+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, WarpEvmResults, WarpEvmSerializer, WarpEvmWallet, createEvmAdapter, findKnownTokenById, getAllEvmAdapters, getAllEvmChainNames, getArbitrumAdapter, getBaseAdapter, getEthereumAdapter, getKnownTokensForChain };