@swapkit/wallets 4.0.0-beta.53 → 4.0.0-beta.55

package/dist/types/okx/helpers.d.ts

@@ -0,0 +1,227 @@
+import { Chain, ChainId, type EVMChain, type GenericTransferParams } from "@swapkit/helpers";
+import type { NearToolbox } from "@swapkit/toolboxes/near";
+import { Psbt } from "bitcoinjs-lib";
+export declare function getWalletMethods(chain: Chain): Promise<{
+    transfer: ({ recipient, assetValue, memo, feeRate, feeOptionKey, }: GenericTransferParams) => Promise<string>;
+    getAddress: () => Promise<string | undefined>;
+    getAccount: (address: string) => Promise<import("@cosmjs/stargate").Account | null>;
+    getBalance: (address: string, _potentialScamFilter?: boolean) => Promise<import("@swapkit/helpers").AssetValue[]>;
+    getSignerFromPhrase: ({ phrase, derivationPath, }: {
+        phrase: string;
+        derivationPath: import("@swapkit/helpers").DerivationPathArray;
+    }) => Promise<import("@cosmjs/proto-signing").DirectSecp256k1HdWallet>;
+    getSignerFromPrivateKey: (privateKey: Uint8Array) => Promise<import("@cosmjs/proto-signing").DirectSecp256k1Wallet>;
+    createPrivateKeyFromPhrase: (phrase: string) => Promise<Uint8Array<ArrayBufferLike>>;
+    validateAddress: (address: string) => boolean;
+    getPubKey: () => Promise<string>;
+    getFees: () => Promise<{
+        average: import("@swapkit/helpers").SwapKitNumber;
+        fast: import("@swapkit/helpers").SwapKitNumber;
+        fastest: import("@swapkit/helpers").SwapKitNumber;
+    }>;
+    fetchFeeRateFromSwapKit: typeof import("@swapkit/toolboxes/cosmos").fetchFeeRateFromSwapKit;
+    getBalanceAsDenoms: (address: string) => Promise<{
+        denom: string;
+        amount: string;
+    }[]>;
+    createTransaction: ({ sender, recipient, assetValue, memo, feeRate, sequence, accountNumber, }: import("@swapkit/toolboxes/cosmos").CosmosCreateTransactionParams) => Promise<{
+        accountNumber: number;
+        chainId: ChainId;
+        fee: {
+            amount: {
+                denom: string;
+                amount: string;
+            }[];
+            gas: string;
+        };
+        memo: string;
+        sequence: number;
+        msgs: {
+            typeUrl: string;
+            value: {
+                fromAddress: string;
+                toAddress: string;
+                amount: {
+                    amount: string;
+                    denom: string;
+                }[];
+            };
+        }[];
+    }>;
+    verifySignature: ({ signature, message, address, }: {
+        signature: string;
+        message: string;
+        address: string;
+    }) => Promise<boolean>;
+} | {
+    address: string;
+    multicall: (callTuples: {
+        address: string;
+        data: string;
+    }[], multicallAddress?: string, funcName?: string, feeOptionKey?: import("@swapkit/helpers").FeeOption) => Promise<string>;
+    getNetworkParams: () => undefined;
+    getBalance: (address: string, scamFilter?: boolean) => Promise<import("@swapkit/helpers").AssetValue[]>;
+    getAddress: () => Promise<string> | undefined;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@swapkit/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@swapkit/helpers").FeeOption;
+        chain: EVMChain;
+    }) => Promise<import("@swapkit/helpers").AssetValue>;
+    call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@swapkit/toolboxes/evm").CallParams) => Promise<T_1>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides, }: import("@swapkit/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@swapkit/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@swapkit/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<import("ethers").ContractTransaction>;
+    createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
+    createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@swapkit/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@swapkit/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@swapkit/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@swapkit/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@swapkit/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@swapkit/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@swapkit/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    isApproved: ({ assetAddress, spenderAddress, from, amount, }: import("@swapkit/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@swapkit/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@swapkit/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | ((message: string | Uint8Array) => Promise<string>) | ((_message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@swapkit/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    address: string;
+    getNetworkParams: () => import("@swapkit/helpers").NetworkParams;
+    getBalance: (address: string, scamFilter?: boolean) => Promise<import("@swapkit/helpers").AssetValue[]>;
+    getAddress: () => Promise<string> | undefined;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@swapkit/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@swapkit/helpers").FeeOption;
+        chain: EVMChain;
+    }) => Promise<import("@swapkit/helpers").AssetValue>;
+    call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@swapkit/toolboxes/evm").CallParams) => Promise<T_1>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides, }: import("@swapkit/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@swapkit/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@swapkit/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam, }: import("@swapkit/toolboxes/evm").ApproveParams) => Promise<import("ethers").ContractTransaction>;
+    createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
+    createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@swapkit/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@swapkit/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@swapkit/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@swapkit/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@swapkit/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@swapkit/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@swapkit/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    isApproved: ({ assetAddress, spenderAddress, from, amount, }: import("@swapkit/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@swapkit/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@swapkit/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | ((message: string | Uint8Array) => Promise<string>) | ((_message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@swapkit/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    address: string;
+    accumulative: ({ inputs, outputs, feeRate: initialFeeRate, chain, }: import("@swapkit/toolboxes/utxo").UTXOCalculateTxSizeParams & {
+        outputs: import("@swapkit/toolboxes/utxo").TargetOutput[];
+        chain: import("@swapkit/helpers").UTXOChain;
+    }) => {
+        inputs: (import("@swapkit/toolboxes/utxo").UTXOType | import("@swapkit/toolboxes/utxo").UTXOInputWithScriptType)[];
+        outputs: import("@swapkit/toolboxes/utxo").TargetOutput[];
+        fee: number;
+    } | {
+        fee: number;
+        inputs?: undefined;
+        outputs?: undefined;
+    };
+    calculateTxSize: ({ inputs, outputs, feeRate }: import("@swapkit/toolboxes/utxo").UTXOCalculateTxSizeParams) => number;
+    getAddressFromKeys: (keys: import("ecpair").ECPairInterface | import("@swapkit/toolboxes/utxo").BchECPair) => string;
+    getAddress: () => Promise<string | undefined>;
+    validateAddress: (address: string) => boolean;
+    broadcastTx: (txHash: string) => Promise<string>;
+    createTransaction: ({ assetValue, recipient, memo, feeRate, sender, fetchTxHex, }: import("@swapkit/toolboxes/utxo").UTXOBuildTxParams) => Promise<{
+        psbt: Psbt;
+        utxos: import("@swapkit/toolboxes/utxo").UTXOType[];
+        inputs: import("@swapkit/toolboxes/utxo").UTXOType[];
+    }>;
+    createKeysForPath: (params: {
+        wif?: string;
+        phrase?: string;
+        derivationPath?: string;
+    }) => import("ecpair").ECPairInterface;
+    getFeeRates: () => Promise<{
+        average: number;
+        fast: number;
+        fastest: number;
+    }>;
+    getInputsOutputsFee: ({ assetValue, feeOptionKey, feeRate, memo, sender, recipient, }: Omit<import("@swapkit/toolboxes/utxo").UTXOBuildTxParams, "feeRate"> & {
+        feeOptionKey?: import("@swapkit/helpers").FeeOption;
+        feeRate?: number;
+    }) => Promise<{
+        inputs: (import("@swapkit/toolboxes/utxo").UTXOType | import("@swapkit/toolboxes/utxo").UTXOInputWithScriptType)[];
+        outputs: import("@swapkit/toolboxes/utxo").TargetOutput[];
+        fee: number;
+    } | {
+        fee: number;
+        inputs?: undefined;
+        outputs?: undefined;
+    }>;
+    transfer: ({ memo, recipient, feeOptionKey, feeRate, assetValue, }: import("@swapkit/toolboxes/utxo").UTXOTransferParams) => Promise<string>;
+    getPrivateKeyFromMnemonic: (params: {
+        phrase: string;
+        derivationPath: string;
+    }) => string;
+    getBalance: (address: string, scamFilter?: boolean) => Promise<import("@swapkit/helpers").AssetValue[]>;
+    estimateTransactionFee: (params: {
+        assetValue: import("@swapkit/helpers").AssetValue;
+        recipient: string;
+        sender: string;
+        memo?: string;
+        feeOptionKey?: import("@swapkit/helpers").FeeOption;
+        feeRate?: number;
+        fetchTxHex?: boolean;
+    }) => Promise<import("@swapkit/helpers").AssetValue>;
+    estimateMaxSendableAmount: ({ from, memo, feeRate, feeOptionKey, recipients, }: {
+        from: string;
+        memo?: string;
+        feeRate?: number;
+        feeOptionKey?: import("@swapkit/helpers").FeeOption;
+        recipients?: number | import("@swapkit/toolboxes/utxo").TargetOutput[];
+    }) => Promise<import("@swapkit/helpers").AssetValue>;
+} | (NearToolbox & {
+    address: string;
+}) | {
+    address: string;
+    tronWeb: import("tronweb").TronWeb;
+    getAddress: () => Promise<string>;
+    validateAddress: (address: string) => boolean;
+    getBalance: (address: string) => Promise<import("@swapkit/helpers").AssetValue[]>;
+    transfer: (params: import("@swapkit/toolboxes/tron").TronTransferParams) => Promise<string>;
+    estimateTransactionFee: (params: import("@swapkit/toolboxes/tron").TronTransferParams & {
+        sender?: string;
+    }) => Promise<import("@swapkit/helpers").AssetValue>;
+    createTransaction: (params: import("@swapkit/toolboxes/tron").TronCreateTransactionParams) => Promise<any>;
+    signTransaction: (transaction: any) => Promise<any>;
+    broadcastTransaction: (signedTransaction: any) => Promise<string>;
+    approve: (params: import("@swapkit/toolboxes/tron").ApproveParams) => Promise<string>;
+    isApproved: (params: import("@swapkit/toolboxes/tron").IsApprovedParams) => Promise<boolean>;
+    getApprovedAmount: (params: import("@swapkit/toolboxes/tron").ApprovedParams) => Promise<bigint>;
+}>;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/types/okx/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/okx/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EACL,OAAO,EACP,KAAK,QAAQ,EACb,KAAK,qBAAqB,EAK3B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE3D,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAkDrC,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,KAAK;;;;sDAnBb,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAhC4B,CAAC,kBAC1D,CAAC,sBAAsB,CAAC;;4CAKY,CAAC;;iDAG3C,GAAD;;;;;;sCAemB,GAAI;;;;;;;gIAkCX,GAAI;iIAUD,GACjB;;;gBAQsB,CAAA;kBAA4B,CAAC;mBAAgC,CAAC;YAE7D,CAAC;;;kBAKjB,CAAD;gBAA0B,CAAC;oBAA8B,CAAC;4BAGrD,CAAC;;;sCAKP,GAAG;oBACgC,CAAC;;;oEAWF,GAAI;;;;;4CAMW,CAAA;;iDAKpB,GAAI;;;;;;sCAUmB,GAAI;;;;;;;gIA2BxD,GAEL;iIAKmB,GAAI;;;gBAYgB,CAAC;kBAA4B,CAAC;mBAAgC,CAAC;YAAwC,CAAC;;;kBAA+I,CAAC;gBAA0B,CAAC;oBAA8B,CAAC;4BAAsC,CAAC;;;sCAAgL,GAAI;oBAAuD,CAAC;;;oEAAqU,GAAI;;;;;;;;;;;;;cA9Iv6B,CAAC;eAEC,CAAC;;;;;;;;;;;;;WAUN,CAAC;cAAwB,CAAC;sBAChC,CAAJ;;;;;;;;oBAyCqD,CAAC;eAC1C,CAAC;;;;;;;cAKE,CAAC;eAAwB,CAAC;;;;;;;4CA7BhC,CAAC;;;;;YAQN,CAAF;oBACU,CAAC;eAA6B,CAAA;kBAClC,CAAF;;;;YAKE,CAAV;eAA0B,CAAA;oBAElB,CAAP;kBAA+B,CAAC;;;aA4D2C,MAAM;;;;;;;;;cA1HhD,CAAC;;;;;;;;GA2JlC"}

package/dist/types/okx/index.d.ts

@@ -0,0 +1,11 @@
+import { Chain } from "@swapkit/helpers";
+export declare const okxWallet: {
+    connectOkx: {
+        connectWallet: (connectParams: {
+            addChain: import("@swapkit/helpers").AddChainType;
+        }) => (chains: Chain[]) => Promise<boolean>;
+        supportedChains: (Chain.Arbitrum | Chain.Aurora | Chain.Avalanche | Chain.Base | Chain.Berachain | Chain.BinanceSmartChain | Chain.Bitcoin | Chain.Cosmos | Chain.Ethereum | Chain.Gnosis | Chain.Near | Chain.Optimism | Chain.Polygon | Chain.Tron)[];
+    };
+};
+export declare const OKX_SUPPORTED_CHAINS: (Chain.Arbitrum | Chain.Aurora | Chain.Avalanche | Chain.Base | Chain.Berachain | Chain.BinanceSmartChain | Chain.Bitcoin | Chain.Cosmos | Chain.Ethereum | Chain.Gnosis | Chain.Near | Chain.Optimism | Chain.Polygon | Chain.Tron)[];
+//# sourceMappingURL=index.d.ts.map

package/dist/types/okx/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/okx/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAuC,MAAM,kBAAkB,CAAC;AAK9E,eAAO,MAAM,SAAS;;;;;;;CAmCpB,CAAC;AAEH,eAAO,MAAM,oBAAoB,wOAAsC,CAAC"}

package/dist/types/okx/types.d.ts

@@ -0,0 +1,104 @@
+import type { StdSignDoc } from "@cosmjs/amino";
+export declare enum BroadcastMode {
+    /** Return after tx commit */
+    Block = "block",
+    /** Return after CheckTx */
+    Sync = "sync",
+    /** Return right away */
+    Async = "async"
+}
+export interface Coin {
+    readonly denom: string;
+    readonly amount: string;
+}
+export interface StdFee {
+    readonly amount: readonly Coin[];
+    readonly gas: string;
+    readonly payer?: string;
+    readonly granter?: string;
+    readonly feePayer?: string;
+}
+export interface Msg {
+    readonly type: string;
+    readonly value: any;
+}
+export interface PubKey {
+    readonly type: string;
+    readonly value: string;
+}
+export interface StdSignature {
+    readonly pub_key: PubKey;
+    readonly signature: string;
+}
+export interface StdTx {
+    readonly msg: readonly Msg[];
+    readonly fee: StdFee;
+    readonly signatures: readonly StdSignature[];
+    readonly memo: string | undefined;
+}
+export interface AminoSignResponse {
+    readonly signed: StdSignDoc;
+    readonly signature: StdSignature;
+}
+export interface SignDoc {
+    /**
+     * body_bytes is protobuf serialization of a TxBody that matches the
+     * representation in TxRaw.
+     */
+    bodyBytes: Uint8Array;
+    /**
+     * auth_info_bytes is a protobuf serialization of an AuthInfo that matches the
+     * representation in TxRaw.
+     */
+    authInfoBytes: Uint8Array;
+    /**
+     * chain_id is the unique identifier of the chain this transaction targets.
+     * It prevents signed transactions from being used on another chain by an
+     * attacker
+     */
+    chainId: string;
+    /** account_number is the account number of the account in state */
+    accountNumber: any;
+}
+/**
+ * This is the same as Algo from @cosmjs/launchpad but those might diverge in the future.
+ */
+export type Algo = "secp256k1" | "ed25519" | "sr25519";
+/**
+ * This is the same as AccountData from @cosmjs/launchpad but those might diverge in the future.
+ */
+export interface AccountData {
+    /** A printable address (typically bech32 encoded) */
+    readonly address: string;
+    readonly algo: Algo;
+    readonly pubkey: Uint8Array;
+}
+export interface DirectSignResponse {
+    /**
+     * The sign doc that was signed.
+     * This may be different from the input signDoc when the signer modifies it as part of the signing process.
+     */
+    readonly signed: SignDoc;
+    readonly signature: StdSignature;
+}
+export interface OfflineDirectSigner {
+    readonly getAccounts: () => Promise<readonly AccountData[]>;
+    readonly signDirect: (signerAddress: string, signDoc: SignDoc) => Promise<DirectSignResponse>;
+}
+export interface OfflineAminoSigner {
+    /**
+     * Get AccountData array from wallet. Rejects if not enabled.
+     */
+    readonly getAccounts: () => Promise<readonly AccountData[]>;
+    /**
+     * Request signature from whichever key corresponds to provided bech32-encoded address. Rejects if not enabled.
+     *
+     * The signer implementation may offer the user the ability to override parts of the signDoc. It must
+     * return the doc that was signed in the response.
+     *
+     * @param signerAddress The address of the account that should sign the transaction
+     * @param signDoc The content that should be signed
+     */
+    readonly signAmino: (signerAddress: string, signDoc: StdSignDoc) => Promise<AminoSignResponse>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types/okx/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/okx/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,oBAAY,aAAa;IACvB,6BAA6B;IAC7B,KAAK,UAAU;IACf,2BAA2B;IAC3B,IAAI,SAAS;IACb,wBAAwB;IACxB,KAAK,UAAU;CAChB;AAED,MAAM,WAAW,IAAI;IACnB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,MAAM,EAAE,SAAS,IAAI,EAAE,CAAC;IACjC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,GAAG;IAClB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC;CACrB;AAED,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,GAAG,EAAE,SAAS,GAAG,EAAE,CAAC;IAC7B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,UAAU,EAAE,SAAS,YAAY,EAAE,CAAC;IAC7C,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;CACnC;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;CAClC;AAED,MAAM,WAAW,OAAO;IACtB;;;OAGG;IACH,SAAS,EAAE,UAAU,CAAC;IACtB;;;OAGG;IACH,aAAa,EAAE,UAAU,CAAC;IAC1B;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB,mEAAmE;IACnE,aAAa,EAAE,GAAG,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,MAAM,IAAI,GAAG,WAAW,GAAG,SAAS,GAAG,SAAS,CAAC;AAEvD;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,qDAAqD;IACrD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;CAC7B;AAED,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;CAClC;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,WAAW,EAAE,MAAM,OAAO,CAAC,SAAS,WAAW,EAAE,CAAC,CAAC;IAC5D,QAAQ,CAAC,UAAU,EAAE,CAAC,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,kBAAkB,CAAC,CAAC;CAC/F;AAED,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,OAAO,CAAC,SAAS,WAAW,EAAE,CAAC,CAAC;IAC5D;;;;;;;;OAQG;IACH,QAAQ,CAAC,SAAS,EAAE,CAAC,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,KAAK,OAAO,CAAC,iBAAiB,CAAC,CAAC;CAChG"}

package/dist/types/onekey/evmSigner.d.ts

@@ -0,0 +1,29 @@
+import type { Chain, DerivationPathArray } from "@swapkit/helpers";
+import type { JsonRpcProvider, Provider, Signer, TypedDataDomain, TypedDataField } from "ethers";
+type OneKeyEVMSignerParams = {
+    chain: Chain;
+    derivationPath: DerivationPathArray;
+    provider: Provider | JsonRpcProvider;
+};
+export declare function getEVMSigner({ chain, derivationPath, provider }: OneKeyEVMSignerParams): Promise<{
+    address: string;
+    chain: Chain;
+    derivationPath: DerivationPathArray;
+    readonly provider: Provider | JsonRpcProvider;
+    connect(provider: null | Provider): Signer;
+    signTypedData(domain: TypedDataDomain, types: Record<string, TypedDataField[]>, value: Record<string, any>): Promise<string>;
+    getAddress: () => Promise<string>;
+    signMessage: (message: string) => Promise<string>;
+    signTransaction: (transaction: any) => Promise<string>;
+    getNonce(blockTag?: import("ethers").BlockTag): Promise<number>;
+    populateCall(tx: import("ethers").TransactionRequest): Promise<import("ethers").TransactionLike<string>>;
+    populateTransaction(tx: import("ethers").TransactionRequest): Promise<import("ethers").TransactionLike<string>>;
+    populateAuthorization(_auth: import("ethers").AuthorizationRequest): Promise<import("ethers").AuthorizationRequest>;
+    estimateGas(tx: import("ethers").TransactionRequest): Promise<bigint>;
+    call(tx: import("ethers").TransactionRequest): Promise<string>;
+    resolveName(name: string): Promise<null | string>;
+    sendTransaction(tx: import("ethers").TransactionRequest): Promise<import("ethers").TransactionResponse>;
+    authorize(authorization: import("ethers").AuthorizationRequest): Promise<import("ethers").Authorization>;
+}>;
+export {};
+//# sourceMappingURL=evmSigner.d.ts.map

package/dist/types/onekey/evmSigner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evmSigner.d.ts","sourceRoot":"","sources":["../../../src/onekey/evmSigner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAEnE,OAAO,KAAK,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AAEjG,KAAK,qBAAqB,GAAG;IAC3B,KAAK,EAAE,KAAK,CAAC;IACb,cAAc,EAAE,mBAAmB,CAAC;IACpC,QAAQ,EAAE,QAAQ,GAAG,eAAe,CAAC;CACtC,CAAC;AAEF,wBAAsB,YAAY,CAAC,EAAE,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,EAAE,qBAAqB;aAIhF,MAAM;WACR,KAAK;oBACI,mBAAmB;uBAChB,QAAQ,GAAG,eAAe;sBAW3B,IAAI,GAAG,QAAQ,GAAG,MAAM;0BAgBhC,eAAe,SAChB,MAAM,CAAC,MAAM,EAAE,cAAc,EAAE,CAAC,SAChC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACzB,OAAO,CAAC,MAAM,CAAC;;kBAoCG,SAAS,MAAM;sBAYX,aAAa,GAAG;;;;;;;;;;GAqC5C"}

package/dist/types/onekey/index.d.ts

@@ -0,0 +1,11 @@
+import { Chain } from "@swapkit/helpers";
+export declare const onekeyWallet: {
+    connectOnekeyWallet: {
+        connectWallet: (connectParams: {
+            addChain: import("@swapkit/helpers").AddChainType;
+        }) => (chains: Chain[]) => Promise<boolean>;
+        supportedChains: (Chain.Arbitrum | Chain.Aurora | Chain.Avalanche | Chain.Base | Chain.BinanceSmartChain | Chain.Bitcoin | Chain.Ethereum | Chain.Gnosis | Chain.Optimism | Chain.Polygon | Chain.Solana)[];
+    };
+};
+export declare const ONEKEY_WALLET_SUPPORTED_CHAINS: (Chain.Arbitrum | Chain.Aurora | Chain.Avalanche | Chain.Base | Chain.BinanceSmartChain | Chain.Bitcoin | Chain.Ethereum | Chain.Gnosis | Chain.Optimism | Chain.Polygon | Chain.Solana)[];
+//# sourceMappingURL=index.d.ts.map

package/dist/types/onekey/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/onekey/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EAQN,MAAM,kBAAkB,CAAC;AAiK1B,eAAO,MAAM,YAAY;;;;;;;CAuCvB,CAAC;AAEH,eAAO,MAAM,8BAA8B,4LAAyC,CAAC"}

package/dist/types/phantom/index.d.ts

@@ -0,0 +1,12 @@
+import { Chain } from "@swapkit/helpers";
+export declare const phantomWallet: {
+    connectPhantom: {
+        connectWallet: (connectParams: {
+            addChain: import("@swapkit/helpers").AddChainType;
+        }) => (chains: Chain[]) => Promise<boolean>;
+        supportedChains: (Chain.Bitcoin | Chain.Ethereum | Chain.Solana)[];
+    };
+};
+export declare const PHANTOM_SUPPORTED_CHAINS: (Chain.Bitcoin | Chain.Ethereum | Chain.Solana)[];
+export type PhantomSupportedChain = (typeof PHANTOM_SUPPORTED_CHAINS)[number];
+//# sourceMappingURL=index.d.ts.map

package/dist/types/phantom/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/phantom/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,EAKN,MAAM,kBAAkB,CAAC;AAG1B,eAAO,MAAM,aAAa;;;;;;;CAwBxB,CAAC;AAEH,eAAO,MAAM,wBAAwB,mDAA0C,CAAC;AAChF,MAAM,MAAM,qBAAqB,GAAG,CAAC,OAAO,wBAAwB,CAAC,CAAC,MAAM,CAAC,CAAC"}

package/dist/types/polkadotjs/index.d.ts

@@ -0,0 +1,11 @@
+import { Chain } from "@swapkit/helpers";
+export declare const polkadotWallet: {
+    connectPolkadotJs: {
+        connectWallet: (connectParams: {
+            addChain: import("@swapkit/helpers").AddChainType;
+        }) => (chains: Chain[]) => Promise<boolean>;
+        supportedChains: Chain.Polkadot[];
+    };
+};
+export declare const POLKADOT_SUPPORTED_CHAINS: Chain.Polkadot[];
+//# sourceMappingURL=index.d.ts.map

package/dist/types/polkadotjs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/polkadotjs/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAqD,MAAM,kBAAkB,CAAC;AAG5F,eAAO,MAAM,cAAc;;;;;;;CAkBzB,CAAC;AAEH,eAAO,MAAM,yBAAyB,kBAA2C,CAAC"}

package/dist/types/radix/index.d.ts

@@ -0,0 +1,11 @@
+import { Chain } from "@swapkit/helpers";
+export declare const radixWallet: {
+    connectRadixWallet: {
+        connectWallet: (connectParams: {
+            addChain: import("@swapkit/helpers").AddChainType;
+        }) => (chains: Chain[]) => Promise<boolean>;
+        supportedChains: Chain.Radix[];
+    };
+};
+export declare const RADIX_SUPPORTED_CHAINS: Chain.Radix[];
+//# sourceMappingURL=index.d.ts.map

package/dist/types/radix/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/radix/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAEL,KAAK,EAKN,MAAM,kBAAkB,CAAC;AAG1B,eAAO,MAAM,WAAW;;;;;;;CAuBtB,CAAC;AAEH,eAAO,MAAM,sBAAsB,eAAwC,CAAC"}

package/dist/types/talisman/index.d.ts

@@ -0,0 +1,11 @@
+import { Chain } from "@swapkit/helpers";
+export declare const talismanWallet: {
+    connectTalisman: {
+        connectWallet: (connectParams: {
+            addChain: import("@swapkit/helpers").AddChainType;
+        }) => (chains: Chain[]) => Promise<boolean>;
+        supportedChains: (Chain.Arbitrum | Chain.Avalanche | Chain.Base | Chain.BinanceSmartChain | Chain.Ethereum | Chain.Optimism | Chain.Polkadot | Chain.Chainflip | Chain.Polygon)[];
+    };
+};
+export declare const TALISMAN_SUPPORTED_CHAINS: (Chain.Arbitrum | Chain.Avalanche | Chain.Base | Chain.BinanceSmartChain | Chain.Ethereum | Chain.Optimism | Chain.Polkadot | Chain.Chainflip | Chain.Polygon)[];
+//# sourceMappingURL=index.d.ts.map

package/dist/types/talisman/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/talisman/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EAON,MAAM,kBAAkB,CAAC;AAI1B,eAAO,MAAM,cAAc;;;;;;;CA4BzB,CAAC;AAEH,eAAO,MAAM,yBAAyB,kKAA2C,CAAC"}

package/dist/types/trezor.d.ts

@@ -0,0 +1,2 @@
+export * from "@swapkit/wallet-hardware/trezor";
+//# sourceMappingURL=trezor.d.ts.map

package/dist/types/trezor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trezor.d.ts","sourceRoot":"","sources":["../../src/trezor.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC"}