synapsecns / sdk / 2587307314

2587307314

Pull #104

github

GitHub 
<a href="https://github.com/synapsecns/sdk/commit/<a class=hub.com/synapsecns/sdk/commit/0d5fa35cb2cd0e734feb2b598569264209802206">0d5fa35cb<a href="https://github.com/synapsecns/sdk/commit/0d5fa35cb2cd0e734feb2b598569264209802206">">Merge </a><a class="double-link" href="https://github.com/synapsecns/sdk/commit/<a class="double-link" href="https://github.com/synapsecns/sdk/commit/b47bd0cc3631c918dab809f65cf4f05e88d4966f">b47bd0cc3</a>">b47bd0cc3</a><a href="https://github.com/synapsecns/sdk/commit/0d5fa35cb2cd0e734feb2b598569264209802206"> into 0f9fbc54d">0f9fbc54d</a>
Pull Request #104: Release v0.95.1

815 of 822 branches covered (99.15%)

Branch coverage included in aggregate %.

2812 of 2820 new or added lines in 25 files covered. (99.72%)

11 existing lines in 1 file now uncovered.

6328 of 6347 relevant lines covered (99.7%)

110.88 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

99.71
/src/tokenswap.ts
1 
import {
2✔
2 
    isNil,
2✔
3 
    isNull,
2✔
4 
    isEmpty,
2✔
5 
    isUndefined
2✔
6 
} from "lodash-es";
2✔
7 



2✔






8



import {




2✔






9



    ChainId, ChainIdTypeMap,




2✔





10



    supportedChainIds




2✔





11



} from "@chainid";




2✔





12



import {Networks}      from "@networks";




2✔





13



import type {Token}    from "@token";




2✔





14



import {Tokens}        from "@tokens";




2✔





15



import {SwapPools}     from "@swappools";




2✔





16



import {rejectPromise} from "@common/utils";




2✔






17



import {




2✔






18



    GasOptions,




2✔






19



    populateGasOptions,




2✔






20



    makeTransactionGasOverrides




2✔






21



} from "@common/gasoptions";




2✔





22






2✔





23



import {BridgeConfigV3ContractInstance} from "@entities";




2✔





24






2✔





25



import {




2✔





26



    SwapContract,




2✔





27



    SwapFactory,




2✔





28



    type BridgeConfigV3Contract




2✔





29



} from "@contracts";




2✔





30






2✔






31



import {SwapType, mintBurnSwapTypes} from "@internal/swaptype";




2✔






32



import {rpcProviderForChain} from "@internal/rpcproviders";




2✔





33






2✔





34



import {




2✔





35



    BigNumber,




2✔





36



    type BigNumberish




2✔





37



} from "@ethersproject/bignumber";




2✔





38






2✔






39



import type {Signer} from "@ethersproject/abstract-signer";




2✔






40



import {




2✔






41



    Overrides,




2✔






42



    type ContractTransaction,




2✔






43



    type PopulatedTransaction,




2✔






44



} from "@ethersproject/contracts";




2✔






45






2✔





46






2✔





47



export namespace UnsupportedSwapErrors {





12✔





48



    export enum UnsupportedSwapErrorKind {





12✔





49



        UnsupportedToken,




12✔





50



        UnsupportedTokenNetFrom,




12✔





51



        UnsupportedTokenNetTo,




12✔





52



        NonmatchingSwapTypes,




12✔






53



        UnsupportedMultiJEWELMigration,




12✔





54



    }




12✔





55






12✔






56



    export interface UnsupportedSwapErrorArgs {




12✔






57



        reason:    string;




12✔






58



        errorKind: UnsupportedSwapErrorKind;




12✔





59



    }




12✔





60






12✔






61



    export class UnsupportedSwapError extends Error {





12✔






62



        readonly reason:    string;




12✔






63



        readonly errorKind: UnsupportedSwapErrorKind;




12✔






64






12✔






65



        constructor({reason, errorKind}: UnsupportedSwapErrorArgs) {





12✔






66



            /* c8 ignore next */




2✔






67



            super(reason);





2✔






68






96✔






69



            this.name = this.constructor.name;




96✔






70



            Error.captureStackTrace(this, this.constructor);




96✔






71






96✔






72



            this.reason    = reason;




96✔






73



            this.errorKind = errorKind;




96✔






74



        }




96✔






75



    }




12✔






76






12✔






77



    export const tokenNotSupported = (t: {symbol: string}, netName: string): UnsupportedSwapError => new UnsupportedSwapError({





12✔





78



        reason:    `Token ${t.symbol} not supported on network ${netName}`,




12✔






79



        errorKind:  UnsupportedSwapErrorKind.UnsupportedToken,




12✔





80



    });




12✔





81






12✔






82



    export const tokenNotSupportedNetFrom = (t: {symbol: string}, netName: string): UnsupportedSwapError => new UnsupportedSwapError({





12✔





83



        reason:    `Token ${t.symbol} not supported on 'from' network ${netName}`,




12✔






84



        errorKind:  UnsupportedSwapErrorKind.UnsupportedTokenNetFrom,




12✔





85



    });




12✔





86






12✔






87



    export const tokenNotSupportedNetTo = (t: {symbol: string}, netName: string): UnsupportedSwapError => new UnsupportedSwapError({





12✔





88



        reason:    `Token ${t.symbol} not supported on 'to' network ${netName}`,




12✔






89



        errorKind:  UnsupportedSwapErrorKind.UnsupportedTokenNetTo,




12✔





90



    });




12✔





91






12✔






92



    export const nonMatchingSwapTypes = (): UnsupportedSwapError => new UnsupportedSwapError({





12✔





93



        reason:    "Token swap types don't match",




12✔






94



        errorKind:  UnsupportedSwapErrorKind.NonmatchingSwapTypes,




12✔






95



    });




12✔






96






12✔






97



    export const unsupportedMultiJEWELMigration = (): UnsupportedSwapError => new UnsupportedSwapError({





12✔






98



        reason:    "Migrating multiJEWEL from Avalanche to Harmony is not supported",




12✔






99



        errorKind: UnsupportedSwapErrorKind.UnsupportedMultiJEWELMigration,




12✔





100



    });




12✔





101



}




12✔





102






2✔





103



export namespace TokenSwap {





12✔





104



    const BRIDGE_CONFIG_INSTANCE: BridgeConfigV3Contract = BridgeConfigV3ContractInstance();




12✔





105






12✔





106



    export interface SwapParams {




12✔






107



        chainId:       number;




12✔






108



        tokenFrom:     Token;




12✔






109



        tokenTo:       Token;




12✔






110



        amountIn:      BigNumberish;




12✔






111



        swapData?:     SwapSetup;




12✔





112



    }




12✔





113






12✔





114



    export interface SwapTokensParams extends SwapParams {




12✔






115



        minAmountOut: BigNumberish;




12✔






116



        deadline?:    number;




12✔





117



    }




12✔





118






12✔





119



    export interface BridgeSwapSupportedParams {




12✔






120



        tokenFrom:   Token;




12✔






121



        tokenTo:     Token;




12✔






122



        chainIdFrom: number;




12✔






123



        chainIdTo:   number;




12✔






124



    }




12✔






125






12✔






126



    export interface AddRemoveLiquidityParams {




12✔






127



        chainId:        number;




12✔






128



        lpToken:        SwapPools.SwapPoolToken;




12✔






129



        deadline?:      BigNumber;




12✔






130



        signer?:        Signer;




12✔






131



    }




12✔






132






12✔






133



    export interface AddLiquidityParams extends AddRemoveLiquidityParams {




12✔






134



        amounts:    BigNumber[];




12✔






135



        minToMint?: BigNumber;




12✔






136



    }




12✔






137






12✔






138



    export interface RemoveLiquidityParams extends AddRemoveLiquidityParams {




12✔






139



        amount:      BigNumber;




12✔






140



        minAmounts?: BigNumber[];




12✔






141



    }




12✔






142






12✔






143



    export interface RemoveLiquidityOneParams extends AddRemoveLiquidityParams {




12✔






144



        token:      Token;




12✔






145



        amount:     BigNumber;




12✔






146



        minAmount?: BigNumber;




12✔





147



    }




12✔





148






12✔





149



    export type EstimatedSwapRate = {




12✔





150



        amountOut: BigNumber




12✔





151



    }




12✔





152






12✔





153



    export type IntermediateSwapTokens = {




12✔






154



        intermediateToken?:            Token;




12✔






155



        bridgeConfigIntermediateToken: Token;




12✔





156



    }




12✔





157






12✔





158



    export type SwapSupportedResult = {




12✔






159



        swapSupported:       boolean;




12✔






160



        reasonNotSupported?: UnsupportedSwapErrors.UnsupportedSwapError;




12✔





161



    }




12✔





162






12✔





163



    export type DetailedTokenSwapMap = {




12✔





164



        [chainId: number]: {




12✔






165



            token: Token;




12✔






166



            [chainId: number]: Token[];




12✔






167



        }[];




12✔





168



    }




12✔





169






12✔





170



    interface TokenSwapMap {




12✔






171



        token: Token;




12✔






172



        [chainId: number]: Token[];




12✔





173



    }




12✔





174






12✔






175



    const CHAIN_SWAPS_GAS_LIMITS: ChainIdTypeMap<GasOptions> = {




12✔






176



        [ChainId.AVALANCHE]: {gasLimit: BigNumber.from("165000")}




12✔






177



    }




12✔






178






12✔






179



    const




12✔






180



        ADD_LIQUIDITY_GAS_LIMT:         BigNumber = BigNumber.from("210000"),




12✔






181



        REMOVE_LIQUIDITY_GAS_LIMT:      BigNumber = BigNumber.from("265000"),




12✔






182



        REMOVE_LIQUIDITY_ONE_GAS_LIMIT: BigNumber = BigNumber.from("210000");




12✔






183






12✔






184






12✔





185



    export function swapSupported(args: SwapParams): SwapSupportedResult {





12✔





186



        const {tokenFrom, tokenTo, chainId} = args;




52✔





187



        return checkCanSwap(tokenFrom, tokenTo, chainId)




52✔





188



    }




52✔





189






12✔





190



    export function bridgeSwapSupported(args: BridgeSwapSupportedParams): SwapSupportedResult {





12✔





191



        const {tokenFrom, tokenTo, chainIdFrom, chainIdTo} = args;




468✔





192



        return checkCanSwap(tokenFrom, tokenTo, chainIdFrom, chainIdTo);




468✔





193



    }




468✔





194






12✔






195



    /**




12✔






196



     * calculateAddLiquidity returns the estimated number of LP tokens which a user would receive




12✔






197



     * were they to deposit a given number of liquidity tokens into a pool.




12✔






198



     *




12✔






199



     * @param {AddLiquidityParams} args {@link AddLiquidityParams} object containing arguments.




12✔






200



     * @param {number} args.chainId Chain ID of the Liquidity Pool.




12✔






201



     * @param {SwapPools.SwapPoolToken} args.lpToken LP Token/Pool with which to interact.




12✔






202



     * @param {BigNumber[]} args.amounts Pool-index-relative array of token amounts to add as liquidity to the pool.




12✔






203



     *




12✔






204



     * @return {BigNumber} Amount of LP tokens a user would receive if the deposited liquidity tokens into the pool.




12✔






205



     */




12✔






206



    export async function calculateAddLiquidity(args: AddLiquidityParams): Promise<BigNumber> {





12✔






207



        const swapInstance = await swapContractFromLPSwapAddress(





8✔






208



            args.lpToken.swapAddress,




8✔






209



            args.chainId




8✔






210



        );




8✔






211






8✔






212



        return swapInstance.calculateTokenAmount(




8✔






213



            args.amounts,




8✔






214



            true




8✔






215



        )




8✔






216



    }




8✔






217






12✔






218



    /**




12✔






219



     * calculateRemoveLiquidity returns the estimated number of pooled tokens which a user would receive




12✔






220



     * were they to return some amount of their LP tokens to the Pool.




12✔






221



     *




12✔






222



     * @param {RemoveLiquidityParams} args {@link RemoveLiquidityParams} object containing arguments.




12✔






223



     * @param {number} args.chainId Chain ID of the Liquidity Pool.




12✔






224



     * @param {SwapPools.SwapPoolToken} args.lpToken LP Token/Pool with which to interact.




12✔






225



     * @param {BigNumber} args.amount Amount of LP tokens to exchange for pooled liquidity tokens.




12✔






226



     *




12✔






227



     * @return {BigNumber[]} Pool-index-relative array of token amounts which a user would receive if they remove the passed amount of LP tokens.




12✔






228



     */




12✔






229



    export async function calculateRemoveLiquidity(args: RemoveLiquidityParams): Promise<BigNumber[]> {





12✔






230



        const swapInstance = await swapContractFromLPSwapAddress(





12✔






231



            args.lpToken.swapAddress,




12✔






232



            args.chainId




12✔






233



        );




12✔






234






12✔






235



        return swapInstance.calculateRemoveLiquidity(args.amount)




12✔






236



    }




12✔






237






12✔






238



    /**




12✔






239



     * calculateRemoveLiquidityOneToken returns the estimated number of a single pooled token




12✔






240



     * which would be removed from a Liquidity Pool and transferred to a user




12✔






241



     * were they to return some amount of their LP tokens to the Pool.




12✔






242



     *




12✔






243



     * @param {RemoveLiquidityOneParams} args {@link RemoveLiquidityOneParams} object containing arguments.




12✔






244



     * @param {number} args.chainId Chain ID of the Liquidity Pool.




12✔






245



     * @param {SwapPools.SwapPoolToken} args.lpToken LP Token/Pool with which to interact.




12✔






246



     * @param {Token} args.token Token which will be removed as liquidity from the Liquidity Pool and transferred to the user in exchange for their LP tokens.




12✔






247



     * @param {BigNumber} args.amount Amount of LP tokens to exchange for desired pooled liquidity token.




12✔






248



     *




12✔






249



     * @return {BigNumber} Amount of a single pooled liquidity token which would be removed from the Liquidity Pool and transferred to the user.




12✔






250



     */




12✔






251



    export async function calculateRemoveLiquidityOneToken(args: RemoveLiquidityOneParams): Promise<BigNumber> {





12✔






252



        const swapInstance = await swapContractFromLPSwapAddress(





14✔






253



            args.lpToken.swapAddress,




14✔






254



            args.chainId




14✔






255



        );




14✔






256






14✔






257



        const tokenAddress = args.token.address(args.chainId);




14✔






258



        if (!tokenAddress) { /* c8 ignore start */





2✔






259



            const err = new Error(`no address for token ${args.token.name} found for chain id ${args.chainId}`);




2✔






260



            return rejectPromise(err)




2✔






261



        } /* c8 ignore stop */




2✔






262






14✔






263



        let tokenIndex: number;




14✔






264



        try {




14✔






265



            tokenIndex = await swapInstance.getTokenIndex(tokenAddress);




14✔






266



        } catch (e) {




14✔






267



            return rejectPromise(e)




14✔






268



        }




14✔






269






14✔






270



        return swapInstance.calculateRemoveLiquidityOneToken(args.amount, tokenIndex)





14✔






271



    }




14✔






272






12✔






273



    /**




12✔






274



     * addLiquidity adds a given amount of a user's tokens (such as USDC for Stableswap pools)




12✔






275



     * as liquidity to a Liquidity Pool, providing the user with LP tokens which can be staked.




12✔






276



     *




12✔






277



     * @param {AddLiquidityParams} args {@link AddLiquidityParams} object containing arguments.




12✔






278



     * @param {number} args.chainId Chain ID of the Liquidity Pool.




12✔






279



     * @param {SwapPools.SwapPoolToken} args.lpToken LP Token with which to interact.




12✔






280



     * @param {BigNumber} args.deadline Latest deadline which transaction will be accepted at.




12✔






281



     * @param {Signer} args.signer EthersJS-compatible transaction signer.




12✔






282



     * @param {BigNumber[]} args.amounts Pool-index-relative array of token amounts to add as liquidity to the pool.




12✔






283



     * @param {BigNumber} args.minToMint Amount of LP tokens to mint. Can be calculated with {@link calculateAddLiquidity}.




12✔






284



     *




12✔






285



     * @return {Promise<ContractTransaction>} Executed transaction object.




12✔






286



     */




12✔






287



    export async function addLiquidity(args: AddLiquidityParams): Promise<ContractTransaction> {





12✔






288



        if (isEmpty(args.signer)) { /* c8 ignore start */





2✔






289



            return rejectPromiseMissingField("signer", "AddLiquidityParams")




2✔






290



        } else if (isEmpty(args.deadline)) {





2✔






291



            return rejectPromiseMissingField("deadline", "AddLiquidityParams")




2✔






292



        } else if (isEmpty(args.minToMint)) {





2✔






293



            return rejectPromiseMissingField("minToMint", "AddLiquidityParams")




2✔






294



        } /* c8 ignore stop */




2✔






295






6✔






296



        const swapInstance = await swapContractFromLPSwapAddress(




6✔






297



            args.lpToken.swapAddress,




6✔






298



            args.chainId,




6✔






299



            args.signer




6✔






300



        );




6✔






301






6✔






302



        return swapInstance.addLiquidity(




6✔






303



            args.amounts,




6✔






304



            args.minToMint,




6✔






305



            args.deadline,




6✔






306



            {gasLimit: ADD_LIQUIDITY_GAS_LIMT}




6✔






307



        )




6✔






308



    }




6✔






309






12✔






310



    /**




12✔






311



     * buildAddLiquidityTransaction populates a transaction which adds a given amount of a




12✔






312



     * user's tokens (such as USDC for Stableswap pools) as liquidity to a Liquidity Pool,




12✔






313



     * providing the user with LP tokens which can be staked.




12✔






314



     *




12✔






315



     * @param {AddLiquidityParams} args {@link AddLiquidityParams} object containing arguments.




12✔






316



     * @param {number} args.chainId Chain ID of the Liquidity Pool.




12✔






317



     * @param {SwapPools.SwapPoolToken} args.lpToken LP Token with which to interact.




12✔






318



     * @param {BigNumber} args.deadline Latest deadline which transaction will be accepted at.




12✔






319



     * @param {BigNumber[]} args.amounts Pool-index-relative array of token amounts to add as liquidity to the pool.




12✔






320



     * @param {BigNumber} args.minToMint Amount of LP tokens to mint. Can be calculated with {@link calculateAddLiquidity}.




12✔






321



     *




12✔






322



     * @return {Promise<PopulatedTransaction>} Populated transaction object.




12✔






323



     */




12✔






324



    export async function buildAddLiquidityTransaction(args: AddLiquidityParams): Promise<PopulatedTransaction> {





12✔






325



        if (isEmpty(args.deadline)) { /* c8 ignore start */





2✔






326



            return rejectPromiseMissingField("deadline", "AddLiquidityParams")




2✔






327



        } else if (isEmpty(args.minToMint)) {





2✔






328



            return rejectPromiseMissingField("minToMint", "AddLiquidityParams")




2✔






329



        } /* c8 ignore stop */




2✔






330






6✔






331



        const swapInstance = await swapContractFromLPSwapAddress(args.lpToken.swapAddress, args.chainId);




6✔






332






6✔






333



        return swapInstance.populateTransaction.addLiquidity(




6✔






334



            args.amounts,




6✔






335



            args.minToMint,




6✔






336



            args.deadline




6✔






337



        )




6✔






338



    }




6✔






339






12✔






340



    /**




12✔






341



     * removeLiquidity exchanges a given amount of a user's LP tokens for a given Liquidity Pool for




12✔






342



     * various amounts of pooled liquidity tokens, thereby removing liquidity from the Pool.




12✔






343



     *




12✔






344



     * @param {RemoveLiquidityParams} args {@link RemoveLiquidityParams} object containing arguments.




12✔






345



     * @param {number} args.chainId Chain ID of the Liquidity Pool.




12✔






346



     * @param {SwapPools.SwapPoolToken} args.lpToken LP Token with which to interact.




12✔






347



     * @param {BigNumber} args.deadline Latest deadline which transaction will be accepted at.




12✔






348



     * @param {Signer} args.signer EthersJS-compatible transaction signer.




12✔






349



     * @param {BigNumber} args.amount Amount of LP tokens to exchange for pooled liquidity tokens.




12✔






350



     * @param {BigNumber[]} args.minAmounts Pool-index-relative array of pooled liquidity token amounts to return in exchange for LP tokens. Can be calculated with {@link calculateRemoveLiquidity}.




12✔






351



     *




12✔






352



     * @return {Promise<ContractTransaction>} Executed transaction object.




12✔






353



     */




12✔






354



    export async function removeLiquidity(args: RemoveLiquidityParams): Promise<ContractTransaction> {





12✔






355



        if (isEmpty(args.signer)) { /* c8 ignore start */





2✔






356



            return rejectPromiseMissingField("signer", "RemoveLiquidityParams")




2✔






357



        } else if (isEmpty(args.deadline)) {





2✔






358



            return rejectPromiseMissingField("deadline", "RemoveLiquidityParams")




2✔






359



        } else if (isEmpty(args.minAmounts)) {





2✔






360



            return rejectPromiseMissingField("minAmounts", "RemoveLiquidityParams")




2✔






361



        } /* c8 ignore stop */




2✔






362






8✔






363



        const swapInstance = await swapContractFromLPSwapAddress(




8✔






364



            args.lpToken.swapAddress,




8✔






365



            args.chainId,




8✔






366



            args.signer




8✔






367



        );




8✔






368






8✔






369



        return swapInstance.removeLiquidity(




8✔






370



            args.amount,




8✔






371



            args.minAmounts,




8✔






372



            args.deadline,




8✔






373



            {gasLimit: REMOVE_LIQUIDITY_GAS_LIMT}




8✔






374



        )




8✔






375



    }




8✔






376






12✔






377



    /**




12✔






378



     * buildRemoveLiquidityTransaction populates a transaction which exchanges a given amount of a user's LP tokens for a given Liquidity Pool for




12✔






379



     * various amounts of pooled liquidity tokens, thereby removing liquidity from the Pool.




12✔






380



     *




12✔






381



     * @param {RemoveLiquidityParams} args {@link RemoveLiquidityParams} object containing arguments.




12✔






382



     * @param {number} args.chainId Chain ID of the Liquidity Pool.




12✔






383



     * @param {SwapPools.SwapPoolToken} args.lpToken LP Token with which to interact.




12✔






384



     * @param {BigNumber} args.deadline Latest deadline which transaction will be accepted at.




12✔






385



     * @param {BigNumber} args.amount Amount of LP tokens to exchange for pooled liquidity tokens.




12✔






386



     * @param {BigNumber[]} args.minAmounts Pool-index-relative array of pooled liquidity token amounts to return in exchange for LP tokens. Can be calculated with {@link calculateRemoveLiquidity}.




12✔






387



     *




12✔






388



     * @return {Promise<PopulatedTransaction>} Populated transaction object.




12✔






389



     */




12✔






390



    export async function buildRemoveLiquidityTransaction(args: RemoveLiquidityParams): Promise<PopulatedTransaction> {





12✔






391



        if (isEmpty(args.deadline)) { /* c8 ignore start */





2✔






392



            return rejectPromiseMissingField("deadline", "RemoveLiquidityParams")




2✔






393



        } else if (isEmpty(args.minAmounts)) {





2✔






394



            return rejectPromiseMissingField("minAmounts", "RemoveLiquidityParams")




2✔






395



        } /* c8 ignore stop */




2✔






396






8✔






397



        const swapInstance = await swapContractFromLPSwapAddress(args.lpToken.swapAddress, args.chainId);




8✔






398






8✔






399



        return swapInstance.populateTransaction.removeLiquidity(




8✔






400



            args.amount,




8✔






401



            args.minAmounts,




8✔






402



            args.deadline




8✔






403



        )




8✔






404



    }




8✔






405






12✔






406



    /**




12✔






407



     * removeLiquidityOneToken exchanges a given amount of a user's LP tokens for a given Liquidity Pool for




12✔






408



     * an amount of a single liquidity token in the given Liquidity Pool, removing that amount from available liquidity




12✔






409



     * and transferring it to the user.




12✔






410



     *




12✔






411



     * @param {RemoveLiquidityOneParams} args {@link RemoveLiquidityOneParams} object containing arguments.




12✔






412



     * @param {number} args.chainId Chain ID of the Liquidity Pool.




12✔






413



     * @param {SwapPools.SwapPoolToken} args.lpToken LP Token/Pool with which to interact.




12✔






414



     * @param {BigNumber} args.deadline Latest deadline which transaction will be accepted at.




12✔






415



     * @param {Signer} args.signer EthersJS-compatible transaction signer.




12✔






416



     * @param {Token} args.token Token which will be returned to the user in exchange for their LP tokens.




12✔






417



     * @param {BigNumber} args.amount Amount of LP tokens to exchange for desired pooled liquidity token.




12✔






418



     * @param {BigNumber} args.minAmount Minimum amount of pooled liquidity token to be removed from the Liquidity Pool and transferred to the user.




12✔






419



     *




12✔






420



     * @return {Promise<ContractTransaction>} Executed transaction object.




12✔






421



     */




12✔






422



    export async function removeLiquidityOneToken(args: RemoveLiquidityOneParams): Promise<ContractTransaction> {





12✔






423



        if (isEmpty(args.signer)) { /* c8 ignore start */





2✔






424



            return rejectPromiseMissingField("signer", "RemoveLiquidityOneParams")




2✔






425



        } else if (isEmpty(args.deadline)) {





2✔






426



            return rejectPromiseMissingField("deadline", "RemoveLiquidityOneParams")




2✔






427



        } else if (isEmpty(args.minAmount)) {





2✔






428



            return rejectPromiseMissingField("minAmount", "RemoveLiquidityOneParams")




2✔






429



        } /* c8 ignore stop */




2✔






430






10✔






431



        const swapInstance = await swapContractFromLPSwapAddress(




10✔






432



            args.lpToken.swapAddress,




10✔






433



            args.chainId,




10✔






434



            args.signer




10✔






435



        );




10✔






436






10✔






437



        const tokenAddress = args.token.address(args.chainId);




10✔






438



        if (!tokenAddress) { /* c8 ignore start */





2✔






439



            const err = new Error(`no address for token ${args.token.name} found for chain id ${args.chainId}`);




2✔






440



            return rejectPromise(err)




2✔






441



        } /* c8 ignore stop */




2✔






442






10✔






443



        let tokenIndex: number;




10✔






444



        try {




10✔






445



            tokenIndex = await swapInstance.getTokenIndex(tokenAddress);




10✔






446



        } catch (e) {




10✔






447



            return rejectPromise(e)




10✔






448



        }




10✔






449






10✔






450



        return swapInstance.removeLiquidityOneToken(





10✔






451



            args.amount,




10✔






452



            tokenIndex,




10✔






453



            args.minAmount,




10✔






454



            args.deadline,




10✔






455



            {gasLimit: REMOVE_LIQUIDITY_ONE_GAS_LIMIT}




10✔






456



        )




10✔






457



    }




10✔






458






12✔






459



    /**




12✔






460



     * buildRemoveLiquidityOneTokenTransaction populates a transaction exchanges a given amount of a user's LP tokens for a given Liquidity Pool for




12✔






461



     * an amount of a single liquidity token in the given Liquidity Pool, removing that amount from available liquidity




12✔






462



     * and transferring it to the user.




12✔






463



     *




12✔






464



     * @param {RemoveLiquidityOneParams} args {@link RemoveLiquidityOneParams} object containing arguments.




12✔






465



     * @param {number} args.chainId Chain ID of the Liquidity Pool.




12✔






466



     * @param {SwapPools.SwapPoolToken} args.lpToken LP Token/Pool with which to interact.




12✔






467



     * @param {BigNumber} args.deadline Latest deadline which transaction will be accepted at.




12✔






468



     * @param {Token} args.token Token which will be returned to the user in exchange for their LP tokens.




12✔






469



     * @param {BigNumber} args.amount Amount of LP tokens to exchange for desired pooled liquidity token.




12✔






470



     * @param {BigNumber} args.minAmount Minimum amount of pooled liquidity token to be removed from the Liquidity Pool and transferred to the user.




12✔






471



     *




12✔






472



     * @return {Promise<PopulatedTransaction>} Populated transaction object.




12✔






473



     */




12✔






474



    export async function buildRemoveLiquidityOneTokenTransaction(args: RemoveLiquidityOneParams): Promise<PopulatedTransaction> {





12✔






475



        if (isEmpty(args.deadline)) { /* c8 ignore start */





2✔






476



            return rejectPromiseMissingField("deadline", "RemoveLiquidityOneParams")




2✔






477



        } else if (isEmpty(args.minAmount)) {





2✔






478



            return rejectPromiseMissingField("minAmount", "RemoveLiquidityOneParams")




2✔






479



        } /* c8 ignore stop */




2✔






480






10✔






481



        const swapInstance = await swapContractFromLPSwapAddress(args.lpToken.swapAddress, args.chainId);




10✔






482






10✔






483



        const tokenAddress = args.token.address(args.chainId);




10✔






484



        if (!tokenAddress) { /* c8 ignore start */





2✔






485



            const err = new Error(`no address for token ${args.token.name} found for chain id ${args.chainId}`);




2✔






486



            return rejectPromise(err)




2✔






487



        } /* c8 ignore stop */




2✔






488






10✔






489



        let tokenIndex: number;




10✔






490



        try {




10✔






491



            tokenIndex = await swapInstance.getTokenIndex(tokenAddress);




10✔






492



        } catch (e) {




10✔






493



            return rejectPromise(e)




10✔






494



        }




10✔






495






10✔






496



        return swapInstance.populateTransaction.removeLiquidityOneToken(





10✔






497



            args.amount,




10✔






498



            tokenIndex,




10✔






499



            args.minAmount,




10✔






500



            args.deadline




10✔






501



        )




10✔






502



    }




10✔






503






12✔






504






12✔






505



    function rejectPromiseMissingField(fieldName: string, paramsType: string): Promise<never> {




12✔






NEW


506



        const err = new Error(`${fieldName} must be passed in ${paramsType}`);




×








NEW


507



        return rejectPromise(err)




×








NEW


508



    }




×








509






12✔





510



    export async function calculateSwapRate(args: SwapParams): Promise<EstimatedSwapRate> {





12✔





511



        const {swapSupported: canSwap, reasonNotSupported} = swapSupported(args);




26✔





512



        if (!canSwap) {





26✔





513



            return rejectPromise(reasonNotSupported)




8✔





514



        }




8✔





515






26✔





516



        return resolveSwapData(args)




26✔





517



            .then(({swapInstance, tokenIndexFrom, tokenIndexTo}) =>





26✔






518



                swapInstance




14✔






519



                    .calculateSwap(tokenIndexFrom, tokenIndexTo, args.amountIn)




26✔





520



                    .then((res): EstimatedSwapRate => ({amountOut: res}))





26✔





521



            )




26✔





522



            .catch(rejectPromise)




26✔





523



    }




26✔





524






12✔






525



    interface SwapTokensFnParams extends SwapTokensParams {




12✔






526



        signer: Signer




12✔






527



    }




12✔






528






12✔






529



    export async function swapTokens(





12✔






530



        args:        SwapTokensFnParams,




8✔






531



        gasOptions?: GasOptions




8✔






532



    ): Promise<ContractTransaction> {




8✔






533



        const {swapSupported: canSwap, reasonNotSupported} = swapSupported(args);




8✔






534



        if (!canSwap) {




8✔






535



            return rejectPromise(reasonNotSupported)




8✔






536



        }




8✔






537






8✔






538



        return resolveSwapData(args)




8✔






539



            .then(swapSetup => {





8✔






540



                let {deadline} = args;




2✔






541



                /* c8 ignore next */




2✔






542



                deadline = deadline ?? Math.round((new Date().getTime() / 1000) + 60 * 10);





2✔






543






2✔






544



                return swapContract(args.tokenFrom, args.chainId, args.signer)




2✔






545



                    .then(swapInstance => {





2✔






546



                        return swapInstance.swap(




2✔






547



                            swapSetup.tokenIndexFrom,




2✔






548



                            swapSetup.tokenIndexTo,




2✔






549



                            args.amountIn,




2✔






550



                            args.minAmountOut,




2✔






551



                            deadline,




2✔






552



                            buildSwapTokensOverrides(args, gasOptions)




2✔






553



                        )




2✔






554



                    })




2✔






555



            })




8✔






556



            .catch(rejectPromise)




8✔






557



    }




8✔






558






12✔






559



    export async function buildSwapTokensTransaction(





12✔






560



        args:        SwapTokensParams,




18✔






561



        gasOptions?: GasOptions




18✔






562



    ): Promise<PopulatedTransaction> {




18✔





563



        const {swapSupported: canSwap, reasonNotSupported} = swapSupported(args);




18✔





564



        if (!canSwap) {





18✔





565



            return rejectPromise(reasonNotSupported)




4✔





566



        }




4✔





567






18✔





568



        return resolveSwapData(args)




18✔






569



            .then(swapData => populateSwapTransaction(args, swapData, gasOptions))





18✔





570



            .catch(rejectPromise)




18✔





571



    }




18✔





572






12✔





573



    async function resolveSwapData(args: SwapTokensParams|SwapParams): Promise<SwapSetup> {





12✔





574



        const {swapData} = args;




36✔





575



        return Promise.resolve(swapData ? swapData : await swapSetup(args.tokenFrom, args.tokenTo, args.chainId))





36✔





576



    }




36✔





577






12✔






578



    function populateSwapTransaction(





12✔






579



        args:        SwapTokensParams,




12✔






580



        swapSetup:   SwapSetup,




12✔






581



        gasOptions?: GasOptions




12✔






582



    ): Promise<PopulatedTransaction> {




12✔






583



        let {deadline} = args;




12✔






584



        const {swapInstance} = swapSetup;




12✔






585



        /* c8 ignore next */




2✔






586



        deadline = deadline ?? Math.round((new Date().getTime() / 1000) + 60 * 10);





2✔






587






12✔






588



        let txnProm = swapInstance.populateTransaction.swap(




12✔






589



            swapSetup.tokenIndexFrom,




12✔






590



            swapSetup.tokenIndexTo,




12✔






591



            args.amountIn,




12✔






592



            args.minAmountOut,




12✔






593



            deadline




12✔






594



        );




12✔






595






12✔






596



        const gasLimit = CHAIN_SWAPS_GAS_LIMITS[args.chainId]?.gasLimit;





12✔






597



        /* c8 ignore next */




2✔






598



        let gasOpts: GasOptions = gasOptions ? gasOptions : {};





2✔






599



        if (gasLimit) {





12✔






600



            gasOpts.gasLimit = gasLimit;




2✔






601



        }




2✔






602






12✔






603



        return txnProm.then(txn => populateGasOptions(txn, gasOpts, args.chainId))





12✔






604



    }




12✔





605






12✔






606



    /* c8 ignore start */




2✔






607



    function buildSwapTokensOverrides(





2✔






608



        args:         SwapTokensParams,




2✔






609



        gasOptions?:  GasOptions




2✔






610



    ): Overrides | null {




2✔






611



        const {chainId} = args;




2✔





612






2✔






613



        const overrides: Overrides = {




2✔






614



            ...makeTransactionGasOverrides(gasOptions, chainId, true),




2✔






615



            ...makeTransactionGasOverrides(CHAIN_SWAPS_GAS_LIMITS[chainId], chainId)




2✔






616



        };




2✔





617






2✔






618



        if (Object.keys(overrides).length === 0) {




2✔






619



            return null




2✔





620



        }




2✔






621







2✔






622



        return overrides




2✔





623



    }




2✔






624



    /* c8 ignore stop */




2✔





625






12✔






626



    export function intermediateTokens(chainId: number, token: Token, otherChainId?: number): IntermediateSwapTokens {





12✔





627



        if (mintBurnSwapTypes.includes(token.swapType)) {





636✔






628



            switch (token.swapType) {




160✔






629



                case SwapType.JEWEL:





160✔






630



                    let bridgeConfigIntermediate: Token = chainId === ChainId.HARMONY




42✔






631



                        ? Tokens.SYN_JEWEL





42✔






632



                        : Tokens.JEWEL;





42✔






633






42✔






634



                    return {intermediateToken: Tokens.JEWEL, bridgeConfigIntermediateToken: bridgeConfigIntermediate}




42✔






635



                // case SwapType.AVAX:




160✔






636



                //     break;




160✔






637



                default:





160✔






638



                    return {intermediateToken: token, bridgeConfigIntermediateToken: token}




118✔






639



            }




160✔





640



        }




160✔





641







476✔





642



        let




476✔





643



            intermediateToken:             Token,




476✔





644



            bridgeConfigIntermediateToken: Token;




476✔





645






476✔





646



        switch (token.swapType) {




476✔





647



            case SwapType.SYN:





636✔





648



                intermediateToken = Tokens.SYN;




8✔





649



                break;




8✔





650



            case SwapType.FRAX:





636✔





651



                bridgeConfigIntermediateToken = chainId === ChainId.ETH ? Tokens.FRAX : Tokens.SYN_FRAX;





14✔





652



                break;




14✔





653



            case SwapType.ETH:





636✔





654



                intermediateToken             = Tokens.NETH;




152✔





655



                bridgeConfigIntermediateToken = chainId === ChainId.ETH ? Tokens.WETH : Tokens.NETH;





152✔





656



                break;




152✔





657



            case SwapType.AVAX:





636✔






658



                const




54✔






659



                    fromAvax    = chainId === ChainId.AVALANCHE,




54✔






660



                    fromHarmony = chainId === ChainId.HARMONY;




54✔






661






54✔






662



                if (!isNil(otherChainId)) {





54✔






663



                    if (fromAvax && otherChainId === ChainId.HARMONY) {





52✔






664



                        intermediateToken             = Tokens.WAVAX;




6✔






665



                        bridgeConfigIntermediateToken = Tokens.SYN_AVAX;




6✔






666



                        break;




6✔






667



                    } else if (fromHarmony && otherChainId === ChainId.AVALANCHE) {





52✔






668



                        intermediateToken             = Tokens.WAVAX;




16✔






669



                        bridgeConfigIntermediateToken = Tokens.WAVAX;




16✔






670



                        break;




16✔






671



                    } else {





42✔






672



                        intermediateToken             = Tokens.WAVAX;




30✔






673



                        bridgeConfigIntermediateToken = chainId === ChainId.HARMONY ? Tokens.SYN_AVAX : Tokens.WAVAX;





30✔






674



                        break;




30✔






675



                    }




30✔






676



                }




52✔






677







2✔






678



                /* c8 ignore next 3 */




2✔






679



                intermediateToken             = Tokens.WAVAX;




2✔






680



                bridgeConfigIntermediateToken = chainId === ChainId.HARMONY ? Tokens.SYN_AVAX : Tokens.WAVAX;





2✔





681



                break;




2✔





682



            case SwapType.MOVR:





636✔





683



                intermediateToken = Tokens.WMOVR;




8✔





684



                break;




8✔






685



            case SwapType.DFKTEARS:





636✔






686



                intermediateToken = Tokens.DFKTEARS;




8✔






687



                break;




8✔





688



            default:





636✔





689



                intermediateToken = Tokens.NUSD;




232✔





690



                break;




232✔





691



        }




636✔





692







476✔





693



        bridgeConfigIntermediateToken = bridgeConfigIntermediateToken ?? intermediateToken;





636✔





694






636✔





695



        return {intermediateToken, bridgeConfigIntermediateToken}




636✔





696



    }




636✔





697






12✔





698



    export function detailedTokenSwapMap(): DetailedTokenSwapMap {





12✔





699



        let res: DetailedTokenSwapMap = {};




2✔





700






2✔





701



        const allChainIds = supportedChainIds();




2✔





702






2✔





703



        for (const c1 of allChainIds) {





2✔





704



            let n1: Networks.Network = Networks.fromChainId(c1);




30✔





705



            let networkTokens: Token[] = n1.tokens;




30✔





706






30✔






707



            const chainGasToken = Tokens.gasTokenForChain(c1);




30✔






708






30✔





709



            res[c1] = networkTokens.map((t: Token) => {





30✔





710



                let swapType = t.swapType;




300✔





711






300✔






712



                if (!isNull(chainGasToken)) {





300✔






713



                    const gasWrapper = Tokens.gasTokenWrapper(chainGasToken);




150✔






714



                    if (gasWrapper.isEqual(t)) {





150✔






715



                        return




8✔






716



                    }




8✔






717



                }




150✔






718







292✔





719



                let tokSwapMap: TokenSwapMap = {




292✔





720



                    token: t,




292✔





721



                }




292✔





722






292✔





723



                for (const c2 of allChainIds) {





292✔





724



                    if (c1 === c2) continue




4,380✔





725







4,088✔






726



                    if (c1 === ChainId.AVALANCHE && t.isEqual(Tokens.MULTIJEWEL) && c2 !== ChainId.DFK) {





4,380✔






727



                        continue




26✔






728



                    }




26✔






729







4,062✔






730



                    const chain2GasToken = Tokens.gasTokenForChain(c2);




4,062✔





731



                    let outToks: Token[] = SwapPools.tokensForChainBySwapGroup(c2, swapType);




4,062✔





732



                    if (outToks.length === 0) continue




4,062✔





733






4,380✔






734



                    outToks = outToks.filter((t2: Token) => {





4,380✔






735



                        if (!isNull(chain2GasToken)) {





4,538✔






736



                            return !Tokens.gasTokenWrapper(chain2GasToken).isEqual(t2)




2,108✔






737



                        }




2,108✔






738







2,430✔






739



                        return true




2,430✔






740



                    })




4,380✔






741






4,380✔





742



                    tokSwapMap[c2] = outToks;




4,380✔





743



                }




4,380✔





744







292✔





745



                return tokSwapMap




292✔






746



            }).filter(t => !isUndefined(t))





30✔





747



        }




30✔





748






2✔





749



        return res




2✔





750



    }




2✔





751






12✔





752



    interface SwapSetup {




12✔





753



        swapInstance:   SwapContract,




12✔





754



        tokenIndexFrom: number,




12✔





755



        tokenIndexTo:   number,




12✔





756



    }




12✔





757






12✔






758



    export async function swapContract(token: Token, chainId: number, signer?: Signer): Promise<SwapContract> {





12✔






759



        const provider = signer ? signer : rpcProviderForChain(chainId);





56✔






760






56✔





761



        const lpToken = _intermediateToken(token, chainId);




56✔





762






56✔






763



        // temp fix until BridgeConfig is updated




56✔






764



        if (lpToken.isEqual(Tokens.NUSD) && chainId === ChainId.CRONOS) {





56✔






765



            return swapContractFromLPSwapAddress(




12✔






766



                SwapPools.stableswapPoolForNetwork(chainId).swapAddress,




12✔






767



                chainId,




12✔






768



                signer




12✔






769



            )




12✔






770



        }




12✔






771






56✔





772



        return BRIDGE_CONFIG_INSTANCE.getPoolConfig(lpToken.address(chainId), chainId)




56✔






773



            .then(({poolAddress}) => SwapFactory.connect(poolAddress, provider))





56✔





774



            .catch(rejectPromise)




56✔





775



    }




56✔





776






12✔






777



    async function swapContractFromLPSwapAddress(lpSwapAddress: string, chainId: number, signer?: Signer): Promise<SwapContract> {





12✔






778



        const provider = signer ? signer : rpcProviderForChain(chainId);





94✔






779






94✔






780



        return SwapFactory.connect(lpSwapAddress, provider)




94✔






781



    }




94✔






782






12✔





783



    export async function swapSetup(tokenFrom: Token, tokenTo: Token, chainId: number): Promise<SwapSetup> {





12✔





784



        const swapInstance = await swapContract(tokenFrom, chainId);





54✔





785






54✔





786



        return Promise.all([




54✔





787



                swapInstance.getTokenIndex(tokenFrom.address(chainId)),




54✔





788



                swapInstance.getTokenIndex(tokenTo.address(chainId)),




54✔





789



        ]).then(([tokenIndexFrom, tokenIndexTo]) => ({





54✔





790



            swapInstance,




54✔





791



            tokenIndexFrom,




54✔





792



            tokenIndexTo,




54✔





793



        })).catch(rejectPromise)




54✔





794



    }




54✔





795






12✔





796



    function _intermediateToken(token: Token, chainId: number): Token {





12✔





797



        const {intermediateToken, bridgeConfigIntermediateToken} = intermediateTokens(chainId, token);




56✔






798



        /* c8 ignore next */




2✔





799



        return intermediateToken ?? bridgeConfigIntermediateToken





2✔





800



    }




56✔





801






12✔





802



    function checkCanSwap(tokenFrom: Token, tokenTo: Token, chainFrom: number, chainTo?: number): SwapSupportedResult {





12✔





803



        const




520✔





804



            tokensCanSwap   = checkTokensCanSwap(tokenFrom, tokenTo),




520✔





805



            tokensSupported = checkTokensSupported(tokenFrom, tokenTo, chainFrom, chainTo);




520✔





806






520✔





807



        if (!tokensSupported.swapSupported) {





520✔





808



            return tokensSupported




54✔





809



        } else if (!tokensCanSwap.swapSupported) {





520✔





810



            return tokensCanSwap




40✔





811



        }




40✔





812







426✔





813



        return {swapSupported: true}




426✔





814



    }




426✔





815






12✔





816



    function checkTokensCanSwap(tokenFrom: Token, tokenTo: Token): SwapSupportedResult {





12✔





817



        let




520✔





818



            swapSupported: boolean = true,




520✔





819



            reasonNotSupported: UnsupportedSwapErrors.UnsupportedSwapError;




520✔





820






520✔





821



        if (tokenFrom.swapType !== tokenTo.swapType) {





520✔





822



            swapSupported = false;




42✔





823



            reasonNotSupported = UnsupportedSwapErrors.nonMatchingSwapTypes();




42✔





824



        }




42✔





825






520✔





826



        return {swapSupported, reasonNotSupported}




520✔





827



    }




520✔





828






12✔





829



    function checkTokensSupported(





12✔





830



        tokenFrom:   Token,




520✔





831



        tokenTo:     Token,




520✔





832



        chainIdFrom: number,




520✔





833



        chainIdTo?:  number




520✔





834



    ): SwapSupportedResult {




520✔






835



        const hasDestChain: boolean = !isUndefined(chainIdTo);




520✔





836






520✔





837



        const




520✔






838



            unsupportedFromErr = hasDestChain ? UnsupportedSwapErrors.tokenNotSupportedNetFrom : UnsupportedSwapErrors.tokenNotSupported,





520✔






839



            unsupportedToErr   = hasDestChain ? UnsupportedSwapErrors.tokenNotSupportedNetTo   : UnsupportedSwapErrors.tokenNotSupported;





520✔





840






520✔





841



        const




520✔





842



            netFrom = Networks.fromChainId(chainIdFrom),




520✔






843



            netTo   = hasDestChain ? Networks.fromChainId(chainIdTo) : netFrom;





520✔






844






520✔






845



        if (hasDestChain) {





520✔






846



            if (tokenFrom.isEqual(Tokens.MULTIJEWEL) && chainIdTo !== ChainId.DFK) {





468✔






847



                return {swapSupported: false, reasonNotSupported: UnsupportedSwapErrors.unsupportedMultiJEWELMigration()}




2✔






848



            }




2✔






849



        }




468✔





850







518✔





851



        let




518✔





852



            swapSupported: boolean = true,




518✔





853



            reasonNotSupported: UnsupportedSwapErrors.UnsupportedSwapError;




518✔





854






518✔





855



        if (!netFrom.supportsToken(tokenFrom)) {





520✔





856



            swapSupported = false;




20✔





857



            reasonNotSupported = unsupportedFromErr(tokenFrom, netFrom.name);




20✔





858



        } else if (!netTo.supportsToken(tokenTo)) {





520✔





859



            swapSupported = false;




32✔





860



            reasonNotSupported = unsupportedToErr(tokenTo, netTo.name);




32✔





861



        }




32✔





862







518✔





863



        return {swapSupported, reasonNotSupported}




518✔





864



    }




518✔





865



}



12✔



















    

  • 

    •