@swapkit/core 1.0.0-rc.11 → 1.0.0-rc.111

package/dist/index.d.ts

@@ -6,38 +6,70 @@ import type { BinanceToolbox } from '@swapkit/toolbox-cosmos';
 import type { BSCToolbox } from '@swapkit/toolbox-evm';
 import type { BTCToolbox } from '@swapkit/toolbox-utxo';
 import { Chain } from '@swapkit/types';
+import type { ChainflipToolbox } from '@swapkit/toolbox-substrate';
+import { ConnectConfig } from '@swapkit/types';
+import { CosmosChain } from '@swapkit/types';
+import type { DASHToolbox } from '@swapkit/toolbox-utxo';
 import type { DepositParam } from '@swapkit/toolbox-cosmos';
 import type { DOGEToolbox } from '@swapkit/toolbox-utxo';
 import type { ETHToolbox } from '@swapkit/toolbox-evm';
+import { EVMChain } from '@swapkit/types';
 import type { EVMWalletOptions } from '@swapkit/types';
 import type { ExtendParams } from '@swapkit/types';
-import type { FeeOption } from '@swapkit/types';
+import { FeeOption } from '@swapkit/types';
 import type { GaiaToolbox } from '@swapkit/toolbox-cosmos';
 import type { KujiraToolbox } from '@swapkit/toolbox-cosmos';
 import type { LTCToolbox } from '@swapkit/toolbox-utxo';
 import type { MATICToolbox } from '@swapkit/toolbox-evm';
 import type { OPToolbox } from '@swapkit/toolbox-evm';
-import type { QuoteRoute } from '@swapkit/api';
+import type { PolkadotToolbox } from '@swapkit/toolbox-substrate';
+import type { QuoteRoute } from '@swapkit/helpers';
 import type { SwapKitNumber } from '@swapkit/helpers';
 import type { ThorchainToolboxType } from '@swapkit/toolbox-cosmos';
 import type { ThornameRegisterParam } from '@swapkit/helpers';
-import type { WalletOption } from '@swapkit/types';
+import { UTXOChain } from '@swapkit/types';
+import { WalletOption } from '@swapkit/types';
 
 export declare type AddLiquidityTxns = {
     runeTx?: string;
     assetTx?: string;
 };
 
-declare type BaseWalletMethods = {
-    getAddress: () => Promise<string> | string;
+declare type ApisType = {
+    [key in UTXOChain]?: string | any;
+} & {
+    [key in EVMChain]?: string | any;
+} & {
+    [key in CosmosChain]?: string;
 };
 
-export declare type ChainWallet = {
+export declare enum ApproveMode {
+    Approve = "approve",
+    CheckOnly = "checkOnly"
+}
+
+export declare type ApproveReturnType<T extends ApproveMode> = T extends "checkOnly" ? Promise<boolean> : Promise<string>;
+
+export declare type AvailableProviders<T> = T | {
+    [K in ProviderName]?: ProviderMethods;
+};
+
+export declare type ChainWallet<T extends Chain> = WalletMethods[T] & {
+    chain: Chain;
     address: string;
     balance: AssetValue[];
     walletType: WalletOption;
 };
 
+export declare type ConnectWalletParamsLocal = {
+    addChain: (params: ChainWallet<Chain>) => void;
+    config: ConnectConfig;
+    rpcUrls: {
+        [chain in Chain]?: string;
+    };
+    apis: ApisType;
+};
+
 export declare type CoreTxParams = {
     assetValue: AssetValue;
     recipient: string;
@@ -49,17 +81,63 @@ export declare type CoreTxParams = {
     expiration?: number;
 };
 
-export declare type CosmosBasedWallet<T extends typeof BinanceToolbox | typeof GaiaToolbox> = BaseWalletMethods & ReturnType<T> & {
+export declare type CosmosBasedWallet<T extends typeof BinanceToolbox | typeof GaiaToolbox> = ReturnType<T> & {
     transfer: (params: CoreTxParams) => Promise<string>;
 };
 
-export declare type EVMWallet<T extends typeof AVAXToolbox | typeof BSCToolbox | typeof ETHToolbox | typeof OPToolbox> = BaseWalletMethods & ReturnType<T> & {
+export declare type EVMWallet<T extends typeof AVAXToolbox | typeof BSCToolbox | typeof ETHToolbox | typeof OPToolbox> = ReturnType<T> & {
     transfer: (params: CoreTxParams) => Promise<string>;
 };
 
-export declare class SwapKitCore<T = ''> {
+declare type GenericSwapParams = {
+    buyAsset: AssetValue;
+    sellAsset: AssetValue;
+    recipient: string;
+};
+
+export declare type OldChainWallet = {
+    address: string;
+    balance: AssetValue[];
+    walletType: WalletOption;
+};
+
+export declare type OldWallet = {
+    [key in Chain]: OldChainWallet | null;
+};
+
+export declare type ProviderMethods = {
+    swap: (swapParams: SwapParams) => Promise<string>;
+    [key: string]: any;
+};
+
+export declare type ProviderName = "thorchain" | "chainflip" | "mayachain";
+
+export declare type QuoteRouteV2 = {
+    buyAsset: string;
+    sellAsset: string;
+    sellAmount: number;
+    destinationAddress: string;
+    sourceAddress: string;
+    providers: string[];
+};
+
+export declare type SubstrateBasedWallet<T extends typeof PolkadotToolbox | typeof ChainflipToolbox> = Awaited<ReturnType<T>>;
+
+export declare function SwapKit<ExtendedProviders extends {}, ConnectWalletMethods extends Record<string, ReturnType<SwapKitWallet["connect"]>>>({ stagenet, wallets, providers, config, apis, rpcUrls, }: {
+    providers: SwapKitProvider[];
+    stagenet: boolean;
+    wallets: SwapKitWallet[];
+    config?: Record<string, any>;
+    apis: Record<string, any>;
+    rpcUrls: Record<string, any>;
+}): SwapKitReturnType & ConnectWalletMethods & AvailableProviders<ExtendedProviders>;
+
+/**
+ * @deprecated Use SwapKit instead (import { SwapKit } from "@swapkit/core")
+ */
+export declare class SwapKitCore<T = ""> {
 
-    connectedChains: Wallet;
+    connectedChains: OldWallet;
     connectedWallets: WalletMethods;
     readonly stagenet: boolean;
     constructor({ stagenet }?: {
@@ -70,7 +148,7 @@ export declare class SwapKitCore<T = ''> {
     getWallet: <T_1 extends Chain>(chain: Chain) => WalletMethods[T_1];
     getExplorerAddressUrl: (chain: Chain, address: string) => string;
     getBalance: (chain: Chain, potentialScamFilter?: boolean) => Promise<AssetValue[]>;
-    swap: ({ streamSwap, recipient, route, feeOptionKey }: SwapParams) => Promise<string>;
+    swap: ({ streamSwap, recipient, route, feeOptionKey, }: SwapWithRouteParams) => Promise<string>;
     getWalletByChain: (chain: Chain, potentialScamFilter?: boolean) => Promise<{
         address?: string | undefined;
         balance?: AssetValue[] | undefined;
@@ -98,8 +176,7 @@ export declare class SwapKitCore<T = ''> {
         runeTx: string;
         assetTx: string;
     }>;
-    addLiquidity: ({ poolIdentifier, runeAssetValue, assetValue, runeAddr, assetAddr, isPendingSymmAsset, mode, }: {
-        poolIdentifier: string;
+    addLiquidity: ({ runeAssetValue, assetValue, runeAddr, assetAddr, isPendingSymmAsset, mode, }: {
         runeAssetValue: AssetValue;
         assetValue: AssetValue;
         isPendingSymmAsset?: boolean | undefined;
@@ -110,41 +187,48 @@ export declare class SwapKitCore<T = ''> {
         runeTx: string | undefined;
         assetTx: string | undefined;
     }>;
+    addLiquidityPart: ({ assetValue, poolAddress, address, symmetric, }: {
+        assetValue: AssetValue;
+        address?: string | undefined;
+        poolAddress: string;
+        symmetric: boolean;
+    }) => Promise<string>;
     withdraw: ({ memo, assetValue, percent, from, to, }: {
         memo?: string | undefined;
         assetValue: AssetValue;
         percent: number;
-        from: 'sym' | 'rune' | 'asset';
-        to: 'sym' | 'rune' | 'asset';
+        from: "sym" | "rune" | "asset";
+        to: "sym" | "rune" | "asset";
     }) => Promise<string>;
     savings: ({ assetValue, memo, percent, type, }: {
         assetValue: AssetValue;
         memo?: string | undefined;
     } & ({
-        type: 'add';
+        type: "add";
         percent?: undefined;
     } | {
-        type: 'withdraw';
+        type: "withdraw";
         percent: number;
     })) => Promise<string>;
     loan: ({ assetValue, memo, minAmount, type, }: {
         assetValue: AssetValue;
         memo?: string | undefined;
         minAmount: AssetValue;
-        type: 'open' | 'close';
+        type: "open" | "close";
     }) => Promise<string>;
     nodeAction: ({ type, assetValue, address, }: {
         address: string;
     } & ({
-        type: 'bond' | 'unbond';
+        type: "bond" | "unbond";
         assetValue: AssetValue;
     } | {
-        type: 'leave';
+        type: "leave";
         assetValue?: undefined;
     })) => Promise<string>;
     registerThorname: ({ assetValue, ...param }: ThornameRegisterParam & {
         assetValue: AssetValue;
     }) => Promise<string>;
+    registerMayaname: ({ assetValue, ...param }: any) => Promise<string>;
     extend: ({ wallets, config, apis, rpcUrls }: ExtendParams<T>) => void;
     estimateMaxSendableAmount: ({ chain, params, }: {
         chain: Chain;
@@ -160,6 +244,7 @@ export declare class SwapKitCore<T = ''> {
     connectXDEFI: (_chains: Chain[]) => Promise<void>;
     connectEVMWallet: (_chains: Chain[] | Chain, _wallet: EVMWalletOptions) => Promise<void>;
     connectWalletconnect: (_chains: Chain[], _options?: any) => Promise<void>;
+    connectKeepkey: (_chains: Chain[], _derivationPath: number[][]) => Promise<string>;
     connectKeystore: (_chains: Chain[], _phrase: string) => Promise<void>;
     connectLedger: (_chains: Chain, _derivationPath: number[]) => Promise<void>;
     connectTrezor: (_chains: Chain, _derivationPath: number[]) => Promise<void>;
@@ -168,14 +253,55 @@ export declare class SwapKitCore<T = ''> {
     disconnectChain: (chain: Chain) => void;
 }
 
-export declare type SwapParams = {
+export declare type SwapKitProvider = ({ wallets, stagenet }: {
+    wallets: Wallets;
+    stagenet?: boolean;
+}) => {
+    name: ProviderName;
+    methods: ProviderMethods;
+};
+
+declare type SwapKitProviders = {
+    [K in ProviderName]?: ProviderMethods;
+};
+
+export declare type SwapKitReturnType = SwapKitProviders & {
+    getAddress: (chain: Chain) => string;
+    getWallet: (chain: Chain) => ChainWallet<Chain> | undefined;
+    getWalletWithBalance: (chain: Chain, potentialScamFilter?: boolean) => Promise<ChainWallet<Chain>>;
+    getBalance: (chain: Chain, potentialScamFilter?: boolean) => AssetValue[];
+    getExplorerTxUrl: (chain: Chain, txHash: string) => string;
+    getExplorerAddressUrl: (chain: Chain, address: string) => string;
+    swap: (params: SwapParams) => Promise<string>;
+    validateAddress: (params: {
+        address: string;
+        chain: Chain;
+    }) => boolean | Promise<boolean> | undefined;
+    approveAssetValue: (assetValue: AssetValue, contractAddress: string) => boolean | Promise<string>;
+    isAssetValueApproved: (assetValue: AssetValue, contractAddress: string) => boolean | Promise<boolean>;
+};
+
+export declare type SwapKitWallet = {
+    connectMethodName: string;
+    connect: (params: ConnectWalletParamsLocal) => (connectParams: any) => void;
+};
+
+export declare type SwapParams = (SwapWithRouteParams | GenericSwapParams) & {
+    provider?: {
+        name: ProviderName;
+        config: Record<string, any>;
+    };
+};
+
+export declare type SwapWithRouteParams = {
     recipient: string;
+    route: QuoteRoute | QuoteRouteV2;
+    feeOptionKey?: FeeOption;
+    quoteId?: string;
     streamSwap?: boolean;
-    route: QuoteRoute;
-    feeOptionKey: FeeOption;
 };
 
-export declare type ThorchainWallet = BaseWalletMethods & ThorchainToolboxType & {
+export declare type ThorchainWallet = ThorchainToolboxType & {
     transfer: (params: CoreTxParams) => Promise<string>;
     deposit: (params: DepositParam) => Promise<string>;
 };
@@ -185,11 +311,13 @@ export declare type UpgradeParams = {
     recipient: string;
 };
 
-export declare type UTXOWallet<T extends typeof BCHToolbox | typeof BTCToolbox | typeof DOGEToolbox | typeof LTCToolbox> = BaseWalletMethods & ReturnType<T> & {
+export declare type UTXOWallet<T extends typeof BCHToolbox | typeof BTCToolbox | typeof DOGEToolbox | typeof LTCToolbox> = ReturnType<T> & {
     transfer: (prams: CoreTxParams) => Promise<string>;
 };
 
-export declare type Wallet = Record<Chain, ChainWallet | null>;
+export declare type Wallet = {
+    [key in Chain]?: ChainWallet<key>;
+};
 
 export declare type WalletMethods = {
     [Chain.Arbitrum]: EVMWallet<typeof ARBToolbox> | null;
@@ -198,17 +326,24 @@ export declare type WalletMethods = {
     [Chain.Binance]: CosmosBasedWallet<typeof BinanceToolbox> | null;
     [Chain.BitcoinCash]: UTXOWallet<typeof BCHToolbox> | null;
     [Chain.Bitcoin]: UTXOWallet<typeof BTCToolbox> | null;
+    [Chain.Chainflip]: SubstrateBasedWallet<typeof ChainflipToolbox> | null;
     [Chain.Cosmos]: CosmosBasedWallet<typeof GaiaToolbox> | null;
+    [Chain.Dash]: UTXOWallet<typeof DASHToolbox> | null;
     [Chain.Dogecoin]: UTXOWallet<typeof DOGEToolbox> | null;
     [Chain.Ethereum]: EVMWallet<typeof ETHToolbox> | null;
     [Chain.Kujira]: CosmosBasedWallet<typeof KujiraToolbox> | null;
     [Chain.Litecoin]: UTXOWallet<typeof LTCToolbox> | null;
     [Chain.Maya]: ThorchainWallet | null;
     [Chain.Optimism]: EVMWallet<typeof OPToolbox> | null;
+    [Chain.Polkadot]: SubstrateBasedWallet<typeof PolkadotToolbox> | null;
     [Chain.Polygon]: EVMWallet<typeof MATICToolbox> | null;
     [Chain.THORChain]: ThorchainWallet | null;
 };
 
+export declare type Wallets = {
+    [K in Chain]?: ChainWallet<K>;
+};
+
 
 export * from "@swapkit/helpers";
 export * from "@swapkit/types";