synapsecns / sdk / 2170211324

import {ChainId, type ChainIdTypeMap} from "@chainid";

import {Networks} from "@networks";

import {

    type Token,

    instanceOfToken

} from "@token";

import {Tokens}    from "@tokens";

import {TokenSwap} from "@tokenswap";

import {

    rejectPromise,

    executePopulatedTransaction

} from "@common/utils";

import {SynapseContracts}    from "@synapsecontracts";

import type {

    SynapseBridgeContract,

    L1BridgeZapContract,

    L2BridgeZapContract,

    GenericZapBridgeContract

} from "@contracts";

// import {type ID, SwapType, rpcProviderForChain, tokenSwitch} from "@internal/index";

import type {ID} from "@internal/types";

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

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

import {tokenSwitch} from "@internal/utils";

import * as SynapseEntities from "@entities";

import {BridgeConfig}               from "./bridgeconfig";

import {GasUtils}                   from "./gasutils";

import {BridgeUtils}                from "./bridgeutils";

import {ERC20, MAX_APPROVAL_AMOUNT} from "./erc20";

import {id as makeKappa} from "@ethersproject/hash";

import {Zero}            from "@ethersproject/constants";

import {formatUnits}     from "@ethersproject/units";

import {BigNumber}       from "@ethersproject/bignumber";

import type {BigNumberish} from "@ethersproject/bignumber";

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

import type {Provider}     from "@ethersproject/providers";

import type {

    ContractTransaction,

    PopulatedTransaction,

} from "@ethersproject/contracts";

/**

 * Bridge provides a wrapper around common Synapse Bridge interactions, such as output estimation, checking supported swaps/bridges,

 * and most importantly, executing Bridge transactions.

 */

export namespace Bridge {

    export type CanBridgeResult = {

        canBridge:     boolean;

        reasonUnable?: string;

        amount?:       BigNumber;

    }

    type NeedsTokenApproveResult = {

        needsApproval:     boolean;

        currentAllowance?: BigNumber;

    }

    export type BridgeOutputEstimate = {

        amountToReceive: BigNumber;

        bridgeFee:       BigNumber;

    }

    /**

     * @param {Token} tokenFrom {@link Token} user will send to the bridge on the source chain

     * @param {Token} tokenTo {@link Token} user will receive from the bridge on the destination chain

     * @param {number} chainIdTo Chain ID of the destination chain

     * @param {BigNumber} amountFrom not necessarily used by this interface, and overriden in BridgeParamsWithAmounts.

     */

    export interface BridgeParams {

        tokenFrom:   Token;

        tokenTo:     Token;

        chainIdTo:   number;

        amountFrom?: BigNumber;

    }

    /**

     * @param {BigNumber} amountFrom Amount of tokenFrom (denoted in wei) that the user will send to the bridge on the source chain.

     * @param {BigNumber} amountTo Amount of tokenTo (denoted in wei) that the user will receive from the bridge on the destination chain.

     * @param {string} addressTo Optional, user can provide an address other than the one retrieved from signer to receive tokens

     * on the destination chain.

     */

    export interface BridgeTransactionParams extends BridgeParams {

        amountFrom: BigNumber;

        amountTo:   BigNumber;

        addressTo?: string;

    }

    type EasyArgsCheck = {

        isEasy:   boolean;

        castArgs: BridgeUtils.BridgeTxParams;

        txn?:     Promise<PopulatedTransaction>;

    }

    type BridgeTokenArgs = {

        fromChainTokens: Token[];

        toChainTokens:   Token[];

        tokenFrom:       Token;

        tokenTo:         Token;

        tokenIndexFrom:  number;

        tokenIndexTo:    number;

    }

    interface CheckCanBridgeParams {

        address?: string;

        signer?:  Signer;

        token:    Token;

        amount:   BigNumberish;

    }

    interface CanBridgeParams extends CheckCanBridgeParams {

        address: string;

    }

    /**

     * SynapseBridge is a wrapper around any Synapse Bridge contract which exists on chains supported by the Synapse Protocol.

     */

    export class SynapseBridge {

        protected network: Networks.Network;

        protected chainId: number;

        protected provider: Provider;

        private readonly bridgeAddress:    string;

        private readonly zapBridgeAddress: string;

        private readonly bridgeInstance: SynapseBridgeContract;

        private readonly zapBridge:      GenericZapBridgeContract;

        private readonly l1BridgeZapEth: L1BridgeZapContract = BridgeUtils.newL1BridgeZap(ChainId.ETH);

        private readonly bridgeConfig:   BridgeConfig = new BridgeConfig();

        private readonly isL2ETHChain: boolean;

        readonly requiredConfirmations: number;

        constructor(args: {

            network: Networks.Network | number,

            provider?: Provider

        }) {

            let {network, provider} = args;

            this.network = network instanceof Networks.Network ? network : Networks.fromChainId(network);

            this.chainId = this.network.chainId;

            this.provider = provider ?? rpcProviderForChain(this.chainId);

            this.requiredConfirmations = getRequiredConfirmationsForBridge(this.network);

            this.isL2ETHChain = BridgeUtils.isL2ETHChain(this.chainId);

            const contractAddrs = SynapseContracts.contractsForChainId(this.chainId);

            this.bridgeAddress    = contractAddrs.bridgeAddress;

            this.zapBridgeAddress = contractAddrs.bridgeZapAddress;

            this.bridgeInstance = SynapseEntities.SynapseBridgeContractInstance(BridgeUtils.entityParams(this.chainId));

            if (this.zapBridgeAddress && this.zapBridgeAddress !== "") {

                this.zapBridge = BridgeUtils.newBridgeZap(this.chainId);

            }

        }

        private get l2BridgeZap(): L2BridgeZapContract {

            return this.zapBridge as L2BridgeZapContract

        }

        bridgeVersion(): Promise<BigNumber> {

            return this.bridgeInstance.bridgeVersion()

        }

        WETH_ADDRESS(): Promise<string> {

            return this.bridgeInstance.WETH_ADDRESS()

        }

        kappaExists(kappa: string): Promise<boolean> {

            return this.bridgeInstance.kappaExists(kappa)

        }

        /**

         * Returns whether a swap/bridge from this Bridge's chain to another chain between two tokens

         * is supported.

         * @param {Token} args.tokenFrom {@link Token} user will send to the bridge

         * @param {Token} args.tokenTo {@link Token} user will receive from the bridge on the destination chain

         * @param {number} args.chainIdTo Chain ID of the destination chain

         * @return boolean value denoting whether the input params constitute a valid swap/bridge, along with a

         * string value denoting the reason for an unsupported swap, if applicable.

         */

        swapSupported(args: {

            tokenFrom: Token,

            tokenTo:   Token

            chainIdTo: number,

        }): [boolean, string] {

            const {swapSupported, reasonNotSupported} = bridgeSwapSupported({...args, chainIdFrom: this.chainId});

            return [swapSupported, reasonNotSupported?.reason || ""]

        }

        /**

         * Returns the estimated output of a given token on the destination chain were a user to send

         * some amount of another given token on the source chain.

         * @param {BridgeParams} args Parameters for the output estimation.

         * @return {Promise<BridgeOutputEstimate>} Object containing the estimated output of args.tokenTo, as well

         * as the estimated fee to be taken by the bridge. Note that the estimated output already accounts for the

         * bridge fee, so the bridge fee is entirely for user-facing purposes. Do not use it for calculations.

         */

        async estimateBridgeTokenOutput(args: BridgeParams): Promise<BridgeOutputEstimate> {

            return this.checkSwapSupported(args)

                .then(() => this.calculateBridgeRate(args))

                .catch(rejectPromise)

        }

        /**

         * Returns a populated transaction for initiating a token bridge between this Bridge (the source chain) and the bridge contract on the destination chain.

         * Note that this function **does not** send a signed transaction.

         * @param {BridgeTransactionParams} args Parameters for the bridge transaction

         * @return {Promise<PopulatedTransaction>} Populated transaction instance which can be sent via ones choice

         * of web3/ethers/etc.

         */

        async buildBridgeTokenTransaction(args: BridgeTransactionParams): Promise<PopulatedTransaction> {

            const

                {addressTo} = args,

                tokenArgs = this.makeBridgeTokenArgs(args),

                {tokenFrom, tokenTo} = tokenArgs;

            if ((!addressTo) || addressTo === "") {

                return rejectPromise(

                    new Error("BridgeTransactionParams.addressTo cannot be empty string or undefined")

                )

            }

            args = {...args, tokenFrom, tokenTo};

            let newTxn: Promise<PopulatedTransaction> = this.chainId === ChainId.ETH

                ? this.buildETHMainnetBridgeTxn(args, tokenArgs)

                : this.buildL2BridgeTxn(args, tokenArgs);

            return newTxn

                .then(txn =>

                    GasUtils.populateGasParams(this.chainId, txn, "bridge")

                )

        }

        /**

         * Starts the Bridge process between this Bridge (the source chain) and the bridge contract on the destination chain.

         * Note that this function **does** send a signed transaction.

         * @param {BridgeTransactionParams} args Parameters for the bridge transaction.

         * @param {Signer} signer Some instance which implements the Ethersjs {@link Signer} interface.

         * @param {boolean} callStatic (Optional, default: false) if true, uses provider.callStatic instead of actually sending the signed transaction.

         * @return {Promise<ContractTransaction>}

         */

        async executeBridgeTokenTransaction(

            args:       BridgeTransactionParams,

            signer:     Signer,

            callStatic: boolean=false

        ): Promise<ContractTransaction> {

            try {

                await this.checkSwapSupported(args);

            } catch (e) { /* c8 ignore start */

                return rejectPromise(e);

            } /* c8 ignore stop */

            const {tokenFrom, amountFrom, addressTo} = args;

            const signerAddress = await signer.getAddress()

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

                args.addressTo = signerAddress;

            } /* c8 ignore stop */

            const checkArgs = {signer, token: tokenFrom, amount: amountFrom};

            return this.checkCanBridge(checkArgs)

                .then(canBridgeRes => {

                    const {canBridge, reasonUnable} = canBridgeRes;

                    if (!canBridge) {

                        return rejectPromise(reasonUnable)

                    }

                    return this.buildBridgeTokenTransaction(args)

                        .then(txn => executePopulatedTransaction(txn, signer))

                })

                .catch(rejectPromise)

        }

        /**

         * Builds an ethers PopulatedTransaction instance for an ERC20 Approve call,

         * approving some amount of a given token to be spent by the Synapse Bridge on its chain.

         * The returned PopulatedTransaction must then be passed to the user via Web3 or some other

         * framework so they can ultimately send the transaction.

         * Should ALWAYS be called before performing any bridge transactions to ensure they don't fail.

         * @param {Object} args

         * @param {Token|string} args.token {@link Token} instance or valid on-chain address of the token the user will be sending

         * to the bridge on the source chain.

         * @param {BigNumberish} args.amount Optional, a specific amount of args.token to approve. By default, this function

         * builds an Approve call using an "infinite" approval amount.

         * @return {Promise<PopulatedTransaction>} Populated transaction instance which can be sent via ones choice

         * of web3/ethers/etc.

         */

        async buildApproveTransaction(args: {

            token:   Token | string,

            amount?: BigNumberish

        }): Promise<PopulatedTransaction> {

            const [approveArgs, tokenAddress] = this.buildERC20ApproveArgs(args);

            return ERC20.buildApproveTransaction(approveArgs, {tokenAddress, chainId: this.chainId})

        }

        /**

         * Builds and executes an ERC20 Approve call,

         * approving some amount of a given token to be spent by the Synapse Bridge on its chain.

         * The returned PopulatedTransaction must then be passed to the user via Web3 or some other

         * framework so they can ultimately send the transaction.

         * Should ALWAYS be called before performing any bridge transactions to ensure they don't fail.

         * @param {Object} args

         * @param {Token|string} args.token {@link Token} instance or valid on-chain address of the token the user will be sending

         * to the bridge on the source chain.

         * @param {BigNumberish} args.amount Optional, a specific amount of args.token to approve. By default, this function

         * @param {Signer} signer Valid ethers Signer instance for building a fully and properly populated

         * transaction.

         */

        async executeApproveTransaction(

            args:       {token: Token | string, amount?: BigNumberish},

            signer:     Signer,

        ): Promise<ContractTransaction> {

            const

                [approveArgs, tokenAddress] = this.buildERC20ApproveArgs(args),

                tokenParams = {tokenAddress, chainId: this.chainId};

            return ERC20.approve(approveArgs, tokenParams, signer)

        }

        async getAllowanceForAddress(args: {

            address: string,

            token:   Token,

        }): Promise<BigNumber> {

            let { address, token } = args;

            let tokenAddress = token.address(this.chainId);

            return ERC20.allowanceOf(address, this.zapBridgeAddress, {tokenAddress, chainId: this.chainId})

        }

        private async resolveApproveFunc(

            approveRes:    NeedsTokenApproveResult,

            hasBalanceRes: Promise<CanBridgeResult>,

            token:         Token

        ): Promise<CanBridgeResult> {

            const {needsApproval, currentAllowance} = approveRes;

            let allowanceEth: string;

            if (currentAllowance) {

                allowanceEth = formatUnits(currentAllowance, token.decimals(this.chainId)).toString();

            }

            const errStr: string = `Spend allowance of Bridge too low for token ${token.symbol}; current allowance for Bridge is ${allowanceEth}`;

            if (!needsApproval) {

                return hasBalanceRes

            }

            return {canBridge: false, reasonUnable: errStr, amount: currentAllowance}

        }

        private async checkNeedsApprove({

            address,

            token,

        }: CheckCanBridgeParams): Promise<NeedsTokenApproveResult> {

            const [{spender}, tokenAddress] = this.buildERC20ApproveArgs({token, amount});

            return ERC20.allowanceOf(address, spender, {tokenAddress, chainId: this.chainId})

                .then(currentAllowance => ({needsApproval: currentAllowance.lt(amount), currentAllowance}))

        }

        private async resolveBalanceFunc(

            prom:   Promise<BigNumber>,

            amount: BigNumberish,

            token:  Token

        ): Promise<CanBridgeResult> {

            return Promise.resolve(prom)

                .then(balance => {

                    const

                        hasBalance         = balance.gte(amount),

                        balanceEth: string = formatUnits(balance, token.decimals(this.chainId)).toString();

                    return (

                        hasBalance

                            ? {canBridge: true}

                            : {canBridge: false, reasonUnable: `Balance of token ${token.symbol} is too low; current balance is ${balanceEth}`, amount: balance}

                    ) as CanBridgeResult

                })

                .catch(rejectPromise)

        }

        private async checkGasTokenBalance(args: CanBridgeParams): Promise<CanBridgeResult> {

            const {address, token, amount} = args;

            const balanceProm: Promise<BigNumber> = this.provider.getBalance(address);

            return this.resolveBalanceFunc(

                balanceProm,

                amount,

                token

            )

        }

        async checkCanBridge(args: CheckCanBridgeParams): Promise<CanBridgeResult> {

            const {token, signer, address} = args;

            let signerAddress: string;

            if (address && address !== "") { /* c8 ignore start */

                signerAddress = address;

            } else {

                signerAddress = await signer.getAddress();

            } /* c8 ignore stop */

            const checkArgs: CanBridgeParams = {...args, address: signerAddress};

            const isGasTokenTransfer: boolean =

                (this.network.chainCurrency === token.symbol) && BridgeUtils.chainSupportsGasToken(this.chainId);

            let hasBalanceRes: Promise<CanBridgeResult> = isGasTokenTransfer

                ? this.checkGasTokenBalance(checkArgs)

                : this.checkERC20Balance(checkArgs);

            return isGasTokenTransfer

                ? hasBalanceRes

                : this.checkNeedsApprove(checkArgs)

                    .then(approveRes => this.resolveApproveFunc(approveRes, hasBalanceRes, token))

                    .catch(rejectPromise)

        }

        private async checkERC20Balance(args: CanBridgeParams): Promise<CanBridgeResult> {

            const

                {address, amount, token} = args,

                tokenAddress: string = token.address(this.chainId);

            return this.resolveBalanceFunc(

                ERC20.balanceOf(address, {tokenAddress, chainId: this.chainId}),

                amount,

                token

            )

        }

        private buildERC20ApproveArgs(args: {

            token:   Token | string,

            amount?: BigNumberish

        }): [ERC20.ApproveArgs, string] {

            const {token, amount} = args;

            let spender: string = this.zapBridgeAddress;

            if (instanceOfToken(token) && token.isEqual(Tokens.MULTIJEWEL)) {

                spender = SynapseEntities.AvaxJewelMigrationAddress;

            }

            /* c8 ignore start */

            let tokenAddr: string = instanceOfToken(token)

                ? token.address(this.chainId)

                : token as string;

            /* c8 ignore stop */

            return [{

                spender,

                amount

            }, tokenAddr]

        }

        private async checkSwapSupported(args: BridgeParams): Promise<boolean> {

            return new Promise<boolean>((resolve, reject) => {

                let [swapSupported, errReason] = this.swapSupported(args);

                if (!swapSupported) {

                    reject(errReason);

                    return

                }

                resolve(true);

            })

        }

        private async calculateBridgeRate(args: BridgeParams): Promise<BridgeOutputEstimate> {

            let {chainIdTo, amountFrom} = args;

            const l2BridgeZapTo = BridgeUtils.newL2BridgeZap(chainIdTo);

            const {

                tokenFrom, tokenTo,

                tokenIndexFrom, tokenIndexTo,

                fromChainTokens

            } = this.makeBridgeTokenArgs(args);

            let {intermediateToken} = TokenSwap.intermediateTokens(chainIdTo, tokenFrom, this.chainId);

            const {

                bridgeFee:  bridgeFeeRequest,

                amountFrom: amountFromFixedDecimals

            } = this.bridgeConfig.calculateSwapFee({

                chainIdFrom: this.chainId,

                tokenFrom,

                chainIdTo,

                amountFrom

            });

            const checkEthBridge = (c1: number, c2: number, t: Token): boolean =>

                c1 === ChainId.ETH && BridgeUtils.isL2ETHChain(c2) && t.swapType === SwapType.ETH

            const

                ethToEth:   boolean = checkEthBridge(this.chainId, chainIdTo,    tokenTo),

                ethFromEth: boolean = checkEthBridge(chainIdTo,    this.chainId, tokenFrom);

            let amountToReceive_from_prom: Promise<BigNumber>;

            if (amountFrom.isZero()) {

                amountToReceive_from_prom = Promise.resolve(Zero);

            } else if (ethToEth || Tokens.isMintBurnToken(tokenFrom) || tokenFrom.isWrapperToken) {

                amountToReceive_from_prom = Promise.resolve(amountFromFixedDecimals);

            } else if (this.chainId === ChainId.ETH) {

                let liquidityAmounts = fromChainTokens.map((t) =>

                    tokenFrom.isEqual(t) ? amountFrom : Zero

                );

                amountToReceive_from_prom = this.l1BridgeZapEth.calculateTokenAmount(

                    liquidityAmounts,

                    true

                );

            } else {

                amountToReceive_from_prom = this.l2BridgeZap.calculateSwap(

                    intermediateToken.address(this.chainId),

                    tokenIndexFrom,

                    0,

                    amountFrom

                );

            }

            let amountToReceive_from = await amountToReceive_from_prom;

            let bridgeFee: BigNumber;

            try { /* c8 ignore start */

                bridgeFee = await bridgeFeeRequest;

                if (bridgeFee === null) {

                    console.error("calculateSwapFee returned null");

                    return rejectPromise("calculateSwapFee returned null")

                }

            } catch (e) {

                console.error(`Error in bridge fee request: ${e}`);

                return rejectPromise(e)

            } /* c8 ignore stop */

            amountToReceive_from = BridgeUtils.subBigNumSafe(amountToReceive_from, bridgeFee);

            let amountToReceive_to_prom: Promise<BigNumber>;

            if (amountToReceive_from.isZero()) {

                amountToReceive_to_prom = Promise.resolve(Zero);

            } else if (ethFromEth || Tokens.isMintBurnToken(tokenTo) || tokenTo.isWrapperToken) {

                amountToReceive_to_prom = Promise.resolve(amountToReceive_from);

            } else if (chainIdTo === ChainId.ETH) {

                amountToReceive_to_prom =

                    this.l1BridgeZapEth.calculateRemoveLiquidityOneToken(

                        amountToReceive_from,

                        tokenIndexTo

                    );

            } else {

                amountToReceive_to_prom = l2BridgeZapTo.calculateSwap(

                    intermediateToken.address(chainIdTo),

                    0,

                    tokenIndexTo,

                    amountToReceive_from

                );

            }

            let amountToReceive: BigNumber;

            try { /* c8 ignore start */

                amountToReceive = await Promise.resolve(amountToReceive_to_prom)

            } catch (err) {

                return rejectPromise(err)

            } /* c8 ignore stop */

            return {amountToReceive, bridgeFee}

        }

        private checkEasyArgs(

            args:      BridgeTransactionParams,

            zapBridge: GenericZapBridgeContract,

            easyDeposits:    ID[],

            easyRedeems:     ID[],

            easyDepositETH?: ID[],

        ): EasyArgsCheck {

            let

                castArgs = args as BridgeUtils.BridgeTxParams,

                isEasy: boolean = false,

                txn:    Promise<PopulatedTransaction>;

            const params = BridgeUtils.makeEasyParams(castArgs, this.chainId, args.tokenTo);

            switch (true) {

                case easyRedeems.includes(args.tokenTo.id):

                    isEasy = true;

                    txn    = zapBridge.populateTransaction.redeem(...params);

                    break;

                case easyDeposits.includes(args.tokenTo.id):

                    isEasy = true;

                    txn    = zapBridge.populateTransaction.deposit(...params);

                    break;

                case easyDepositETH.includes(args.tokenTo.id):

                    isEasy = true;

                    txn    =  zapBridge

                        .populateTransaction

                        .depositETH(

                            ...BridgeUtils.depositETHParams(castArgs),

                            BridgeUtils.overrides(args.amountFrom)

                        );

                    break;

            }

            return {castArgs, isEasy, txn}

        }

        private buildETHMainnetBridgeTxn(

            args:      BridgeTransactionParams,

            tokenArgs: BridgeTokenArgs

        ): Promise<PopulatedTransaction> {

            const {addressTo, chainIdTo, amountFrom, amountTo} = args;

            let

                easyRedeems:    ID[] = [

                    Tokens.SYN.id,  Tokens.UST.id,  Tokens.USDB.id,

                    Tokens.VSTA.id,

                ],

                easyDeposits:   ID[] = [

                    Tokens.HIGH.id, Tokens.DOG.id,  Tokens.FRAX.id,

                    Tokens.GOHM.id, Tokens.NEWO.id, Tokens.SDT.id,

                ],

                easyDepositETH: ID[] = [Tokens.NETH.id];

            let {castArgs, isEasy, txn} = this.checkEasyArgs(args, this.l1BridgeZapEth, easyDeposits, easyRedeems, easyDepositETH);

            if (isEasy && txn) {

                return txn

            }

            const liquidityAmounts = tokenArgs.fromChainTokens.map(t =>

                    args.tokenFrom.isEqual(t)

                        ? amountFrom

                        : Zero

            );

            const {

                transactionDeadline,

                bridgeTransactionDeadline,

                minToSwapDestFromOrigin,

                minToSwapDest,

                minToSwapOriginMediumSlippage,

                minToSwapDestFromOriginMediumSlippage,

            } = BridgeUtils.getSlippages(amountFrom, amountTo);

            if (args.tokenTo.isEqual(Tokens.NUSD) || args.tokenTo.isEqual(Tokens.DFK_USDC)) {

                if (args.tokenFrom.isEqual(Tokens.NUSD) || args.tokenFrom.isEqual(Tokens.DFK_USDC)) {

                    const bridgeDepositArgs = BridgeUtils.makeEasyParams(

                        args as BridgeUtils.BridgeTxParams,

                        this.chainId,

                        Tokens.NUSD

                    );

                    return this.l1BridgeZapEth

                        .populateTransaction

                        .deposit(...bridgeDepositArgs)

                } else {

                    return this.l1BridgeZapEth.populateTransaction.zapAndDeposit(

                        addressTo,

                        chainIdTo,

                        Tokens.NUSD.address(this.chainId),

                        liquidityAmounts,

                        minToSwapDest,

                        transactionDeadline,

                    )

                }

            }

            if (BridgeUtils.isETHLikeToken(args.tokenTo) || args.tokenTo.isEqual(Tokens.WETH)) {

                return this.l1BridgeZapEth.populateTransaction.depositETHAndSwap(

                    ...BridgeUtils.depositETHParams(castArgs),

                    0, // nusd tokenindex,

                    tokenArgs.tokenIndexTo,

                    minToSwapDestFromOrigin, // minDy

                    bridgeTransactionDeadline,

                    BridgeUtils.overrides(amountFrom)

                )

            } else if (args.tokenFrom.isEqual(Tokens.NUSD)) {

                return this.l1BridgeZapEth.populateTransaction.depositAndSwap(

                    addressTo,

                    chainIdTo,

                    Tokens.NUSD.address(this.chainId),

                    amountFrom,

                    0,

                    tokenArgs.tokenIndexTo,

                    minToSwapDestFromOriginMediumSlippage,

                    bridgeTransactionDeadline

                )

            }

            return this.l1BridgeZapEth.populateTransaction.zapAndDepositAndSwap(

                addressTo,

                chainIdTo,

                Tokens.NUSD.address(this.chainId),

                liquidityAmounts,

                minToSwapOriginMediumSlippage, // minToSwapOrigin,

                transactionDeadline,

                0,

                tokenArgs.tokenIndexTo,

                minToSwapDestFromOriginMediumSlippage, //, minToSwapDestFromOrigin, // minDy

                bridgeTransactionDeadline,

            )

        }

        private buildL2BridgeTxn(

            args: BridgeTransactionParams,

            tokenArgs: BridgeTokenArgs

        ): Promise<PopulatedTransaction> {

            const

                {chainIdTo, amountFrom, amountTo} = args,

                zapBridge = SynapseEntities.L2BridgeZapContractInstance({

                    chainId:          this.chainId,

                    signerOrProvider: this.provider

                });

            tokenArgs.tokenFrom = tokenArgs.tokenFrom.isEqual(Tokens.AVWETH)

                : tokenArgs.tokenFrom;

            if (tokenArgs.tokenFrom.isEqual(Tokens.MULTIJEWEL)) {

                const jewelMigrator = SynapseEntities.AvaxJewelMigrationContractInstance();

                return jewelMigrator

                    .populateTransaction

                    .migrateAndBridge(

                        args.amountFrom,

                        args.addressTo,

                        args.chainIdTo

                    )

            }

            let

                easyDeposits:   ID[] = [],

                easyDepositETH: ID[] = [],

                easyRedeems:    ID[] = [

                    Tokens.SYN.id,      Tokens.HIGH.id,    Tokens.DOG.id,

                    Tokens.FRAX.id,     Tokens.UST.id,     Tokens.GOHM.id,

                    Tokens.NEWO.id,     Tokens.SDT.id,     Tokens.LUNA.id,

                    Tokens.USDB.id,

                ];

            BridgeUtils.DepositIfChainTokens.forEach((depositIfChainArgs) => {

                if (this.chainId === ChainId.DFK && args.tokenTo.isEqual(Tokens.SYN_AVAX)) {

                    return

                }

                let {chainId, tokens, depositEth, redeemChainIds} = depositIfChainArgs;

                let

                    hasAltChains = redeemChainIds.length > 0,

                    tokenHashes  = tokens.map((t) => t.id);

                if (this.chainId === chainId) {

                    if (depositEth) {

                        easyDepositETH.push(...tokenHashes);

                    } else {

                        easyDeposits.push(...tokenHashes);

                    }

                } else {

                    if (hasAltChains && redeemChainIds.includes(this.chainId)) {

                        easyRedeems.push(...tokenHashes);

                    }

                }

            });

            const

                dfkBridgeZap = BridgeUtils.newL1BridgeZap(ChainId.DFK),

                checkEasyZap = this.chainId === ChainId.DFK ? dfkBridgeZap : this.zapBridge;

            let {castArgs, isEasy, txn} = this.checkEasyArgs(args, checkEasyZap, easyDeposits, easyRedeems, easyDepositETH);

            if (isEasy && txn) {

                return txn

            }

            const {

                transactionDeadline,

                bridgeTransactionDeadline,

                minToSwapDestFromOrigin,

                minToSwapOriginHighSlippage,

                minToSwapDestFromOriginMediumSlippage,

                minToSwapDestFromOriginHighSlippage,

                minToSwapDest,

            } = BridgeUtils.getSlippages(amountFrom, amountTo);

            const easyRedeemAndSwap = (baseToken: Token): Promise<PopulatedTransaction> =>

                zapBridge

                    .populateTransaction

                    .redeemAndSwap(

                        ...BridgeUtils.makeEasyParams(castArgs, this.chainId, baseToken),

                        0,

                        tokenArgs.tokenIndexTo,

                        minToSwapDest,

                        transactionDeadline,

                    )

                let populateFn = swapETH

                    ? zapBridge.populateTransaction.swapETHAndRedeem

                    : zapBridge.populateTransaction.swapAndRedeem

                return populateFn(

                    ...BridgeUtils.makeEasySubParams(castArgs, this.chainId, baseToken),

                    tokenArgs.tokenIndexFrom,

                    0,

                    amountFrom,

                    minToSwapOriginHighSlippage, // minToSwapOrigin, // minToSwapOriginHighSlippage,

                    transactionDeadline,

                    swapETH ? BridgeUtils.overrides(amountFrom) : {}

                )

            }

            const easySwapAndRedeemAndSwap = (baseToken: Token, swapETH: boolean = false): Promise<PopulatedTransaction> => {

                let populateFn = swapETH

                    ? zapBridge.populateTransaction.swapETHAndRedeemAndSwap

                    : zapBridge.populateTransaction.swapAndRedeemAndSwap

                return populateFn(

                    ...BridgeUtils.makeEasySubParams(castArgs, this.chainId, baseToken),

                    tokenArgs.tokenIndexFrom,

                    0,

                    amountFrom,

                    minToSwapOriginHighSlippage,

                    transactionDeadline,

                    0,

                    tokenArgs.tokenIndexTo,

                    minToSwapDestFromOriginHighSlippage, // swapMinAmount

                    bridgeTransactionDeadline, // toSwapDeadline, // swapDeadline

                    swapETH ? BridgeUtils.overrides(amountFrom) : {}

                )

            }

            switch (tokenSwitch(args.tokenTo)) {

                case Tokens.NUSD:

                case Tokens.DFK_USDC:

                    if (args.tokenFrom.isEqual(Tokens.NUSD) || args.tokenFrom.isEqual(Tokens.DFK_USDC)) {

                        return zapBridge

                            .populateTransaction

                            .redeem(...BridgeUtils.makeEasyParams(castArgs, this.chainId, Tokens.NUSD))

                    }

                    return zapBridge

                        .populateTransaction

                        .swapAndRedeem(

                            ...BridgeUtils.makeEasySubParams(castArgs, this.chainId, Tokens.NUSD),

                            tokenArgs.tokenIndexFrom,

                            0,

                            amountFrom,

                            minToSwapOriginHighSlippage,

                            transactionDeadline

                        )

                case Tokens.GMX:

                    let params = BridgeUtils.makeEasyParams(castArgs, this.chainId, Tokens.GMX);

                    let [addrTo, chainTo,,amount] = params;

                    return this.chainId === ChainId.ARBITRUM

                        ? zapBridge.populateTransaction.deposit(...params)

                        : this.bridgeInstance

                            .populateTransaction

                            .redeem(

                                addrTo,

                                chainTo,

                                Tokens.GMX.wrapperAddress(this.chainId),

                                amount

                            )

                case Tokens.JEWEL:

                    if (this.chainId === ChainId.HARMONY) {

                        return zapBridge

                            .populateTransaction

                            .swapAndRedeem(

                                ...BridgeUtils.makeEasySubParams(castArgs, this.chainId, Tokens.SYN_JEWEL),

                                0,