@velora-dex/sdk 8.0.0 → 8.1.0

package/docs/DELTA.md

@@ -80,10 +80,41 @@ const deltaAuction = await deltaSDK.submitDeltaOrder({
 
 ```ts
 // poll if necessary
-const auction = await deltaSDK.getDeltaOrderById(deltaAuction.id);
-if (auction?.status === 'EXECUTED') {
-  console.log('Auction was executed');
+function isExecutedDeltaAuction(
+  auction: Omit<DeltaAuction, 'signature'>,
+  waitForCrosschain = true // only consider executed when destChain work is done
+) {
+  if (auction.status !== 'EXECUTED') return false;
+
+  // crosschain Order is executed on destChain if bridgeStatus is filled
+  if (waitForCrosschain && auction.order.bridge.destinationChainId !== 0) {
+    return auction.bridgeStatus === 'filled';
+  }
+
+  return true;
 }
+
+function fetchOrderPeriodically(auctionId: string) {
+  const intervalId = setInterval(async () => {
+    const auction = await simpleSDK.delta.getDeltaOrderById(auctionId);
+    console.log('checks: ', auction); // Handle or log the fetched auction as needed
+
+    if (isExecutedDeltaAuction(auction)) {
+      clearInterval(intervalId); // Stop interval if completed
+      console.log('Order completed');
+    }
+  }, 3000);
+  console.log('Order Pending');
+  // Return intervalId to enable clearing the interval if needed externally
+  return intervalId;
+}
+
+function startStatusCheck(auctionId: string) {
+  const intervalId = fetchOrderPeriodically(auctionId);
+  setTimeout(() => clearInterval(intervalId), 60000 * 5); // Stop after 5 minutes
+}
+
+startStatusCheck(deltaAuction.id);
 ```
 
 #### A more detailed example of Delta Order usage can be found in [examples/delta](./src/examples/delta.ts)
@@ -200,8 +231,39 @@ This is necessary because Across, the service facilitating crosschain bridging,
 
 ```ts
 // poll if necessary
-const auction = await deltaSDK.getDeltaOrderById(deltaAuction.id);
-if (auction?.status === 'EXECUTED' && auction.bridgeStatus === "filled") {
-  console.log('Auction was executed');
+function isExecutedDeltaAuction(
+  auction: Omit<DeltaAuction, 'signature'>,
+  waitForCrosschain = true // only consider executed when destChain work is done
+) {
+  if (auction.status !== 'EXECUTED') return false;
+
+  // crosschain Order is executed on destChain if bridgeStatus is filled
+  if (waitForCrosschain && auction.order.bridge.destinationChainId !== 0) {
+    return auction.bridgeStatus === 'filled';
+  }
+
+  return true;
 }
-```
+
+function fetchOrderPeriodically(auctionId: string) {
+  const intervalId = setInterval(async () => {
+    const auction = await simpleSDK.delta.getDeltaOrderById(auctionId);
+    console.log('checks: ', auction); // Handle or log the fetched auction as needed
+
+    if (isExecutedDeltaAuction(auction)) {
+      clearInterval(intervalId); // Stop interval if completed
+      console.log('Order completed');
+    }
+  }, 3000);
+  console.log('Order Pending');
+  // Return intervalId to enable clearing the interval if needed externally
+  return intervalId;
+}
+
+function startStatusCheck(auctionId: string) {
+  const intervalId = fetchOrderPeriodically(auctionId);
+  setTimeout(() => clearInterval(intervalId), 60000 * 5); // Stop after 5 minutes
+}
+
+startStatusCheck(deltaAuction.id);
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velora-dex/sdk",
-  "version": "8.0.0",
+  "version": "8.1.0",
   "main": "dist/index.js",
   "module": "dist/sdk.esm.js",
   "typings": "dist/index.d.ts",

package/src/examples/delta.ts

@@ -7,6 +7,7 @@ import {
   constructAxiosFetcher,
   constructAllDeltaOrdersHandlers,
 } from '..';
+import { startStatusCheck } from './helpers/delta';
 
 const fetcher = constructAxiosFetcher(axios);
 
@@ -40,7 +41,7 @@ async function simpleDeltaFlow() {
     amount,
     userAddress: account,
     srcDecimals: 18,
-    destDecimals: 18,
+    destDecimals: 6,
     // partner: "..." // if available
   });
 
@@ -70,10 +71,7 @@ async function simpleDeltaFlow() {
   });
 
   // poll if necessary
-  const auction = await deltaSDK.getDeltaOrderById(deltaAuction.id);
-  if (auction?.status === 'EXECUTED') {
-    console.log('Auction was executed');
-  }
+  startStatusCheck(() => deltaSDK.getDeltaOrderById(deltaAuction.id));
 }
 async function manualDeltaFlow() {
   const amount = '1000000000000'; // wei
@@ -84,7 +82,7 @@ async function manualDeltaFlow() {
     amount,
     userAddress: account,
     srcDecimals: 18,
-    destDecimals: 18,
+    destDecimals: 6,
     // partner: "..." // if available
   });
 
@@ -120,8 +118,5 @@ async function manualDeltaFlow() {
   });
 
   // poll if necessary
-  const auction = await deltaSDK.getDeltaOrderById(deltaAuction.id);
-  if (auction?.status === 'EXECUTED') {
-    console.log('Auction was executed');
-  }
+  startStatusCheck(() => deltaSDK.getDeltaOrderById(deltaAuction.id));
 }

package/src/examples/helpers/delta.ts

@@ -0,0 +1,39 @@
+import { DeltaAuction, GetDeltaOrdersFunctions } from '../..';
+
+function isExecutedDeltaAuction(
+  auction: Omit<DeltaAuction, 'signature'>,
+  waitForCrosschain = true // only consider executed when destChain work is done
+) {
+  if (auction.status !== 'EXECUTED') return false;
+
+  // crosschain Order is executed on destChain if bridgeStatus is filled
+  if (waitForCrosschain && auction.order.bridge.destinationChainId !== 0) {
+    return auction.bridgeStatus === 'filled';
+  }
+
+  return true;
+}
+
+type GetDeltaOrderFn = () => ReturnType<
+  GetDeltaOrdersFunctions['getDeltaOrderById']
+>;
+
+function fetchOrderPeriodically(getDeltaOrder: GetDeltaOrderFn) {
+  const intervalId = setInterval(async () => {
+    const auction = await getDeltaOrder();
+    console.log('checks: ', auction); // Handle or log the fetched auction as needed
+
+    if (isExecutedDeltaAuction(auction)) {
+      clearInterval(intervalId); // Stop interval if completed
+      console.log('Order completed');
+    }
+  }, 3000);
+  console.log('Order Pending');
+  // Return intervalId to enable clearing the interval if needed externally
+  return intervalId;
+}
+
+export function startStatusCheck(getDeltaOrder: GetDeltaOrderFn) {
+  const intervalId = fetchOrderPeriodically(getDeltaOrder);
+  setTimeout(() => clearInterval(intervalId), 60000 * 5); // Stop after 5 minutes
+}

package/src/examples/quote.ts

@@ -12,6 +12,7 @@ import {
   DeltaPrice,
   isFetcherError,
 } from '..';
+import { startStatusCheck } from './helpers/delta';
 
 const fetcher = constructAxiosFetcher(axios);
 
@@ -50,7 +51,7 @@ async function deltaQuote() {
     amount,
     userAddress: account,
     srcDecimals: 18,
-    destDecimals: 18,
+    destDecimals: 6,
     mode: 'delta',
     side: 'SELL',
     // partner: "..." // if available
@@ -79,7 +80,7 @@ async function marketQuote() {
     amount,
     userAddress: account,
     srcDecimals: 18,
-    destDecimals: 18,
+    destDecimals: 6,
     mode: 'market',
     side: 'SELL',
     // partner: "..." // if available
@@ -115,7 +116,7 @@ async function allQuote() {
     amount,
     userAddress: account,
     srcDecimals: 18,
-    destDecimals: 18,
+    destDecimals: 6,
     mode: 'all',
     side: 'SELL',
     // partner: "..." // if available
@@ -170,12 +171,9 @@ async function handleDeltaQuote({
   });
 
   // poll if necessary
-  const auction = await quoteSDK.getDeltaOrderById(deltaAuction.id);
-  if (auction?.status === 'EXECUTED') {
-    console.log('Auction was executed');
-  }
+  startStatusCheck(() => quoteSDK.getDeltaOrderById(deltaAuction.id));
 
-  return auction;
+  return deltaAuction;
 }
 
 async function handleMarketQuote({

package/src/examples/simpleQuote.ts

@@ -2,6 +2,7 @@
 import axios from 'axios';
 import { ethers } from 'ethersV5';
 import { constructSimpleSDK } from '..';
+import { startStatusCheck } from './helpers/delta';
 
 const DAI_TOKEN = '0x6b175474e89094c44da98b954eedeac495271d0f';
 const USDC_TOKEN = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
@@ -31,7 +32,7 @@ async function allQuote() {
     amount,
     userAddress: account,
     srcDecimals: 18,
-    destDecimals: 18,
+    destDecimals: 6,
     mode: 'all', // Delta quote if possible, with fallback to Market price
     side: 'SELL',
     // partner: "..." // if available
@@ -68,10 +69,7 @@ async function allQuote() {
     });
 
     // poll if necessary
-    const auction = await simpleSDK.delta.getDeltaOrderById(deltaAuction.id);
-    if (auction?.status === 'EXECUTED') {
-      console.log('Auction was executed');
-    }
+    startStatusCheck(() => simpleSDK.delta.getDeltaOrderById(deltaAuction.id));
   } else {
     console.log(
       `Delta Quote failed: ${quote.fallbackReason.errorType} - ${quote.fallbackReason.details}`

package/src/helpers/misc.ts

@@ -90,6 +90,9 @@ export class FetcherError extends Error implements FetcherErrorInterface {
     const { data, status } = response;
     this.status = status;
     this.message = isDataWithError(data) ? data.error : message;
+    this.message = isDataWithError2(data)
+      ? `${data.errorType}${data.description ? `: ${data.description}` : ''}`
+      : this.message;
   }
 }
 // to turn `object -> Record` for indexed variable access
@@ -100,6 +103,11 @@ function isObject(obj: unknown): obj is Record<string | symbol, any> {
 export function isDataWithError(data: unknown): data is { error: string } {
   return isObject(data) && typeof data['error'] === 'string';
 }
+export function isDataWithError2(
+  data: unknown
+): data is { errorType: string; description?: string } {
+  return isObject(data) && typeof data['errorType'] === 'string';
+}
 
 export type ExtractAbiMethodNames<T extends readonly { name: string }[]> =
   T[number]['name'];

package/src/methods/delta/buildCrosschainOrderBridge.ts

@@ -3,7 +3,7 @@ import type { ConstructFetchInput, RequestParameters } from '../../types';
 import { BridgePrice } from './getDeltaPrice';
 import { constructGetMulticallHandlers } from './getMulticallHandlers';
 import {
-  getDeltaBridgeAndDestToken,
+  getDeltaBridge,
   GetDeltaBridgeAndDestTokenOutput,
 } from './helpers/across';
 import { BeneficiaryType } from '../common/orders/types';
@@ -18,7 +18,7 @@ export type BuildCrosschainOrderBridgeParams = {
   beneficiaryType: BeneficiaryType;
 
   /** @description price response received from /delta/prices (getDeltaPrice method) */
-  deltaPrice: Pick<BridgePrice, 'bridgeFee' | 'destToken'>;
+  deltaPrice: Pick<BridgePrice, 'bridgeFee' | 'bridge'>;
 };
 
 type BuildCrosschainOrderBridge = (
@@ -46,8 +46,13 @@ export const constructBuildCrosschainOrderBridge = (
     requestParams
   ) => {
     assert(
-      chainId !== destChainId,
-      '`destChainId` must be different from `chainId` for crosschain Order.bridge'
+      chainId !== deltaPrice.bridge.destinationChainId,
+      '`deltaPrice.bridge.destinationChainId` must be different from `chainId` for crosschain Order.bridge'
+    );
+
+    assert(
+      destChainId === deltaPrice.bridge.destinationChainId,
+      '`destChainId` must match `deltaPrice.bridge.destinationChainId` for crosschain Order.bridge'
     );
 
     const getMulticallHandler = async (chainId: number) => {
@@ -62,19 +67,17 @@ export const constructBuildCrosschainOrderBridge = (
       return multicallHandler;
     };
 
-    const { bridge, orderChanges } = await getDeltaBridgeAndDestToken({
+    const { bridge } = await getDeltaBridge({
       destTokenDestChain: destToken,
-      destChainId: destChainId,
-      destTokenSrcChain: deltaPrice.destToken,
-      srcChainId: chainId,
+      destChainId,
       bridgeFee: deltaPrice.bridgeFee,
+      bridgeOutputToken: deltaPrice.bridge.outputToken,
       beneficiaryType,
       getMulticallHandler,
     });
 
     return {
       bridge,
-      orderChanges,
     };
   };
 

package/src/methods/delta/buildDeltaOrder.ts

@@ -9,7 +9,7 @@ import {
   type BuildDeltaOrderDataInput,
   type SignableDeltaOrderData,
 } from './helpers/buildDeltaOrderData';
-import { Bridge, DeltaAuctionOrder } from './helpers/types';
+import { Bridge } from './helpers/types';
 import { constructBuildCrosschainOrderBridge } from './buildCrosschainOrderBridge';
 import { BeneficiaryType } from '../common/orders/types';
 export type { SignableDeltaOrderData } from './helpers/buildDeltaOrderData';
@@ -48,7 +48,7 @@ export type BuildDeltaOrderDataParams = {
     DeltaPrice,
     'destAmount' | 'partner' | 'partnerFee' | 'destToken'
   > &
-    Partial<Pick<BridgePrice, 'bridgeFee'>>;
+    Partial<Pick<BridgePrice, 'bridgeFee' | 'bridge'>>;
 
   /** @description partner fee in basis points (bps), 50bps=0.5% */
   partnerFeeBps?: number;
@@ -125,7 +125,6 @@ export const constructBuildDeltaOrder = (
 
     // Bridge is necessary for Crosschain Delta Orders
     let bridge = options.bridge;
-    let partialChangedOrder: Pick<DeltaAuctionOrder, 'destToken'> | null = null;
 
     // give preference to user-provided bridge
     if (!bridge) {
@@ -138,23 +137,25 @@ export const constructBuildDeltaOrder = (
           deltaPrice.bridgeFee,
           '`bridgeFee` is required in `deltaPrice` for crosschain Delta Orders'
         );
+        assert(
+          deltaPrice.bridge,
+          '`bridge` is required in `deltaPrice` for crosschain Delta Orders'
+        );
 
-        const { bridge: constructedBridge, orderChanges } =
-          await buildCrosschainOrderBridge(
-            {
-              destToken: options.destToken,
-              destChainId: options.destChainId,
-              beneficiaryType: options.beneficiaryType ?? 'EOA',
-              deltaPrice: {
-                bridgeFee: deltaPrice.bridgeFee,
-                destToken: deltaPrice.destToken,
-              },
+        const { bridge: constructedBridge } = await buildCrosschainOrderBridge(
+          {
+            destToken: options.destToken,
+            destChainId: options.destChainId,
+            beneficiaryType: options.beneficiaryType ?? 'EOA',
+            deltaPrice: {
+              bridgeFee: deltaPrice.bridgeFee,
+              bridge: deltaPrice.bridge, // already contains destChainId and outputToken
             },
-            requestParams
-          );
+          },
+          requestParams
+        );
 
         bridge = constructedBridge;
-        partialChangedOrder = orderChanges;
       } else {
         // 0-values bridge for same-chain Orders
         bridge = DEFAULT_BRIDGE;
@@ -165,8 +166,9 @@ export const constructBuildDeltaOrder = (
       owner: options.owner,
       beneficiary: options.beneficiary,
       srcToken: options.srcToken,
-      // for some cases of WETH<->ETH crosschain swaps, the destToken is to WETH or ETH
-      destToken: partialChangedOrder?.destToken ?? options.destToken,
+      // for some cases of WETH->ETH crosschain swaps, the destToken is changed to WETH or ETH,
+      // this is already reflected in deltaPrice
+      destToken: options.deltaPrice.destToken,
       srcAmount: options.srcAmount,
       destAmount: options.destAmount,
       expectedDestAmount: options.deltaPrice.destAmount,

package/src/methods/delta/getDeltaPrice.ts

@@ -1,3 +1,4 @@
+import { Bridge } from '../..';
 import { API_URL, SwapSide } from '../../constants';
 import { constructSearchString } from '../../helpers/misc';
 import type { ConstructFetchInput, RequestParameters } from '../../types';
@@ -51,6 +52,7 @@ export type BridgePrice = DeltaPrice & {
   bridgeFee: string;
   bridgeFeeUSD: string;
   poolAddress: string;
+  bridge: Pick<Bridge, 'destinationChainId' | 'outputToken'>;
 };
 
 type DeltaPriceResponse = {

package/src/methods/delta/helpers/across.ts

@@ -1,7 +1,7 @@
 import { assert } from 'ts-essentials';
 import { ZERO_ADDRESS } from '../../common/orders/buildOrderData';
 import { BeneficiaryType } from '../../common/orders/types';
-import { Bridge, DeltaAuctionOrder } from './types';
+import { Bridge } from './types';
 
 export const ACROSS_WETH_ADDRESSES_MAP: Record<number, string> = {
   // Mainnet
@@ -32,6 +32,8 @@ export const ACROSS_WETH_ADDRESSES_MAP: Record<number, string> = {
   81457: '0x4300000000000000000000000000000000000004',
   // Blast Sepolia
   168587773: '0x4200000000000000000000000000000000000023',
+  // BSC
+  56: '0x2170Ed0880ac9A755fd29B2688956BD959F933F8',
   // Ink
   57073: '0x4200000000000000000000000000000000000006',
   // Ink Sepolia
@@ -98,11 +100,10 @@ export function isETHaddress(tokenAddress: string): boolean {
 // https://developers.velora.xyz/api/velora-api/velora-delta-api/build-a-delta-order-to-sign
 
 export type GetDeltaBridgeAndDestTokenInput = {
-  destTokenDestChain: string;
+  destTokenDestChain: string; // the token user wants to ultimately receive
   destChainId: number;
-  destTokenSrcChain: string;
-  srcChainId: number;
   bridgeFee: string;
+  bridgeOutputToken: string; // the token on the destination chain, in case of WETH -> ETH, will be different from destTokenDestChain and unwrapped
   beneficiaryType: BeneficiaryType;
   getMulticallHandler: (chainId: number) => Promise<string>;
 };
@@ -110,16 +111,13 @@ export type GetDeltaBridgeAndDestTokenInput = {
 export type GetDeltaBridgeAndDestTokenOutput = {
   /** @description The bridge object to be used for Order.bridge */
   bridge: Bridge;
-  /** @description The changes to be made to the Order */
-  orderChanges: Pick<DeltaAuctionOrder, 'destToken'>;
 };
 
-export async function getDeltaBridgeAndDestToken({
+export async function getDeltaBridge({
   destTokenDestChain,
   destChainId,
-  destTokenSrcChain,
-  srcChainId,
   bridgeFee,
+  bridgeOutputToken,
   beneficiaryType,
   getMulticallHandler,
 }: GetDeltaBridgeAndDestTokenInput): Promise<GetDeltaBridgeAndDestTokenOutput> {
@@ -127,48 +125,20 @@ export async function getDeltaBridgeAndDestToken({
     beneficiaryType === 'EOA' || beneficiaryType === 'SmartContract',
     'beneficiaryType must be EOA or SmartContract'
   );
-  const WETH_SRC_CHAIN = ACROSS_WETH_ADDRESSES_MAP[srcChainId];
-
-  const WETH_DEST_CHAIN = ACROSS_WETH_ADDRESSES_MAP[destChainId];
-
-  if (!WETH_SRC_CHAIN || !WETH_DEST_CHAIN) {
-    // this should never happen as we only expect crosschain Delta Orders for supported chains
-    const bridge: Bridge = {
-      maxRelayerFee: bridgeFee,
-      destinationChainId: destChainId,
-      outputToken: destTokenDestChain,
-      multiCallHandler: ZERO_ADDRESS,
-    };
-
-    return {
-      bridge,
-      orderChanges: {
-        destToken: destTokenSrcChain,
-      },
-    };
-  }
+
+  const outputToken = bridgeOutputToken.toLowerCase(); // for uniformity
+
+  let multiCallHandler: string = ZERO_ADDRESS;
 
   if (beneficiaryType === 'EOA' && isETHaddress(destTokenDestChain)) {
     /*
     if beneficiary is an EOA and destToken on destChain = ETH
-    order.destToken=ETH
-    order.bridge.outputToken=WETH_DEST_CHAIN
+    order.destToken=ETH (deltaPrice already contains correct destToken)
+    order.bridge.outputToken=WETH_DEST_CHAIN (deltaPrice already contains correct bridge.outputToken)
     order.bridge.multiCallHandler=NULL_ADDRESS
     */
 
-    const bridge: Bridge = {
-      maxRelayerFee: bridgeFee,
-      destinationChainId: destChainId,
-      outputToken: WETH_DEST_CHAIN,
-      multiCallHandler: ZERO_ADDRESS,
-    };
-
-    return {
-      bridge,
-      orderChanges: {
-        destToken: ETH_ADDRESS,
-      },
-    };
+    multiCallHandler = ZERO_ADDRESS;
   }
   if (
     beneficiaryType === 'EOA' &&
@@ -176,43 +146,21 @@ export async function getDeltaBridgeAndDestToken({
   ) {
     /*
     if beneficiary is an EOA and destToken on destChain = WETH
-    order.destToken=WETH
-    order.bridge.outputToken=WETH_DEST_CHAIN
+    order.destToken=WETH (deltaPrice already contains correct destToken)
+    order.bridge.outputToken=WETH_DEST_CHAIN (deltaPrice already contains correct bridge.outputToken)
     order.bridge.multiCallHandler=MULTI_CALL_HANDLER
     */
-    const bridge: Bridge = {
-      maxRelayerFee: bridgeFee,
-      destinationChainId: destChainId,
-      outputToken: WETH_DEST_CHAIN,
-      multiCallHandler: await getMulticallHandler(destChainId),
-    };
-    return {
-      bridge,
-      orderChanges: {
-        destToken: WETH_SRC_CHAIN,
-      },
-    };
+    multiCallHandler = await getMulticallHandler(destChainId);
   }
 
   if (beneficiaryType === 'SmartContract' && isETHaddress(destTokenDestChain)) {
     /* 
       if beneficiary is a contract and destToken on destChain = ETH
-      order.destToken=ETH
-      order.bridge.outputToken=WETH_DEST_CHAIN
+      order.destToken=ETH (deltaPrice already contains correct destToken)
+      order.bridge.outputToken=WETH_DEST_CHAIN (deltaPrice already contains correct bridge.outputToken)
       order.bridge.multiCallHandler=MULTI_CALL_HANDLER
       */
-    const bridge: Bridge = {
-      maxRelayerFee: bridgeFee,
-      destinationChainId: destChainId,
-      outputToken: WETH_DEST_CHAIN,
-      multiCallHandler: await getMulticallHandler(destChainId),
-    };
-    return {
-      bridge,
-      orderChanges: {
-        destToken: ETH_ADDRESS,
-      },
-    };
+    multiCallHandler = await getMulticallHandler(destChainId);
   }
 
   if (
@@ -221,35 +169,21 @@ export async function getDeltaBridgeAndDestToken({
   ) {
     /*
       if beneficiary is a contract and destToken on destChain = WETH
-      order.destToken=WETH
-      order.bridge.outputToken=WETH_DEST_CHAIN
+      order.destToken=WETH (deltaPrice already contains correct destToken)
+      order.bridge.outputToken=WETH_DEST_CHAIN (deltaPrice already contains correct bridge.outputToken)
       order.bridge.multiCallHandler=NULL_ADDRESS
     */
-    const bridge: Bridge = {
-      maxRelayerFee: bridgeFee,
-      destinationChainId: destChainId,
-      outputToken: WETH_DEST_CHAIN,
-      multiCallHandler: ZERO_ADDRESS,
-    };
-    return {
-      bridge,
-      orderChanges: {
-        destToken: WETH_SRC_CHAIN,
-      },
-    };
+    multiCallHandler = ZERO_ADDRESS;
   }
 
   const bridge: Bridge = {
     maxRelayerFee: bridgeFee,
     destinationChainId: destChainId,
-    outputToken: destTokenDestChain,
-    multiCallHandler: ZERO_ADDRESS,
+    outputToken,
+    multiCallHandler,
   };
 
   return {
     bridge,
-    orderChanges: {
-      destToken: destTokenSrcChain,
-    },
   };
 }