@xchainjs/xchain-thorchain-amm 0.1.0-alpha

package/lib/xchain-thorchain-amm/src/chain-defaults.d.ts

@@ -0,0 +1,4 @@
+import { Chain } from '@xchainjs/xchain-util/lib';
+import { ChainAttributes } from './types';
+declare const DefaultChainAttributes: Record<Chain, ChainAttributes>;
+export { DefaultChainAttributes };

package/lib/xchain-thorchain-amm/src/crypto-amount.d.ts

@@ -0,0 +1,37 @@
+import { Asset, AssetAmount, BaseAmount } from '@xchainjs/xchain-util';
+import { BigNumber } from 'bignumber.js';
+declare type CryptoNumeric = CryptoAmount | number | BigNumber;
+/**
+ * Utility Class to combine an amount (asset/base) with the Asset
+ *
+ */
+export declare class CryptoAmount {
+    baseAmount: BaseAmount;
+    readonly asset: Asset;
+    constructor(amount: BaseAmount, asset: Asset);
+    plus(v: CryptoAmount): CryptoAmount;
+    minus(v: CryptoAmount): CryptoAmount;
+    times(v: CryptoNumeric): CryptoAmount;
+    div(v: CryptoNumeric): CryptoAmount;
+    lt(v: CryptoAmount): boolean;
+    lte(v: CryptoAmount): boolean;
+    gt(v: CryptoAmount): boolean;
+    gte(v: CryptoAmount): boolean;
+    eq(v: CryptoAmount): boolean;
+    formatedAssetString(): string;
+    assetAmountFixedString(): string;
+    get assetAmount(): AssetAmount;
+    /**
+     * This guard protects against trying to perform math with different assets
+     *
+     * Example.
+     * const x = new CryptoAmount(baseAmount(1),AssetBTC)
+     * const y = new CryptoAmount(baseAmount(1),AssetETH)
+     *
+     * x.plus(y) <- will throw error "cannot perform math on 2 diff assets BTC.BTC ETH.ETH
+     *
+     * @param v - CryptoNumeric
+     */
+    private check;
+}
+export {};

package/lib/xchain-thorchain-amm/src/index.d.ts

@@ -0,0 +1,6 @@
+export * from './wallet';
+export * from './thorchain-amm';
+export * from './liquidity-pool';
+export * from './types';
+export * from './crypto-amount';
+export * from './utils/midgard';

package/lib/xchain-thorchain-amm/src/liquidity-pool-cache.d.ts

@@ -0,0 +1,73 @@
+import { Asset } from '@xchainjs/xchain-util';
+import { BigNumber } from 'bignumber.js';
+import { CryptoAmount } from './crypto-amount';
+import { LiquidityPool } from './liquidity-pool';
+import { SwapOutput } from './types';
+import { Midgard } from './utils/midgard';
+/**
+ * This class manages retrieving information from up to date Thorchain Liquidity Pools
+ */
+export declare class LiquidityPoolCache {
+    private midgard;
+    private poolCache;
+    private expirePoolCacheMillis;
+    /**
+     * Contrustor to create a LiquidityPoolCache
+     *
+     * @param midgard - an instance of the midgard API (could be pointing to stagenet,testnet,mainnet)
+     * @param expirePoolCacheMillis - how long should the pools be cached before expiry
+     * @returns LiquidityPoolCache
+     */
+    constructor(midgard: Midgard, expirePoolCacheMillis?: number);
+    /**
+     * Gets the exchange rate of the from asset in terms on the to asset
+     *
+     * @param asset - cannot be RUNE.
+     * @returns Promise<BigNumber>
+     */
+    getExchangeRate(from: Asset, to: Asset): Promise<BigNumber>;
+    /**
+     * Gets the Liquidity Pool for a given Asset
+     *
+     * @param asset - cannot be RUNE, since Rune is the other side of each pool.
+     * @returns Promise<LiquidityPool>
+     */
+    getPoolForAsset(asset: Asset): Promise<LiquidityPool>;
+    /**
+     * Get all the Liquidity Pools currently cached.
+     * if the cache is expired, the pools wioll be re-fetched from midgard
+     *
+     * @returns Promise<Record<string, LiquidityPool>>
+     */
+    getPools(): Promise<Record<string, LiquidityPool>>;
+    /**
+     * Refreshes the Pool Cache
+     *
+     * NOTE: do not call refereshPoolCache() directly, call getPools() instead
+     * which will refresh the cache if it's expired
+     */
+    private refereshPoolCache;
+    /**
+     *
+     *  Calcuate the expected slip, output & swapFee given the current pool depths
+     *
+     *  swapFee - the amount of asset lost  according to slip calculations
+     *  slip - the percent (0-1) of original amount lost to slipfees
+     *  output - the amount of asset expected from the swap   *
+     *
+     * @param inputAmount - CryptoAmount amount to swap from
+     * @param destinationAsset - destimation Asset to swap to
+     * @returns SwapOutput - swap output object - output - fee - slip
+     */
+    getExpectedSwapOutput(inputAmount: CryptoAmount, destinationAsset: Asset): Promise<SwapOutput>;
+    /**
+     * Returns the exchange of a CryptoAmount to a different Asset
+     *
+     * Ex. convert(input:100 BUSD, outAsset: BTC) -> 0.0001234 BTC
+     *
+     * @param input - amount/asset to convert to outAsset
+     * @param ouAsset - the Asset you want to convert to
+     * @returns CryptoAmount of input
+     */
+    convert(input: CryptoAmount, outAsset: Asset): Promise<CryptoAmount>;
+}

package/lib/xchain-thorchain-amm/src/liquidity-pool.d.ts

@@ -0,0 +1,17 @@
+import { PoolDetail } from '@xchainjs/xchain-midgard/lib';
+import { Asset, BaseAmount } from '@xchainjs/xchain-util';
+import { BigNumber } from 'bignumber.js';
+/**
+ * Represent a Liquidity Pool in Thorchain
+ */
+export declare class LiquidityPool {
+    private pool;
+    readonly assetBalance: BaseAmount;
+    readonly runeBalance: BaseAmount;
+    readonly asset: Asset;
+    readonly assetString: string;
+    readonly runeToAssetRatio: BigNumber;
+    readonly assetToRuneRatio: BigNumber;
+    constructor(pool: PoolDetail);
+    isAvailable(): boolean;
+}

package/lib/xchain-thorchain-amm/src/thorchain-amm.d.ts

@@ -0,0 +1,115 @@
+import { Asset, Chain } from '@xchainjs/xchain-util';
+import { CryptoAmount } from './crypto-amount';
+import { ChainAttributes, EstimateSwapParams, SwapEstimate, SwapSubmitted, TotalFees } from './types';
+import { Midgard } from './utils/midgard';
+import { Wallet } from './wallet';
+/**
+ * THORChain Class for interacting with THORChain.
+ * Recommended main class to use for swapping with THORChain
+ * Has access to Midgard and THORNode data
+ */
+export declare class ThorchainAMM {
+    private midgard;
+    private allPools;
+    private chainAttributes;
+    /**
+     * Contructor to create a ThorchainAMM
+     *
+     * @param midgard - an instance of the midgard API (could be pointing to stagenet,testnet,mainnet)
+     * @param expirePoolCacheMillis - how long should the pools be cached before expiry
+     * @param chainAttributes - atrributes used to calculate waitTime & conf counting
+     * @returns ThorchainAMM
+     */
+    constructor(midgard: Midgard, expirePoolCacheMillis?: number, chainAttributes?: Record<Chain, ChainAttributes>);
+    /**
+     * Provides a swap estimate for the given swap detail. Will check the params for errors before trying to get the estimate.
+     * Uses current pool data, works out inbound and outboud fee, affiliate fees and works out the expected wait time for the swap (in and out)
+     *
+     * @param params - amount to swap
+  
+     * @returns The SwapEstimate
+     */
+    estimateSwap(params: EstimateSwapParams): Promise<SwapEstimate>;
+    /**
+     * Convinience method to convert TotalFees to a different CryptoAmount
+     *
+     * TotalFees are always calculated and returned in RUNE, this method can
+     * be used to show the equivalent fees in another Asset Type
+     *
+     * @param fees: TotalFees - the fees you want to convert
+     * @param asset: Asset - the asset you want the fees converted to
+     * @returns TotalFees in asset
+     */
+    getFeesIn(fees: TotalFees, asset: Asset): Promise<TotalFees>;
+    /**
+     * Returns the exchange of a CryptoAmount to a different Asset
+     *
+     * Ex. convert(input:100 BUSD, outAsset: BTC) -> 0.0001234 BTC
+     *
+     * @param input - amount/asset to convert to outAsset
+     * @param ouAsset - the Asset you want to convert to
+     * @returns CryptoAmount of input
+     */
+    convert(input: CryptoAmount, outAsset: Asset): Promise<CryptoAmount>;
+    /**
+     * Conducts a swap with the given inputs. Should be called after estimateSwap() to ensure the swap is valid
+     *
+     * @param wallet - wallet to use
+     * @param params - swap paraps
+     * @param destinationAddress - were to send the output of the swap
+     * @param affiliateAddress - were to send the affilate Address, should be a THOR address (optional)
+     * @param interfaceID - id if the calling interface (optional)
+     * @returns {SwapSubmitted} - Tx Hash, URL of BlockExplorer and expected wait time.
+     */
+    protected doSwap(wallet: Wallet, params: EstimateSwapParams, destinationAddress: string, affiliateAddress?: string, interfaceID?: number): Promise<SwapSubmitted>;
+    /**
+     * Basic Checks for swap information
+     * @param params
+     */
+    private isValidSwap;
+    /**
+     * Does the calculations for the swap.
+     * Used by estimateSwap
+     *
+     * @param params
+     * @param sourceInboundDetails
+     * @param destinationInboundDetails
+     * @param sourcePool
+     * @param destinationPool
+     * @returns
+     */
+    private calcSwapEstimate;
+    /**
+     * Looks for errors or issues within swap prams before doing the swap.
+     *
+     *
+     * @param params
+     * @param estimate
+     * @param sourcePool
+     * @param sourceInboundDetails
+     * @param destinationPool
+     * @param destinationInboundDetails
+     * @returns
+     */
+    private getSwapEstimateErrors;
+    private checkCoverFees;
+    /**
+     * Works out how long an outbound Tx will be held by THORChain before sending.
+     *
+     * @param outboundAmount: CryptoAmount  being sent.
+     * @returns required delay in seconds
+     * @see https://gitlab.com/thorchain/thornode/-/blob/develop/x/thorchain/manager_txout_current.go#L548
+     */
+    outboundDelay(outboundAmount: CryptoAmount): Promise<number>;
+    /**
+     * Finds the required confCount required for an inbound or outbound Tx to THORChain. Estimate based on Midgard data only.
+     *
+     * Finds the gas asset of the given asset (e.g. BUSD is on BNB), finds the value of asset in Gas Asset then finds the required confirmation count.
+     * ConfCount is then times by 6 seconds.
+     *
+     * @param inbound: CryptoAmount - amount/asset of the outbound amount.
+     * @returns time in seconds before a Tx is confirmed by THORChain
+     * @see https://docs.thorchain.org/chain-clients/overview
+     */
+    private confCounting;
+}

package/lib/xchain-thorchain-amm/src/types.d.ts

@@ -0,0 +1,90 @@
+import { Address, FeeOption } from '@xchainjs/xchain-client';
+import { Asset, BaseAmount } from '@xchainjs/xchain-util';
+import { BigNumber } from 'bignumber.js';
+import { CryptoAmount } from './crypto-amount';
+import { LiquidityPool } from './liquidity-pool';
+export declare type TotalFees = {
+    inboundFee: CryptoAmount;
+    swapFee: CryptoAmount;
+    outboundFee: CryptoAmount;
+    affiliateFee: CryptoAmount;
+};
+export declare type SwapEstimate = {
+    totalFees: TotalFees;
+    slipPercentage: BigNumber;
+    netOutput: CryptoAmount;
+    waitTimeSeconds: number;
+    canSwap: boolean;
+    errors?: string[];
+};
+export declare type PoolCache = {
+    lastRefreshed: number;
+    pools: Record<string, LiquidityPool>;
+};
+export declare type MidgardConfig = {
+    apiRetries: number;
+    midgardBaseUrls: string[];
+};
+export declare type EstimateSwapParams = {
+    input: CryptoAmount;
+    destinationAsset: Asset;
+    affiliateFeePercent?: number;
+    slipLimit?: BigNumber;
+};
+export declare type ExecuteSwap = {
+    fromBaseAmount: BaseAmount;
+    sourceAsset: Asset;
+    destinationAsset: Asset;
+    limit: BaseAmount;
+    destinationAddress: Address;
+    affiliateAddress: Address;
+    affiliateFee: BaseAmount;
+    feeOption?: FeeOption;
+    interfaceID: number;
+    waitTimeSeconds: number;
+};
+export declare type SwapSubmitted = {
+    hash: string;
+    url: string;
+    waitTimeSeconds: number;
+};
+export declare type DepositParams = {
+    walletIndex?: number;
+    asset: Asset;
+    amount: BaseAmount;
+    feeOption: FeeOption;
+    memo: string;
+};
+export declare type SwapOutput = {
+    output: BaseAmount;
+    swapFee: BaseAmount;
+    slip: BigNumber;
+};
+export declare type UnitData = {
+    liquidityUnits: BaseAmount;
+    totalUnits: BaseAmount;
+};
+export declare type LiquidityData = {
+    rune: BaseAmount;
+    asset: BaseAmount;
+};
+export declare type Block = {
+    current: number;
+    lastAdded: number;
+    fullProtection: number;
+};
+export declare type Coverage = {
+    poolRatio: BaseAmount;
+};
+export declare type InboundDetail = {
+    vault: string;
+    router?: string;
+    haltedChain: boolean;
+    haltedTrading: boolean;
+    haltedLP: boolean;
+    gas_rate: BigNumber;
+};
+export declare type ChainAttributes = {
+    blockReward: number;
+    avgBlockTimeInSecs: number;
+};

package/lib/xchain-thorchain-amm/src/utils/index.d.ts

@@ -0,0 +1,3 @@
+export { getSingleSwap, getDoubleSwap } from './swap';
+export { getLiquidityProtectionData, getSlipOnLiquidity, getPoolShare, getLiquidityUnits } from './liquidity';
+export * from './midgard';

package/lib/xchain-thorchain-amm/src/utils/liquidity.d.ts

@@ -0,0 +1,33 @@
+import { BaseAmount } from '@xchainjs/xchain-util';
+import { BigNumber } from 'bignumber.js';
+import { LiquidityPool } from '../liquidity-pool';
+import { Block, LiquidityData, UnitData } from '../types';
+/**
+ *
+ * @param liquidity - asset amount added
+ * @param pool  - pool depths
+ * @returns liquidity units
+ */
+export declare const getLiquidityUnits: (liquidity: LiquidityData, pool: LiquidityPool) => BaseAmount;
+/**
+ *
+ * @param unitData
+ * @param pool
+ * @returns
+ */
+export declare const getPoolShare: (unitData: UnitData, pool: LiquidityPool) => LiquidityData;
+/**
+ *
+ * @param liquidity
+ * @param pool
+ * @returns
+ */
+export declare const getSlipOnLiquidity: (liquidity: LiquidityData, pool: LiquidityPool) => BigNumber;
+/**
+ *
+ * @param liquidity
+ * @param pool
+ * @param block
+ * @returns
+ */
+export declare const getLiquidityProtectionData: (liquidity: LiquidityData, pool: LiquidityPool, block: Block) => number;

package/lib/xchain-thorchain-amm/src/utils/midgard.d.ts

@@ -0,0 +1,44 @@
+import { Network } from '@xchainjs/xchain-client';
+import { InboundAddressesItem, PoolDetail } from '@xchainjs/xchain-midgard';
+import { Chain } from '@xchainjs/xchain-util';
+import { CryptoAmount } from '../crypto-amount';
+import { InboundDetail, MidgardConfig } from '../types';
+export declare class Midgard {
+    private config;
+    private network;
+    private midgardApis;
+    constructor(network?: Network, config?: MidgardConfig);
+    private getMimirDetails;
+    /**
+     *
+     * @returns an array of Pools
+     */
+    getPools(): Promise<PoolDetail[]>;
+    getAllInboundAddresses(): Promise<InboundAddressesItem[]>;
+    /**
+     * Gets the Inbound Details for a given array of Chains.
+     * Will check if chain is THOR.
+     * @param chains - external chains
+     * @returns inbound details of given chains
+     */
+    getInboundDetails(chains: Chain[]): Promise<InboundDetail[]>;
+    private getConstantsDetails;
+    /**
+     *
+     * @returns the outbound Tx Value in RUNE (Basemount)
+     */
+    getScheduledOutboundValue(): Promise<CryptoAmount>;
+    /**
+     * Function that wraps Mimir and Constants to return the value from a given constant name. Searchs Mimir first.
+     *
+     * @param networkValueName the network value to be used to search the contsants
+     * @returns the mimir or constants value
+     */
+    getNetworkValueByNames(networkValueNames: string[]): Promise<Record<string, string>>;
+    /**
+     * Gets the latest block using the Health endpoint within Midgard
+     *
+     * @returns
+     */
+    getLatestBlockHeight(): Promise<number>;
+}

package/lib/xchain-thorchain-amm/src/utils/swap.d.ts

@@ -0,0 +1,68 @@
+import { Address } from '@xchainjs/xchain-client';
+import { Asset, BaseAmount, Chain } from '@xchainjs/xchain-util';
+import { BigNumber } from 'bignumber.js';
+import { CryptoAmount } from '../crypto-amount';
+import { LiquidityPool } from '../liquidity-pool';
+import { SwapOutput } from '../types';
+/**
+ *
+ * @param inputAmount - amount to swap
+ * @param pool - Pool Data, RUNE and ASSET Depths
+ * @param toRune - Direction of Swap. True if swapping to RUNE.
+ * @returns
+ */
+export declare const getSwapFee: (inputAmount: BaseAmount, pool: LiquidityPool, toRune: boolean) => BaseAmount;
+/**
+ * Works out the swap slip for a given swap.
+ *
+ * @param inputAmount - amount to swap
+ * @param pool - Pool Data, RUNE and ASSET Depths
+ * @param toRune - Direction of Swap. True if swapping to RUNE.
+ * @returns The amount of slip. Needs to * 100 to get percentage.
+ */
+export declare const getSwapSlip: (inputAmount: BaseAmount, pool: LiquidityPool, toRune: boolean) => BigNumber;
+/**
+ *
+ * @param inputAmount - amount to swap
+ * @param pool - Pool Data, RUNE and ASSET Depths
+ * @param toRune - Direction of Swap. True if swapping to RUNE.
+ * @returns The output amount
+ */
+export declare const getSwapOutput: (inputAmount: BaseAmount, pool: LiquidityPool, toRune: boolean) => BaseAmount;
+export declare const getDoubleSwapOutput: (inputAmount: BaseAmount, pool1: LiquidityPool, pool2: LiquidityPool) => BaseAmount;
+/**
+ *
+ * @param inputAmount - amount to swap
+ * @param pool - Pool Data, RUNE and ASSET Depths
+ * @returns swap output object - output - fee - slip
+ */
+export declare const getSingleSwap: (inputAmount: BaseAmount, pool: LiquidityPool, toRune: boolean) => SwapOutput;
+export declare const getDoubleSwapSlip: (inputAmount: BaseAmount, pool1: LiquidityPool, pool2: LiquidityPool) => BigNumber;
+export declare const getValueOfRuneInAsset: (inputRune: BaseAmount, pool: LiquidityPool) => BaseAmount;
+export declare const getValueOfAssetInRune: (inputAsset: BaseAmount, pool: LiquidityPool) => BaseAmount;
+export declare const getDoubleSwapFee: (inputAmount: BaseAmount, pool1: LiquidityPool, pool2: LiquidityPool) => BaseAmount;
+/**
+ *
+ * @param inputAmount - amount to swap
+ * @param pool - Pool Data, RUNE and ASSET Depths
+ * @param toRune - Direction of Swap. True if swapping to RUNE.
+ * @returns swap output object - output - fee - slip
+ */
+export declare const getDoubleSwap: (inputAmount: BaseAmount, pool1: LiquidityPool, pool2: LiquidityPool) => SwapOutput;
+export declare const getContractAddressFromAsset: (asset: Asset) => Address;
+/**
+ * Works out the required inbound or outbound fee based on the chain.
+ * Call getInboundDetails to get the current gasRate
+ *
+ * @param sourceAsset
+ * @param gasRate
+ * @see https://dev.thorchain.org/thorchain-dev/thorchain-and-fees#fee-calcuation-by-chain
+ * @returns
+ */
+export declare const calcNetworkFee: (asset: Asset, gasRate: BigNumber) => CryptoAmount;
+/**
+ * Return the chain for a given Asset This method should live somewhere else.
+ * @param chain
+ * @returns the gas asset type for the given chain
+ */
+export declare const getChainAsset: (chain: Chain) => Asset;

package/lib/xchain-thorchain-amm/src/utils/thornode.d.ts

@@ -0,0 +1,57 @@
+import { Network } from '@xchainjs/xchain-client';
+import { LastBlock, TxOutItem, TxResponse } from '@xchainjs/xchain-thornode';
+import { Chain } from '@xchainjs/xchain-util';
+import { ChainAttributes } from '../types';
+export declare type ThornodeConfig = {
+    apiRetries: number;
+    thornodeBaseUrls: string[];
+};
+export declare enum TxStage {
+    INBOUND_CHAIN_UNCONFIRMED = 0,
+    CONF_COUNTING = 1,
+    TC_PROCESSING = 2,
+    OUTBOUND_QUEUED = 3,
+    OUTBOUND_CHAIN_UNCONFIRMED = 4,
+    OUTBOUND_CHAIN_CONFIRMED = 5
+}
+export declare type TxStatus = {
+    stage: TxStage;
+    seconds: number;
+};
+export declare class Thornode {
+    private config;
+    private network;
+    private chainAttributes;
+    private transactionsApi;
+    private queueApi;
+    private networkApi;
+    constructor(network?: Network, config?: ThornodeConfig, chainAttributes?: Record<Chain, ChainAttributes>);
+    /**
+     * Returns the oubound transactions held by THORChain due to outbound delay
+     * May be empty if there are no transactions
+     *
+     * @returns {ScheduledQueueItem} Array
+     *
+     */
+    getscheduledQueue(): Promise<TxOutItem[]>;
+    getTxData(txHash: string): Promise<TxResponse>;
+    getLastBlock(height?: number): Promise<LastBlock[]>;
+    protected getChain: (chain: string) => Chain;
+    /**
+     * For a given in Tx Hash (as returned by THORChainAMM.DoSwap()), finds the status of any THORChain transaction
+     * This function should be polled.
+     * @param
+     * @param destinationChain
+     * @param inboundTxHash
+     * @returns
+     */
+    checkTx(inboundTxHash: string, sourceChain?: Chain): Promise<TxStatus>;
+    /** Stage 1  */
+    private checkObservedTx;
+    /** Stage 2, THORNode has seen it. See if observed only (conf counting) or it has been processed by THORChain  */
+    private checkObservedOnly;
+    /** Stage 3 */
+    private checkOutboundQueue;
+    /** Stage 4 */
+    private checkOutboundTx;
+}

package/lib/xchain-thorchain-amm/src/wallet.d.ts

@@ -0,0 +1,63 @@
+import { Balance, Network, TxHash, XChainClient } from '@xchainjs/xchain-client';
+import { InboundAddressesItem } from '@xchainjs/xchain-midgard/src/generated/midgardApi';
+import { Asset, BaseAmount, Chain } from '@xchainjs/xchain-util';
+import { ethers } from 'ethers';
+import { DepositParams, ExecuteSwap, SwapSubmitted } from './types';
+declare type AllBalances = {
+    chain: Chain;
+    address: string;
+    balances: Balance[] | string;
+};
+/**
+ * Wallet Class for managing all xchain-* wallets with a mnemonic seed.
+ */
+export declare class Wallet {
+    private network;
+    clients: Record<string, XChainClient>;
+    private asgardAssets;
+    private midgard;
+    /**
+     * Contructor to create a Wallet
+     *
+     * @param network - stagenet,testnet,mainnet
+     * @param phrase - mnemonic phrase
+     * @returns Wallet
+     */
+    constructor(network: Network, phrase: string);
+    /**
+     * Fetch balances for all wallets
+     *
+     * @returns AllBalances[]
+     */
+    getAllBalances(): Promise<AllBalances[]>;
+    /**
+     * Executes a Swap from THORChainAMM.doSwap()
+     *
+     * @param swap object with all the required details for a swap.
+     * @returns transaction details and explorer url
+     * @see ThorchainAMM.doSwap()
+     */
+    executeSwap(swap: ExecuteSwap): Promise<SwapSubmitted>;
+    private constructSwapMemo;
+    private validateSwap;
+    private swapRuneTo;
+    private swapNonRune;
+    private updateAsgardAddresses;
+    /**
+     * Transaction to THORChain inbound address.
+     *
+     * @param {DepositParams} params The transaction options.
+     * @returns {TxHash} The transaction hash.
+     *
+     * @throws {"halted chain"} Thrown if chain is halted.
+     * @throws {"halted trading"} Thrown if trading is halted.
+     * @throws {"amount is not approved"} Thrown if the amount is not allowed to spend
+     * @throws {"router address is not defined"} Thrown if router address is not defined
+     */
+    sendETHDeposit(params: DepositParams): Promise<TxHash>;
+    isTCRouterApprovedToSpend(asset: Asset, amount: BaseAmount, walletIndex?: number): Promise<boolean>;
+    approveTCRouterToSpend(asset: Asset, amount?: ethers.BigNumber, walletIndex?: number): Promise<ethers.providers.TransactionResponse>;
+    private getRouterAddressForChain;
+    getAsgardAssets(): Promise<InboundAddressesItem[]>;
+}
+export {};