Chainflip JavaScript SDK

import { Chains } from "@chainflip/sdk/swap";
 
console.log(await swapSDK.getChains(Chains.Assethub));

// console output:
[
  {
    chain: "Ethereum",
    name: "Ethereum",
    evmChainId: 1,
    isMainnet: true,
    requiredBlockConfirmations: 5,
    maxRetryDurationBlocks: 0,
  },
  {
    chain: "Bitcoin",
    name: "Bitcoin",
    evmChainId: undefined,
    isMainnet: true,
    requiredBlockConfirmations: 2,
    maxRetryDurationBlocks: 0,
  },
];

import { Chains } from "@chainflip/sdk/swap";
 
console.log(await swapSDK.getAssets(Chains.Ethereum));

// console output:
[
  {
    chainflipId: 'Eth',
    asset: 'ETH',
    chain: 'Ethereum',
    contractAddress: undefined,
    decimals: 18,
    name: 'Ether',
    symbol: 'ETH',
    isMainnet: true,
    minimumSwapAmount: '10000000000000000',
    maximumSwapAmount: null,
    minimumEgressAmount: '1'
  },
  ...,
  {
    chainflipId: 'Usdc',
    asset: 'USDC',
    chain: 'Ethereum',
    contractAddress: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
    decimals: 6,
    name: 'USDC',
    symbol: 'USDC',
    isMainnet: true,
    minimumSwapAmount: '20000000',
    maximumSwapAmount: null,
    minimumEgressAmount: '1'
  },
]

import { SwapSDK, Chains, Assets } from "@chainflip/sdk/swap";
 
const quoteRequest = {
  srcChain: Chains.Ethereum,
  srcAsset: Assets.USDC,
  destChain: Chains.Solana,
  destAsset: Assets.SOL,
  amount: (50e6).toString(), // 50 USDC
  brokerCommissionBps: 100, // 100 basis point = 1%
  affiliateBrokers: [
    {
      account: "cFM8kRvLBXagj6ZXvrt7wCM4jGmHvb5842jTtXXg3mRHjrvKy",
      commissionBps: 50,
    },
  ],
};
 
const swapSDK = new SwapSDK({
  enabledFeatures: {
    // enable DCA V2 feature when initiating the SDK to receive DCA quotes
    dcaV2: true,
  },
});
 
console.log(await swapSDK.getQuoteV2(quoteRequest));

// console output:
{
  srcChain: 'Ethereum',
  srcAsset: 'USDC',
  destChain: 'Solana',
  destAsset: 'SOL',
  amount: '50000000',
  requestId: '3f1a9c62-7b4e-4c10-9d5f-2a8e6b0c4d13',
  quotes: [
    {
      egressAmount: '309311018',
      recommendedSlippageTolerancePercent: 0.5,
      recommendedLivePriceSlippageTolerancePercent: 0.125,
      recommendedRetryDurationMinutes: 5,
      includedFees: [
        { type: 'INGRESS', chain: 'Ethereum', asset: 'USDC', amount: '1395704' },
        { type: 'NETWORK', chain: 'Ethereum', asset: 'USDC', amount: '48604' },
        { type: 'BROKER', chain: 'Ethereum', asset: 'USDC', amount: '728335' },
        { type: 'EGRESS', chain: 'Solana', asset: 'SOL', amount: '14000' },
      ],
      lowLiquidityWarning: true,
      poolInfo: [
        {
          baseAsset: { chain: 'Solana', asset: 'SOL' },
          quoteAsset: { chain: 'Ethereum', asset: 'USDC' },
          fee: { chain: 'Ethereum', asset: 'USDC', amount: '24302' },
        },
      ],
      estimatedDurationsSeconds: { deposit: 90, swap: 12, egress: 90.6 },
      estimatedDurationSeconds: 192.6,
      estimatedPrice: '0.00636414974511718059',
      type: 'REGULAR',
      srcAsset: { chain: 'Ethereum', asset: 'USDC' },
      destAsset: { chain: 'Solana', asset: 'SOL' },
      depositAmount: '50000000',
      isVaultSwap: false,
      isOnChain: false,
    },
    {
      egressAmount: '309311018',
      recommendedSlippageTolerancePercent: 0.5,
      recommendedLivePriceSlippageTolerancePercent: 0.125,
      recommendedRetryDurationMinutes: 5,
      includedFees: [
        { type: 'INGRESS', chain: 'Ethereum', asset: 'USDC', amount: '1395704' },
        { type: 'NETWORK', chain: 'Ethereum', asset: 'USDC', amount: '48604' },
        { type: 'BROKER', chain: 'Ethereum', asset: 'USDC', amount: '728335' },
        { type: 'EGRESS', chain: 'Solana', asset: 'SOL', amount: '14000' },
      ],
      lowLiquidityWarning: true,
      poolInfo: [
        {
          baseAsset: { chain: 'Solana', asset: 'SOL' },
          quoteAsset: { chain: 'Ethereum', asset: 'USDC' },
          fee: { chain: 'Ethereum', asset: 'USDC', amount: '24302' },
        },
      ],
      estimatedDurationsSeconds: { deposit: 90, swap: 142, egress: 90.6 },
      estimatedDurationSeconds: 192.6,
      estimatedPrice: '0.00636414974511718059',
      type: 'DCA',
      srcAsset: { chain: 'Ethereum', asset: 'USDC' },
      destAsset: { chain: 'Solana', asset: 'SOL' },
      depositAmount: '50000000',
      isVaultSwap: false,
      isOnChain: false,
      dcaParams: {
        chunkIntervalBlocks: 2,
        numberOfChunks: 22,
      },
    },
  ],
}

import {
  Chains,
  Assets,
  type DepositAddressRequestV2,
} from "@chainflip/sdk/swap";
 
const { quotes } = await swapSDK.getQuoteV2({
  srcChain: Chains.Ethereum,
  srcAsset: Assets.ETH,
  destChain: Chains.Bitcoin,
  destAsset: Assets.BTC,
  amount: (1.5e18).toString(), // 1.5 ETH
});
const quote = quotes.find((quote) => quote.type === "REGULAR");
if (!quote) throw new Error("No quote");
 
const swapDepositAddressRequest: DepositAddressRequestV2 = {
  quote,
  destAddress: "bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq",
  fillOrKillParams: {
    refundAddress: "0xa56A6be23b6Cf39D9448FF6e897C29c41c8fbDFF", // address to which assets are refunded
    retryDurationMinutes: quote.recommendedRetryDurationMinutes, // use recommended retry duration from quote
    slippageTolerancePercent: quote.recommendedSlippageTolerancePercent, // use recommended slippage tolerance from quote
    livePriceSlippageTolerancePercent:
      quote.recommendedLivePriceSlippageTolerancePercent, // use recommended live price slippage tolerance from quote
  },
  brokerCommissionBps: 100, // 100 basis point = 1%
  affiliateBrokers: [
    {
      account: "cFM8kRvLBXagj6ZXvrt7wCM4jGmHvb5842jTtXXg3mRHjrvKy",
      commissionBps: 50,
    },
  ], // total commission 150 bps = 1.5%
};
console.log(await swapSDK.requestDepositAddressV2(swapDepositAddressRequest));

// console output:
{
  srcAsset: 'ETH',
  srcChain: 'Ethereum',
  destAsset: 'BTC',
  destChain: 'Bitcoin',
  srcAddress: undefined,
  destAddress: 'bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq',
  dcaParams: undefined,
  fillOrKillParams: {
    refundAddress: '0xa56A6be23b6Cf39D9448FF6e897C29c41c8fbDFF',
    retryDurationMinutes: 5,
    slippageTolerancePercent: 0.5,
    livePriceSlippageTolerancePercent: 0.125
  },
  maxBoostFeeBps: 0,
  ccmParams: undefined,
  amount: '1500000000000000000', // 1.5 ETH
  depositChannelId: '6739624-Ethereum-2562', // Identifies the deposit channel for this swap
  depositAddress: '0x6284c66ebf4110ae3cc4da45fb9b1c2143417092', // Address where funds need to be deposited to start the swap
  brokerCommissionBps: 100,
  affiliateBrokers: [
    { account: 'cFM8kRvLBXagj6ZXvrt7wCM4jGmHvb5842jTtXXg3mRHjrvKy', commissionBps: 50 }
  ],
  depositChannelExpiryBlock: 21930372n,
  estimatedDepositChannelExpiryTime: 1630000000, // Estimated expiry time of the deposit channel
  channelOpeningFee: 0n
}

import { Chains, Assets } from "@chainflip/sdk/swap";
 
const { quotes } = await swapSDK.getQuoteV2({
  srcChain: Chains.Bitcoin,
  srcAsset: Assets.BTC,
  destChain: Chains.Ethereum,
  destAsset: Assets.ETH,
  amount: (1.5e8).toString(), // 1.5 BTC
});
// `boostQuote` may be undefined depending on asset and liquidity conditions
const regularBoostQuote = quotes.find(
  (quote) => quote.type === "REGULAR",
)?.boostQuote;
if (!regularBoostQuote) throw new Error("No boost quote");
 
const swapDepositAddressRequest = {
  quote: regularBoostQuote,
  destAddress: "0xa56A6be23b6Cf39D9448FF6e897C29c41c8fbDFF",
  fillOrKillParams: {
    refundAddress: "bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq",
    retryDurationBlocks: 100,
    slippageTolerancePercent: quote.recommendedSlippageTolerancePercent,
    livePriceSlippageTolerancePercent:
      quote.recommendedLivePriceSlippageTolerancePercent,
  },
};
console.log(await swapSDK.requestDepositAddressV2(swapDepositAddressRequest));

import { Chains, Assets } from "@chainflip/sdk/swap";
 
const { quotes } = await swapSDK.getQuoteV2({
  srcChain: Chains.Ethereum,
  srcAsset: Assets.ETH,
  destChain: Chains.Bitcoin,
  destAsset: Assets.BTC,
  amount: (1.5e18).toString(), // 1.5 ETH
});
 
// ❗ the dcaV2 feature must be enabled when the SDK is instantiated to receive DCA quotes ❗
const quote = quotes.find((quote) => quote.type === "DCA");
if (!quote) throw new Error("No DCA quote");
 
const swapDepositAddressRequest = {
  quote,
  destAddress: "bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq",
  brokerCommissionBps: 100,
  fillOrKillParams: {
    refundAddress: "0xa56A6be23b6Cf39D9448FF6e897C29c41c8fbDFF",
    retryDurationBlocks: 100,
    slippageTolerancePercent: quote.recommendedSlippageTolerancePercent,
    livePriceSlippageTolerancePercent:
      quote.recommendedLivePriceSlippageTolerancePercent,
  },
};
console.log(await swapSDK.requestDepositAddressV2(swapDepositAddressRequest));

import { Chains, Assets } from "@chainflip/sdk/swap";
import { getDefaultProvider, Wallet, Contract } from "ethers";
 
const wallet = new Wallet(
  process.env.SECRET_KEY as string,
  getDefaultProvider("sepolia"),
);
 
const { quotes } = await swapSDK.getQuoteV2({
  srcChain: Chains.Ethereum,
  srcAsset: Assets.USDC,
  destChain: Chains.Bitcoin,
  destAsset: Assets.BTC,
  isVaultSwap: true,
  amount: (500e6).toString(), // 500 USDC
});
const quote = quotes.find((quote) => quote.type === "REGULAR");
if (!quote) throw new Error("No quote");
 
const vaultSwapRequest = {
  quote,
  srcAddress: wallet.address,
  destAddress: "bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq",
  fillOrKillParams: {
    refundAddress: wallet.address, // address to which assets are refunded
    retryDurationBlocks: 100, // 100 blocks * 6 seconds = 10 minutes before deposits are refunded
    slippageTolerancePercent: quote.recommendedSlippageTolerancePercent, // use recommended slippage tolerance from quote
    livePriceSlippageTolerancePercent:
      quote.recommendedLivePriceSlippageTolerancePercent, // use recommended live price slippage tolerance from quote
  },
};
const vaultSwapData = await swapSDK.encodeVaultSwapData(vaultSwapRequest);
console.log(vaultSwapData);
 
// `VaultSwapResponse` is a union - narrow it on `chain` to get the fields for
// the source chain of the swap
if (vaultSwapData.chain !== "Ethereum") throw new Error("Invalid chain");
 
// approve chainflip vault to spend erc20 token
if (vaultSwapData.sourceTokenAddress) {
  const sourceTokenContract = new Contract(
    vaultSwapData.sourceTokenAddress,
    ["function approve(address spender, uint256 value) returns (bool)"],
    wallet,
  );
  const approvalTx = await sourceTokenContract.approve(
    vaultSwapData.to,
    quote.depositAmount,
  );
  await approvalTx.wait();
}
 
const swapTx = await wallet.sendTransaction({
  to: vaultSwapData.to,
  data: vaultSwapData.calldata,
  value: vaultSwapData.value,
});
const receipt = await swapTx.wait(); // wait for transaction to be included in a block
if (!receipt) throw new Error("Transaction was not mined");
 
// status will be available after the transaction is included in a block
const status = await swapSDK.getStatusV2({ id: receipt.hash });

// console output:
{
  chain: 'Ethereum',
  to: '0x36ead71325604dc15d35fae584d7b50646d81753',
  calldata: '0xdd68734500000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000014cb583c817964a2c527608f8b813a4c9bddb559a9000000000000000000000000000000000000000000000000000000000000000000000000000000000000005e0064000000cb583c817964a2c527608f8b813a4c9bddb559a945f572d5916d163cccbef285e25d4bde2400000000000000000000000000000000009e8d88ae895c9b37b2dead9757a3452f7c2299704d91ddfa444d87723f94fe0c0000000000',
  value: 0n,
  sourceTokenAddress: '0x1c7d4b196cb0c7b01d743fbc6116a902379c7238'
}

import { Chains, Assets } from "@chainflip/sdk/swap";
import Client from "bitcoin-core";
import * as bitcoin from "bitcoinjs-lib";
import ECPairFactory from "ecpair";
import * as secp256k1 from "tiny-secp256k1";
 
const keypair = ECPairFactory(secp256k1).fromWIF(
  process.env.WALLET_WIF as string,
);
const network = bitcoin.networks.testnet;
const walletAddress = bitcoin.payments.p2wpkh({
  pubkey: Buffer.from(keypair.publicKey),
  network,
}).address!;
bitcoin.initEccLib(secp256k1);
 
const { quotes } = await swapSDK.getQuoteV2({
  srcChain: Chains.Bitcoin,
  srcAsset: Assets.BTC,
  destChain: Chains.Ethereum,
  destAsset: Assets.ETH,
  isVaultSwap: true,
  amount: (0.015e8).toString(), // 0.015 BTC
});
 
// `boostQuote` may be undefined depending on asset and liquidity conditions
const quote = quotes.find((quote) => quote.type === "REGULAR")?.boostQuote;
if (!quote) throw new Error("No boost quote");
 
const vaultSwapRequest = {
  quote,
  srcAddress: walletAddress,
  destAddress: "0xa56A6be23b6Cf39D9448FF6e897C29c41c8fbDFF",
  fillOrKillParams: {
    refundAddress: walletAddress,
    retryDurationBlocks: 100,
    slippageTolerancePercent: quote.recommendedSlippageTolerancePercent,
    livePriceSlippageTolerancePercent:
      quote.recommendedLivePriceSlippageTolerancePercent,
  },
};
const vaultSwapData = await swapSDK.encodeVaultSwapData(vaultSwapRequest);
console.log(vaultSwapData);
 
// `VaultSwapResponse` is a union - narrow it on `chain` to get the fields for
// the source chain of the swap
if (vaultSwapData.chain !== "Bitcoin") throw new Error("Invalid chain");
 
export const rpcClient = new Client({
  host: "https://bitcoin-testnet-rpc.publicnode.com",
});
const inputUtxo = {
  txId: "4403c8d3b752a3aa0757031239a82ce92d67fadc1bb4a35f80ace660499edd55",
  outIndex: 2,
};
const inputTx = bitcoin.Transaction.fromHex(
  await rpcClient.command("getrawtransaction", inputUtxo.txId),
);
const txFeeSats = 1000n;
 
const tx = new bitcoin.Psbt({ network })
  .addInput({
    hash: inputTx.getHash(),
    index: inputUtxo.outIndex,
    nonWitnessUtxo: inputTx.toBuffer(),
    sequence: 0xfffffffd, // enable replace-by-fee
  })
  .addOutput({
    // first output needs to spend assets to deposit address
    address: vaultSwapData.depositAddress,
    value: BigInt(quote.depositAmount),
  })
  .addOutput({
    // second output needs to return encoded vault details using the OP_RETURN opcode
    script: bitcoin.payments.embed({
      data: [
        Buffer.from(vaultSwapData.nulldataPayload.replace("0x", ""), "hex"),
      ],
      network,
    }).output!,
    value: 0n,
  })
  .addOutput({
    // third output defines the refund address for the swap
    address: walletAddress,
    value:
      inputTx.outs[inputUtxo.outIndex].value -
      BigInt(quote.depositAmount) -
      txFeeSats,
  })
  .signInput(0, {
    publicKey: Buffer.from(keypair.publicKey),
    sign: (hash) => Buffer.from(keypair.sign(hash)),
  })
  .finalizeAllInputs()
  .extractTransaction();
await rpcClient.command("sendrawtransaction", tx.toHex());
 
// status will be available once the transaction is in the mempool
const status = await swapSDK.getStatusV2({ id: tx.getId() });

// console output:
{
  chain: 'Bitcoin',
  nulldataPayload: '0x0001a56a6be23b6cf39d9448ff6e897c29c41c8fbdff640029a43fc140746a5e000000000000000001000200000000',
  depositAddress: 'tb1pxu6h02gundytrfvlrxtjylkqmfv072ljtqcfvwclh37cx4eq7chqq6zmng'
}

import { Chains, Assets, type VaultSwapRequest } from "@chainflip/sdk/swap";
import { randomBytes } from "crypto";
import {
  PublicKey,
  Keypair,
  sendAndConfirmTransaction,
  TransactionInstruction,
  Transaction,
  Connection,
  clusterApiUrl,
} from "@solana/web3.js";
import bs58 from "bs58";
 
const keypair = Keypair.fromSecretKey(
  bs58.decode(process.env.SECRET_KEY_BASE58 as string),
);
 
const { quotes } = await swapSDK.getQuoteV2({
  srcChain: Chains.Solana,
  srcAsset: Assets.SOL,
  destChain: Chains.Ethereum,
  destAsset: Assets.ETH,
  isVaultSwap: true,
  amount: (1.5e9).toString(), // 1.5 SOL
});
const quote = quotes.find((quote) => quote.type === "REGULAR");
if (!quote) throw new Error("No quote");
 
const vaultSwapRequest: VaultSwapRequest = {
  quote,
  srcAddress: keypair.publicKey.toBase58(),
  destAddress: "0xa56A6be23b6Cf39D9448FF6e897C29c41c8fbDFF",
  fillOrKillParams: {
    refundAddress: keypair.publicKey.toBase58(),
    retryDurationBlocks: 100,
    slippageTolerancePercent: quote.recommendedSlippageTolerancePercent,
    livePriceSlippageTolerancePercent:
      quote.recommendedLivePriceSlippageTolerancePercent,
  },
  extraParams: {
    // the seed must be a 0x-prefixed, 32 byte hex string
    seed: `0x${randomBytes(32).toString("hex")}`,
  },
};
const vaultSwapData = await swapSDK.encodeVaultSwapData(vaultSwapRequest);
console.log(vaultSwapData);
 
// `VaultSwapResponse` is a union - narrow it on `chain` to get the fields for
// the source chain of the swap
if (vaultSwapData.chain !== "Solana") throw new Error("Invalid chain");
 
const transaction = new Transaction().add(
  new TransactionInstruction({
    keys: vaultSwapData.accounts.map((account) => ({
      pubkey: new PublicKey(account.pubkey),
      isSigner: account.isSigner,
      isWritable: account.isWritable,
    })),
    programId: new PublicKey(vaultSwapData.programId),
    data: Buffer.from(vaultSwapData.data.slice(2), "hex"),
  }),
);
const signature = await sendAndConfirmTransaction(
  new Connection(clusterApiUrl("devnet"), "confirmed"),
  transaction,
  [keypair],
);
 
// status will be available after the transaction is included in a block
const status = await swapSDK.getStatusV2({ id: signature });

// console output:
{
  chain: 'Solana',
  programId: 'DeL6iGV5RWrWh7cPoEa7tRHM8XURAaB4vPjfX5qVyuWE',
  data: '0xa3265ce2f3698dc4002f6859000000000100000014000000c64722ad9613851b10e26ff8118a7696a0f956f201000000006a000000000a0000009e0d6a70e12d54edf90971cc977fa26a1d3bb4b0b26e72470171c36b0006b01f000000100000000000000000000000000000000000000000000000000000000000009059e6d854b769a505d01148af212bf8cb7f8469a7153edce8dcaedd9d299125000000200000004a7b9c2f1e8d3a5b6c4f9e2d7a1b3c8f0e5d9a2c6b4f7e1d3a8b5c9f2e0d6a30',
  accounts: [
    {
      pubkey: 'GpTqSHz4JzQimjfDiBgDhJzYcTonj3t6kMhKTigCKHfc',
      isSigner: false,
      isWritable: false
    },
    ...
  ]
}

import { Chains, Assets } from "@chainflip/sdk/swap";
import { TronWeb } from "tronweb";
 
const privateKey = process.env.TRON_SECRET_KEY as string;
const tronWeb = new TronWeb({
  fullHost: "https://nile.trongrid.io", // Nile testnet matches perseverance
  privateKey,
});
const tronAddress = tronWeb.address.fromPrivateKey(privateKey) as string;
 
const swapAmount = (50e6).toString(); // 50 TRX in sun
 
const { quotes } = await swapSDK.getQuoteV2({
  srcChain: Chains.Tron,
  srcAsset: Assets.TRX,
  destChain: Chains.Ethereum,
  destAsset: Assets.USDC,
  isVaultSwap: true,
  amount: swapAmount,
});
const quote = quotes.find((quote) => quote.type === "REGULAR");
if (!quote) throw new Error("No quote");
 
const vaultSwapData = await swapSDK.encodeVaultSwapData({
  quote,
  destAddress: "0xa56A6be23b6Cf39D9448FF6e897C29c41c8fbDFF",
  fillOrKillParams: {
    refundAddress: tronAddress,
    retryDurationBlocks: 100,
    slippageTolerancePercent: quote.recommendedSlippageTolerancePercent,
    livePriceSlippageTolerancePercent:
      quote.recommendedLivePriceSlippageTolerancePercent,
  },
});
console.log(vaultSwapData);
 
// `VaultSwapResponse` is a union - narrow it on `chain` to get the fields for
// the source chain of the swap
if (vaultSwapData.chain !== "Tron") throw new Error("Invalid chain");
 
const { to, value, note, sourceTokenAddress } = vaultSwapData;
 
let transaction;
if (sourceTokenAddress) {
  // TRC-20 (USDT): call transfer(vault, amount) on the token contract
  const { transaction: trc20Tx } =
    await tronWeb.transactionBuilder.triggerSmartContract(
      sourceTokenAddress,
      "transfer(address,uint256)",
      { feeLimit: 100_000_000 },
      [
        { type: "address", value: to },
        { type: "uint256", value: swapAmount },
      ],
      tronAddress,
    );
  transaction = trc20Tx;
} else {
  // native TRX: send TRX directly to the Chainflip vault address
  transaction = await tronWeb.transactionBuilder.sendTrx(
    to,
    Number(value), // value is in sun (1 TRX = 1,000,000 sun)
    tronAddress,
  );
}
 
// attach the swap parameters as a note - this is what identifies the
// transaction to Chainflip
transaction = await tronWeb.transactionBuilder.addUpdateData(
  transaction,
  note.slice(2), // strip the leading 0x
  "hex",
);
 
const signedTx = await tronWeb.trx.sign(transaction);
const receipt = await tronWeb.trx.sendRawTransaction(signedTx);
 
// status will be available after the transaction is included in a block
const status = await swapSDK.getStatusV2({ id: receipt.txid });

// console output (native TRX swap):
{
  chain: 'Tron',
  to: 'TYPcfPnrhqRRbaBmeJoWmgAcbVLGrJHeLR',
  calldata: '0x',
  value: 50000000n,
  note: '0x0001a56a6be23b6cf39d9448ff6e897c29c41c8fbdff640029a43fc140746a5e00000000000000000100020000',
  sourceTokenAddress: undefined
}

import { Chains, Assets, SwapSDK } from "@chainflip/sdk/swap";
 
const swapSDK = new SwapSDK({ network: "perseverance" });
 
const { quotes } = await swapSDK.getQuoteV2({
  srcChain: Chains.Ethereum,
  srcAsset: Assets.USDC,
  destChain: Chains.Bitcoin,
  destAsset: Assets.BTC,
  isVaultSwap: true,
  amount: (500e6).toString(), // 500 USDC
});
const quote = quotes.find((quote) => quote.type === "REGULAR");
if (!quote) throw new Error("No quote");
 
const vaultSwapRequest = {
  quote,
  destAddress: "tb1q65700ylwuua9669umxdep76a69jy3tfh55llf5",
  fillOrKillParams: {
    refundAddress: "0x36ead71325604dc15d35fae584d7b50646d81753", // address to which assets are refunded
    retryDurationBlocks: 100, // 100 blocks * 6 seconds = 10 minutes before deposits are refunded
    slippageTolerancePercent: quote.recommendedSlippageTolerancePercent, // use recommended slippage tolerance from quote
    livePriceSlippageTolerancePercent:
      quote.recommendedLivePriceSlippageTolerancePercent, // use recommended live price slippage tolerance from quote
  },
};
const vaultSwapData = await swapSDK.encodeCfParameters(vaultSwapRequest);
console.log(vaultSwapData);

// console output:
"0x006400000036ead71325604dc15d35fae584d7b50646d81753b8b06ebc3b32569bff571d39d21918010000000000000000000000000000000000009e8d88ae895c9b37b2dead9757a3452f7c2299704d91ddfa444d87723f94fe0c000000";

const swapStatusRequest = {
  id: "6726421-Bitcoin-34009", // depositChannelId / swapId / transactionId
};
 
console.log(await swapSDK.getStatusV2(swapStatusRequest));

// console output:
{
  state: 'COMPLETED',
  swapId: '332925',
  srcAsset: 'BTC',
  srcChain: 'Bitcoin',
  destAsset: 'USDC',
  destChain: 'Ethereum',
  destAddress: '0xbbfefb09727136a6c3ddd28bd4abdf259b9351c1',
  srcChainRequiredBlockConfirmations: 2,
  estimatedDurationsSeconds: { deposit: 1806, swap: 12, egress: 102 },
  estimatedDurationSeconds: 1920,
  brokers: [
    { account: 'cFJZVRaybb2PBwxTiAiRLiQfHY4KPB3RpJK22Q7Fhqk979aCH', commissionBps: 5 },
    { account: 'cFK6mYjpajcwPDZ7JUsac8XUoVSJnhjL43ZMZW7YoN8HE4dD8', commissionBps: 60 },
  ],
  fees: [
    { type: 'NETWORK', chain: 'Ethereum', asset: 'USDC', amount: '52965555' },
    { type: 'LIQUIDITY', chain: 'Bitcoin', asset: 'BTC', amount: '27972' },
    { type: 'BROKER', chain: 'Ethereum', asset: 'USDC', amount: '343931842' },
    { type: 'BOOST', chain: 'Bitcoin', asset: 'BTC', amount: '28000' },
    { type: 'INGRESS', chain: 'Bitcoin', asset: 'BTC', amount: '1251' },
    { type: 'EGRESS', chain: 'Ethereum', asset: 'USDC', amount: '0' },
  ],
  depositChannel: {
    id: '6726421-Bitcoin-34009',
    createdAt: 1740415452001,
    depositAddress: 'bc1ppaxkhh5c65zypqtjl7s5j4lqqaund3lzaz27cwlhw7nvg0s84cwqv4q6pw',
    srcChainExpiryBlock: '885280',
    estimatedExpiryTime: 1740502800000,
    expectedDepositAmount: undefined,
    isExpired: false,
    openedThroughBackend: false,
    dcaParams: { numberOfChunks: 18, chunkIntervalBlocks: 2 },
  },
  deposit: {
    amount: '55970749',
    txRef: 'ba030cf99b7b01d9455c3ab87a5d87a301b67e91640fc9c76014c6e5b97986d7',
    witnessedAt: 1740415836000,
    witnessedBlockIndex: '6726483-536',
  },
  swap: {
    originalInputAmount: '55970749',
    remainingInputAmount: '0',
    swappedInputAmount: '55970749',
    swappedIntermediateAmount: '0',
    swappedOutputAmount: '52568658562',
    dca: {
      lastExecutedChunk: {
        inputAmount: '3109487',
        outputAmount: '2916364871',
        scheduledAt: 1740416046000,
        scheduledBlockIndex: '6726517-2189',
        executedAt: 1740416058000,
        executedBlockIndex: '6726519-1073',
        retryCount: 0,
      },
      currentChunk: null,
      executedChunks: 18,
      remainingChunks: 0,
    },
  },
  swapEgress: {
    amount: '52568658562',
    scheduledAt: 1740416058000,
    scheduledBlockIndex: '6726519-1074',
    witnessedAt: 1740416262000,
    witnessedBlockIndex: '6726552-640',
    txRef: '0xc8646625910babc04b1612526c27fbac68aacf6cc489affbae69d1d430f5fcb1',
  },
  fillOrKillParams: {
    refundAddress: 'bc1qstlcaqcds8xea7dtktdn47hng7c3lq3fa7vrtm',
    minPrice: '92307.460172',
    retryDurationBlocks: 150,
  },
  dcaParams: { numberOfChunks: 18, chunkIntervalBlocks: 2 },
  boost: {
    effectiveBoostFeeBps: 5,
    maxBoostFeeBps: 0,
    boostedAt: 1740415836000,
    boostedBlockIndex: '6726483-536',
  },
  lastStatechainUpdateAt: 1740497470820,
}

console.log(await swapSDK.getSwapLimits());

// console output (the values are protocol parameters and change over time):
{
  minimumSwapAmounts: {
    Bitcoin: { BTC: 70000n },
    Ethereum: {
      ETH: 10000000000000000n,
      FLIP: 4000000000000000000n,
      USDC: 20000000n,
      USDT: 20000000n,
      WBTC: 70000n,
      CBBTC: 70000n
    },
    Arbitrum: {
      ETH: 10000000000000000n,
      USDC: 20000000n,
      USDT: 20000000n
    },
    Solana: { SOL: 0n, USDC: 0n, USDT: 0n },
    Assethub: { DOT: 40000000000n, USDC: 20000000n, USDT: 20000000n },
    Bsc: { BNB: 10000000000000000n, USDT: 20000000000000000000n },
    Tron: { TRX: 20000000n, USDT: 20000000n }
  },
  maximumSwapAmounts: {
    Bitcoin: { BTC: 4000000n },
    Ethereum: {
      ETH: 500000000000000000n,
      FLIP: 200000000000000000000n,
      USDC: 1000000000n,
      USDT: 1000000000n,
      WBTC: null,
      CBBTC: null
    },
    Arbitrum: {
      ETH: 500000000000000000n,
      USDC: 1000000000n,
      USDT: null
    },
    Solana: { SOL: null, USDC: null, USDT: null },
    Assethub: { DOT: 2000000000000n, USDC: null, USDT: null },
    Bsc: { BNB: null, USDT: null },
    Tron: { TRX: null, USDT: null }
  }
}

console.log(await swapSDK.getBoostLiquidity());

// console output:
[
  // ...
  {
    availableAmount: 0n,
    feeTierBps: 5,
    chain: "Ethereum",
    asset: "FLIP",
    poolType: "LEGACY_BOOST",
  },
  {
    availableAmount: 0n,
    feeTierBps: 5,
    chain: "Ethereum",
    asset: "USDC",
    poolType: "LEGACY_BOOST",
  },
  {
    availableAmount: 450695350n,
    feeTierBps: 5,
    chain: "Bitcoin",
    asset: "BTC",
    poolType: "LEGACY_BOOST",
  },
  {
    availableAmount: 1200000000n,
    feeTierBps: 5,
    chain: "Bitcoin",
    asset: "BTC",
    poolType: "SUPPLY",
  },
  {
    availableAmount: 0n,
    feeTierBps: 5,
    chain: "Arbitrum",
    asset: "USDC",
    poolType: "LEGACY_BOOST",
  },
  // ...
];

console.log(
  await sdk.getBoostLiquidity({
    asset: "BTC",
    chain: "Bitcoin",
  }),
);

// console output:
[
  {
    availableAmount: 450695350n,
    feeTierBps: 5,
    chain: "Bitcoin",
    asset: "BTC",
    poolType: "LEGACY_BOOST",
  },
  {
    availableAmount: 1200000000n,
    feeTierBps: 5,
    chain: "Bitcoin",
    asset: "BTC",
    poolType: "SUPPLY",
  },
];

console.log(
  await sdk.getBoostLiquidity({
    feeTierBps: 5,
  }),
);

// console output:
[
  // ...
  {
    availableAmount: 450695350n,
    feeTierBps: 5,
    chain: "Bitcoin",
    asset: "BTC",
    poolType: "LEGACY_BOOST",
  },
  // ...
];

console.log(await swapSDK.getChannelOpeningFees());

// console output (the values are protocol parameters and change over time):
{
  Bitcoin: 0n,
  Ethereum: 0n,
  Arbitrum: 0n,
  Solana: 0n,
  Assethub: 0n,
  Bsc: 0n,
  Tron: 0n
}

console.log(await swapSDK.getRequiredBlockConfirmations());

// console output (the values are protocol parameters and change over time):
{
  Bitcoin: 2,
  Ethereum: 5,
  Arbitrum: 2,
  Solana: null,
  Assethub: null,
  Bsc: 5,
  Tron: 20
}

console.log(await swapSDK.checkBoostEnabled());

// console output:
true;