@velora-dex/sdk 8.0.0

package/src/examples/ethersV6.ts

@@ -0,0 +1,38 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import axios from 'axios';
+import { ethers } from 'ethers';
+import {
+  constructPartialSDK,
+  constructFullSDK,
+  constructGetAdapters,
+  constructEthersV6ContractCaller,
+  constructAxiosFetcher,
+} from '..';
+
+const fetcher = constructAxiosFetcher(axios);
+
+const provider = ethers.getDefaultProvider(1);
+const contractCaller = constructEthersV6ContractCaller({
+  ethersV6ProviderOrSigner: provider,
+  EthersV6Contract: ethers.Contract,
+});
+
+const sdk = constructFullSDK({
+  chainId: 1,
+  fetcher,
+  contractCaller,
+});
+
+const res = sdk.swap.getAdapters();
+
+// type Promise<ContractTransaction>
+const txResponse = sdk.swap.approveToken('1', '0x...');
+// type Promise<ContractTransaction[]>
+const txResponses = sdk.swap.approveTokenBulk('1', ['0x...']);
+
+const partial = constructPartialSDK(
+  { apiURL: '', chainId: 1, fetcher },
+  constructGetAdapters
+);
+
+const res1 = partial.getAdapters();

package/src/examples/limitOrders_all.ts

@@ -0,0 +1,135 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import axios from 'axios';
+import BigNumber from 'bignumber.js';
+import { ethers } from 'ethersV5';
+import { assert } from 'ts-essentials';
+import {
+  // swap methods
+  constructPartialSDK,
+  constructEthersContractCaller,
+  constructAxiosFetcher,
+  // limitOrders methods
+  constructAllLimitOrdersHandlers,
+  // extra types
+  LimitOrderFromApi,
+  SwappableOrder,
+} from '..';
+
+const account = '0x1234...';
+
+const fetcher = constructAxiosFetcher(axios);
+
+// provider must have write access to account
+// this would usually be wallet provider (Metamask)
+const provider = ethers.getDefaultProvider(1);
+const contractCaller = constructEthersContractCaller(
+  {
+    ethersProviderOrSigner: provider,
+    EthersContract: ethers.Contract,
+  },
+  account
+);
+
+// type BuildLimitOrderFunctions
+// & SignLimitOrderFunctions
+// & CancelLimitOrderFunctions<ethers.ContractTransaction>
+// & ApproveTokenFunctions<ethers.ContractTransaction>
+const limitOrderSDK = constructPartialSDK(
+  {
+    chainId: 1,
+    fetcher,
+    contractCaller,
+  },
+  constructAllLimitOrdersHandlers
+);
+
+const DAI = '0x6B175474E89094C44Da98b954EedeAC495271d0F';
+const HEX = '0x2b591e99afe9f32eaa6214f7b7629768c40eeb39';
+
+const orderInput = {
+  nonce: 1,
+  expiry: Math.floor(Date.now() / 1000) + 60 * 60 * 24 * 7, // week from now, in sec
+  makerAsset: DAI,
+  takerAsset: HEX,
+  makerAmount: (1e18).toString(10),
+  takerAmount: (8e18).toString(10),
+  maker: account,
+};
+
+async function run() {
+  // approve token for the limit order
+  const tx1: ethers.ContractTransaction =
+    await limitOrderSDK.approveMakerTokenForLimitOrder(
+      orderInput.makerAmount,
+      orderInput.makerAsset
+    );
+
+  // builds + signs + posts order to API
+  // new limit order returned from API
+  const newLimitOrder: LimitOrderFromApi = await limitOrderSDK.submitLimitOrder(
+    orderInput
+  );
+
+  // to act as order taker
+  const anotherAccount = '0x5678...';
+
+  const limitOrdersSDKForTaker = constructPartialSDK(
+    {
+      chainId: 1,
+      fetcher,
+      contractCaller: constructEthersContractCaller(
+        {
+          ethersProviderOrSigner: provider,
+          EthersContract: ethers.Contract,
+        },
+        anotherAccount
+      ),
+    },
+    constructAllLimitOrdersHandlers
+  );
+
+  const tx2: ethers.ContractTransaction =
+    await limitOrdersSDKForTaker.approveTakerTokenForLimitOrder(
+      orderInput.takerAmount,
+      orderInput.takerAsset
+    );
+
+  const executingOrder: SwappableOrder = {
+    ...newLimitOrder,
+    permitMakerAsset: newLimitOrder.permitMakerAsset || undefined,
+  };
+
+  const { gas: payloadGas, ...LOPayloadTxParams } =
+    await limitOrdersSDKForTaker.buildLimitOrderTx({
+      srcDecimals: 18,
+      destDecimals: 18,
+      userAddress: anotherAccount, // taker
+      orders: [executingOrder],
+    });
+
+  const tx5Params = {
+    ...LOPayloadTxParams,
+    gasPrice:
+      LOPayloadTxParams.gasPrice &&
+      '0x' + new BigNumber(LOPayloadTxParams.gasPrice).toString(16),
+    maxFeePerGas:
+      LOPayloadTxParams.maxFeePerGas &&
+      '0x' + new BigNumber(LOPayloadTxParams.maxFeePerGas).toString(16),
+    maxPriorityFeePerGas:
+      LOPayloadTxParams.maxPriorityFeePerGas &&
+      '0x' + new BigNumber(LOPayloadTxParams.maxPriorityFeePerGas).toString(16),
+    gasLimit: '0x' + new BigNumber(payloadGas || 5000000).toString(16),
+    value: '0x' + new BigNumber(LOPayloadTxParams.value).toString(16),
+  };
+
+  console.log('SENDING TX', tx5Params);
+
+  assert(
+    provider instanceof ethers.providers.JsonRpcProvider,
+    'provider has signer (JsonRpcProvider)'
+  );
+
+  const tx3 = await provider
+    .getSigner(anotherAccount)
+    .sendTransaction(tx5Params);
+}

package/src/examples/limitOrders_partial.ts

@@ -0,0 +1,171 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import axios from 'axios';
+import BigNumber from 'bignumber.js';
+import { ethers } from 'ethersV5';
+import { assert } from 'ts-essentials';
+import {
+  // swap methods
+  constructPartialSDK,
+  constructEthersContractCaller,
+  constructAxiosFetcher,
+  // limitOrders methods
+  constructBuildLimitOrder,
+  constructCancelLimitOrder,
+  constructSignLimitOrder,
+  constructGetLimitOrders,
+  constructPostLimitOrder,
+  constructApproveTokenForLimitOrder,
+  // extra types
+  SignableOrderData,
+  LimitOrderToSend,
+  constructBuildLimitOrderTx,
+} from '..';
+
+const account = '0x1234...';
+
+const fetcher = constructAxiosFetcher(axios);
+
+// provider must have write access to account
+// this would usually be wallet provider (Metamask)
+const provider = ethers.getDefaultProvider(1);
+const contractCaller = constructEthersContractCaller(
+  {
+    ethersProviderOrSigner: provider,
+    EthersContract: ethers.Contract,
+  },
+  account
+);
+
+// type BuildLimitOrderFunctions
+// & SignLimitOrderFunctions
+// & CancelLimitOrderFunctions<ethers.ContractTransaction>
+// & ApproveTokenFunctions<ethers.ContractTransaction>
+const limitOrderSDK = constructPartialSDK(
+  {
+    chainId: 1,
+    fetcher,
+    contractCaller,
+  },
+  constructBuildLimitOrder,
+  constructCancelLimitOrder,
+  constructSignLimitOrder,
+  constructPostLimitOrder,
+  constructGetLimitOrders,
+  constructApproveTokenForLimitOrder
+);
+
+const DAI = '0x6B175474E89094C44Da98b954EedeAC495271d0F';
+const HEX = '0x2b591e99afe9f32eaa6214f7b7629768c40eeb39';
+
+const orderInput = {
+  nonce: 1,
+  expiry: Math.floor(Date.now() / 1000) + 60 * 60 * 24 * 7, // week from now, in sec
+  makerAsset: DAI,
+  takerAsset: HEX,
+  makerAmount: (1e18).toString(10),
+  takerAmount: (8e18).toString(10),
+  maker: account,
+};
+
+async function run() {
+  /// cancelling current orders
+  const { orders: currentOrders } = await limitOrderSDK.getLimitOrders({
+    maker: account,
+    type: 'LIMIT',
+  });
+
+  if (currentOrders[0]?.orderHash) {
+    const tx1: ethers.ContractTransaction =
+      await limitOrderSDK.cancelLimitOrder(currentOrders[0].orderHash);
+  }
+
+  const moreOrderHashes = currentOrders
+    .slice(1, 2)
+    .map((order) => order.orderHash);
+
+  const tx2: ethers.ContractTransaction =
+    await limitOrderSDK.cancelLimitOrderBulk(moreOrderHashes);
+
+  /// creating a new order
+
+  const tx3: ethers.ContractTransaction =
+    await limitOrderSDK.approveMakerTokenForLimitOrder(
+      orderInput.makerAmount,
+      orderInput.makerAsset
+    );
+
+  const signableOrderData: SignableOrderData =
+    await limitOrderSDK.buildLimitOrder(orderInput);
+
+  const signature: string = await limitOrderSDK.signLimitOrder(
+    signableOrderData
+  );
+
+  const orderToPostToApi: LimitOrderToSend = {
+    ...signableOrderData.data,
+    signature,
+  };
+
+  const newOrder = await limitOrderSDK.postLimitOrder(orderToPostToApi);
+
+  /// filling an order
+
+  // to act as order taker
+  const anotherAccount = '0x5678...';
+
+  const limitOrderSDKForTaker = constructPartialSDK(
+    {
+      chainId: 1,
+      fetcher,
+      contractCaller: constructEthersContractCaller(
+        {
+          ethersProviderOrSigner: provider,
+          EthersContract: ethers.Contract,
+        },
+        anotherAccount
+      ),
+    },
+    constructBuildLimitOrderTx,
+    constructApproveTokenForLimitOrder
+  );
+
+  const tx4: ethers.ContractTransaction =
+    await limitOrderSDKForTaker.approveTakerTokenForLimitOrder(
+      orderInput.takerAmount,
+      orderInput.takerAsset
+    );
+
+  const { gas: payloadGas, ...LOPayloadTxParams } =
+    await limitOrderSDKForTaker.buildLimitOrderTx({
+      srcDecimals: 18,
+      destDecimals: 18,
+      userAddress: anotherAccount, // taker
+      orders: [orderToPostToApi],
+    });
+
+  const tx5Params = {
+    ...LOPayloadTxParams,
+    gasPrice:
+      LOPayloadTxParams.gasPrice &&
+      '0x' + new BigNumber(LOPayloadTxParams.gasPrice).toString(16),
+    maxFeePerGas:
+      LOPayloadTxParams.maxFeePerGas &&
+      '0x' + new BigNumber(LOPayloadTxParams.maxFeePerGas).toString(16),
+    maxPriorityFeePerGas:
+      LOPayloadTxParams.maxPriorityFeePerGas &&
+      '0x' + new BigNumber(LOPayloadTxParams.maxPriorityFeePerGas).toString(16),
+    gasLimit: '0x' + new BigNumber(payloadGas || 5000000).toString(16),
+    value: '0x' + new BigNumber(LOPayloadTxParams.value).toString(16),
+  };
+
+  console.log('SENDING TX', tx5Params);
+
+  assert(
+    provider instanceof ethers.providers.JsonRpcProvider,
+    'provider has signer (JsonRpcProvider)'
+  );
+
+  const tx5 = await provider
+    .getSigner(anotherAccount)
+    .sendTransaction(tx5Params);
+}

package/src/examples/limitOrders_postOrder.ts

@@ -0,0 +1,77 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import axios from 'axios';
+import { ethers } from 'ethersV5';
+
+import {
+  // swap methods
+  constructPartialSDK,
+  constructEthersContractCaller,
+  constructAxiosFetcher,
+  // limitOrders methods
+  constructBuildLimitOrder,
+  constructSignLimitOrder,
+  constructPostLimitOrder,
+  // extra types
+  SignableOrderData,
+  LimitOrderToSend,
+} from '..';
+
+const wallet = ethers.Wallet.createRandom();
+
+const fetcher = constructAxiosFetcher(axios);
+
+const provider = wallet.connect(ethers.getDefaultProvider(1));
+const contractCaller = constructEthersContractCaller(
+  {
+    ethersProviderOrSigner: provider,
+    EthersContract: ethers.Contract,
+  },
+  wallet.address
+);
+
+// type BuildLimitOrderFunctions
+// & SignLimitOrderFunctions
+// & PostLimitOrderFunctions
+
+const limitOrderSDK = constructPartialSDK(
+  {
+    chainId: 1,
+    fetcher,
+    contractCaller,
+  },
+  constructBuildLimitOrder,
+  constructSignLimitOrder,
+  constructPostLimitOrder
+);
+
+const DAI = '0x6B175474E89094C44Da98b954EedeAC495271d0F';
+const HEX = '0x2b591e99afe9f32eaa6214f7b7629768c40eeb39';
+
+const orderInput = {
+  nonce: 1,
+  expiry: Math.floor(Date.now() / 1000) + 60 * 60 * 24 * 7, // week from now, in sec
+  makerAsset: DAI,
+  takerAsset: HEX,
+  makerAmount: (1e18).toString(10),
+  takerAmount: (8e18).toString(10),
+  maker: wallet.address,
+};
+
+async function run() {
+  const signableOrderData: SignableOrderData =
+    await limitOrderSDK.buildLimitOrder(orderInput);
+
+  const signature: string = await limitOrderSDK.signLimitOrder(
+    signableOrderData
+  );
+
+  const orderToPostToApi: LimitOrderToSend = {
+    ...signableOrderData.data,
+    signature,
+  };
+
+  const newOrder = await limitOrderSDK.postLimitOrder(orderToPostToApi);
+  console.log(newOrder);
+}
+
+run();

package/src/examples/partial.ts

@@ -0,0 +1,34 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import axios from 'axios';
+import { ethers } from 'ethersV5';
+import {
+  constructPartialSDK,
+  constructGetAdapters,
+  constructApproveToken,
+  constructEthersContractCaller,
+  constructAxiosFetcher,
+} from '..';
+
+const fetcher = constructAxiosFetcher(axios);
+
+const provider = ethers.getDefaultProvider(1);
+const contractCaller = constructEthersContractCaller({
+  ethersProviderOrSigner: provider,
+  EthersContract: ethers.Contract,
+});
+
+// type AdaptersFunctions & ApproveTokenFunctions<ethers.ContractTransaction>
+const part1 = constructPartialSDK(
+  {
+    chainId: 1,
+    fetcher,
+    contractCaller,
+  },
+  constructGetAdapters,
+  constructApproveToken
+);
+
+// type Promise<AdaptersAsObject>
+const res1 = part1.getAdapters();
+// type Promise<ethers.ContractTransaction>
+const res2 = part1.approveToken('123', '0x...');

package/src/examples/quote.ts

@@ -0,0 +1,205 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import axios from 'axios';
+import { ethers, Wallet } from 'ethersV5';
+import {
+  constructPartialSDK,
+  constructEthersContractCaller,
+  constructAxiosFetcher,
+  constructAllDeltaOrdersHandlers,
+  constructGetQuote,
+  constructSwapSDK,
+  OptimalRate,
+  DeltaPrice,
+  isFetcherError,
+} from '..';
+
+const fetcher = constructAxiosFetcher(axios);
+
+const provider = ethers.getDefaultProvider(1);
+const signer = Wallet.createRandom().connect(provider);
+const account = signer.address;
+const contractCaller = constructEthersContractCaller({
+  ethersProviderOrSigner: provider,
+  EthersContract: ethers.Contract,
+});
+
+// type AdaptersFunctions & ApproveTokenFunctions<ethers.ContractTransaction>
+const quoteSDK = constructPartialSDK(
+  {
+    chainId: 1,
+    fetcher,
+    contractCaller,
+  },
+  constructAllDeltaOrdersHandlers,
+  constructSwapSDK,
+  constructGetQuote
+);
+
+const DAI_TOKEN = '0x6b175474e89094c44da98b954eedeac495271d0f';
+const USDC_TOKEN = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
+
+/**
+ * mode='delta' example
+ */
+async function deltaQuote() {
+  const amount = '1000000000000'; // wei
+
+  const quote = await quoteSDK.getQuote({
+    srcToken: DAI_TOKEN,
+    destToken: USDC_TOKEN,
+    amount,
+    userAddress: account,
+    srcDecimals: 18,
+    destDecimals: 18,
+    mode: 'delta',
+    side: 'SELL',
+    // partner: "..." // if available
+  });
+
+  try {
+    const deltaPrice = quote.delta;
+    await handleDeltaQuote({ amount, deltaPrice });
+  } catch (error) {
+    if (isFetcherError(error)) {
+      const data = error.response?.data;
+      console.log(`Delta Quote failed: ${data.errorType} - ${data.details}`);
+    }
+  }
+}
+
+/**
+ * mode='market' example
+ */
+async function marketQuote() {
+  const amount = '1000000000000'; // wei
+
+  const quote = await quoteSDK.getQuote({
+    srcToken: DAI_TOKEN,
+    destToken: USDC_TOKEN,
+    amount,
+    userAddress: account,
+    srcDecimals: 18,
+    destDecimals: 18,
+    mode: 'market',
+    side: 'SELL',
+    // partner: "..." // if available
+  });
+
+  const TokenTransferProxy = await quoteSDK.getSpender();
+
+  // or sign a Permit1 or Permit2 TransferFrom for TokenTransferProxy
+  const approveTxHash = quoteSDK.approveToken(amount, DAI_TOKEN);
+
+  const txParams = await quoteSDK.buildTx({
+    srcToken: DAI_TOKEN,
+    destToken: USDC_TOKEN,
+    srcAmount: amount,
+    slippage: 250, // 2.5%
+    priceRoute: quote.market,
+    userAddress: account,
+    // partner: '...' // if available
+  });
+
+  const swapTx = await handleMarketQuote({ amount, priceRoute: quote.market });
+}
+
+/**
+ * mode='all' example
+ */
+async function allQuote() {
+  const amount = '1000000000000'; // wei
+
+  const quote = await quoteSDK.getQuote({
+    srcToken: DAI_TOKEN,
+    destToken: USDC_TOKEN,
+    amount,
+    userAddress: account,
+    srcDecimals: 18,
+    destDecimals: 18,
+    mode: 'all',
+    side: 'SELL',
+    // partner: "..." // if available
+  });
+
+  if ('delta' in quote) {
+    const deltaPrice = quote.delta;
+    await handleDeltaQuote({ amount, deltaPrice });
+  } else {
+    console.log(
+      `Delta Quote failed: ${quote.fallbackReason.errorType} - ${quote.fallbackReason.details}`
+    );
+    const swapTx = await handleMarketQuote({
+      amount,
+      priceRoute: quote.market,
+    });
+  }
+}
+
+async function handleDeltaQuote({
+  amount,
+  deltaPrice,
+}: {
+  amount: string;
+  deltaPrice: DeltaPrice;
+}) {
+  /**
+   * refer to examples/delta for more details
+   */
+  const DeltaContract = await quoteSDK.getDeltaContract();
+
+  // or sign a Permit1 or Permit2 TransferFrom for DeltaContract
+  await quoteSDK.approveTokenForDelta(amount, DAI_TOKEN);
+
+  const slippagePercent = 0.5;
+  const destAmountAfterSlippage = BigInt(
+    // get rid of exponential notation
+
+    +(+deltaPrice.destAmount * (1 - slippagePercent / 100)).toFixed(0)
+    // get rid of decimals
+  ).toString(10);
+
+  const deltaAuction = await quoteSDK.submitDeltaOrder({
+    deltaPrice,
+    owner: account,
+    // beneficiary: anotherAccount, // if need to send destToken to another account
+    // permit: "0x1234...", // if signed a Permit1 or Permit2 TransferFrom for DeltaContract
+    srcToken: DAI_TOKEN,
+    destToken: USDC_TOKEN,
+    srcAmount: amount,
+    destAmount: destAmountAfterSlippage, // minimum acceptable destAmount
+  });
+
+  // poll if necessary
+  const auction = await quoteSDK.getDeltaOrderById(deltaAuction.id);
+  if (auction?.status === 'EXECUTED') {
+    console.log('Auction was executed');
+  }
+
+  return auction;
+}
+
+async function handleMarketQuote({
+  amount,
+  priceRoute,
+}: {
+  amount: string;
+  priceRoute: OptimalRate;
+}) {
+  const TokenTransferProxy = await quoteSDK.getSpender();
+
+  // or sign a Permit1 or Permit2 TransferFrom for TokenTransferProxy
+  const approveTxHash = quoteSDK.approveToken(amount, DAI_TOKEN);
+
+  const txParams = await quoteSDK.buildTx({
+    srcToken: DAI_TOKEN,
+    destToken: USDC_TOKEN,
+    srcAmount: amount,
+    slippage: 250, // 2.5%
+    priceRoute,
+    userAddress: account,
+    // partner: '...' // if available
+  });
+
+  const swapTx = await signer.sendTransaction(txParams);
+  return swapTx;
+}

package/src/examples/sdk.ts

@@ -0,0 +1,39 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import axios from 'axios';
+import { ethers } from 'ethersV5';
+import {
+  constructPartialSDK,
+  constructFullSDK,
+  constructGetAdapters,
+  constructEthersV5ContractCaller,
+  constructAxiosFetcher,
+} from '..';
+
+const fetcher = constructAxiosFetcher(axios);
+
+const provider = ethers.getDefaultProvider(1);
+const contractCaller = constructEthersV5ContractCaller({
+  ethersProviderOrSigner: provider,
+  EthersContract: ethers.Contract,
+});
+
+const sdk = constructFullSDK({
+  apiURL: '',
+  chainId: 1,
+  fetcher,
+  contractCaller,
+});
+
+const res = sdk.swap.getAdapters();
+
+// type Promise<ContractTransaction>
+const txResponse = sdk.swap.approveToken('1', '0x...');
+// type Promise<ContractTransaction[]>
+const txResponses = sdk.swap.approveTokenBulk('1', ['0x...']);
+
+const partial = constructPartialSDK(
+  { apiURL: '', chainId: 1, fetcher },
+  constructGetAdapters
+);
+
+const res1 = partial.getAdapters();