@velora-dex/sdk 8.0.0 → 8.1.1-dev.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.1-dev.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/helpers/providers/viem.ts

@@ -23,7 +23,10 @@ import { TransactionParams } from '../../methods/swap/transaction';
 
 export type MinViemClient = Partial<
   Pick<PublicActions<Transport, Chain>, 'readContract'> &
-    Pick<WalletActions<Chain>, 'writeContract' | 'signTypedData'>
+    Pick<
+      WalletActions<Chain>,
+      'writeContract' | 'signTypedData' | 'signMessage'
+    >
 > & { account?: Account };
 
 export const constructContractCaller = (

package/src/index.ts

@@ -206,6 +206,10 @@ import {
   QuoteWithMarketPrice,
   QuoteWithMarketPriceAsFallback,
 } from './methods/quote/getQuote';
+import {
+  CancelDeltaOrderFunctions,
+  constructCancelDeltaOrder,
+} from './methods/delta/cancelDeltaOrder';
 
 export { constructSwapSDK, SwapSDKMethods } from './methods/swap';
 
@@ -289,6 +293,7 @@ export {
   constructGetDeltaContract,
   constructGetDeltaPrice,
   constructGetDeltaOrders,
+  constructCancelDeltaOrder,
   constructApproveTokenForDelta,
   // Quote methods
   constructGetQuote,
@@ -378,6 +383,7 @@ export type {
   GetDeltaPriceFunctions,
   GetDeltaOrdersFunctions,
   ApproveTokenForDeltaFunctions,
+  CancelDeltaOrderFunctions,
   // types for Quote methods
   GetQuoteFunctions,
   QuoteParams,

package/src/methods/delta/buildCrosschainOrderBridge.ts

@@ -1,9 +1,9 @@
 import { assert } from 'ts-essentials';
 import type { ConstructFetchInput, RequestParameters } from '../../types';
 import { BridgePrice } from './getDeltaPrice';
-import { constructGetMulticallHandlers } from './getMulticallHandlers';
+// 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: BridgePrice;
 };
 
 type BuildCrosschainOrderBridge = (
@@ -39,18 +39,23 @@ export const constructBuildCrosschainOrderBridge = (
   const { chainId } = options;
 
   // cached internally for `multicall` contracts
-  const { getMulticallHandlers } = constructGetMulticallHandlers(options);
+  // const { getMulticallHandlers } = constructGetMulticallHandlers(options);
 
   const buildCrosschainOrderBridge: BuildCrosschainOrderBridge = async (
     { destToken, destChainId, beneficiaryType, deltaPrice },
     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'
     );
 
-    const getMulticallHandler = async (chainId: number) => {
+    assert(
+      destChainId === deltaPrice.bridge.destinationChainId,
+      '`destChainId` must match `deltaPrice.bridge.destinationChainId` for crosschain Order.bridge'
+    );
+
+    /* const getMulticallHandler = async (chainId: number) => {
       const multicallHandlersMap = await getMulticallHandlers(requestParams);
       const multicallHandler = multicallHandlersMap[chainId];
 
@@ -62,19 +67,26 @@ 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,
-    });
+    }); */
+
+    // @TODO remove the whole buildCrosschainOrderBridge() when API provides BridgePrice.bridge = whole Bridge object
+    const bridge = {
+      protocolSelector: '0x00000000',
+      scalingFactor: 0,
+      protocolData: '0x',
+      destinationChainId: deltaPrice.bridge.destinationChainId,
+      outputToken: deltaPrice.bridge.outputToken,
+    };
 
     return {
       bridge,
-      orderChanges,
     };
   };
 

package/src/methods/delta/buildDeltaOrder.ts

@@ -1,19 +1,23 @@
-import { assert } from 'ts-essentials';
-import type { ConstructFetchInput, RequestParameters } from '../../types';
-import { ZERO_ADDRESS } from '../common/orders/buildOrderData';
+import type {
+  ConstructFetchInput,
+  EnumerateLiteral,
+  RequestParameters,
+} from '../../types';
 import { constructGetDeltaContract } from './getDeltaContract';
-import { BridgePrice, DeltaPrice } from './getDeltaPrice';
+import { BridgePrice } from './getDeltaPrice';
 import { constructGetPartnerFee } from './getPartnerFee';
 import {
   buildDeltaSignableOrderData,
   type BuildDeltaOrderDataInput,
   type SignableDeltaOrderData,
 } from './helpers/buildDeltaOrderData';
-import { Bridge, DeltaAuctionOrder } from './helpers/types';
-import { constructBuildCrosschainOrderBridge } from './buildCrosschainOrderBridge';
+import { SwapSideToOrderKind } from './helpers/types';
 import { BeneficiaryType } from '../common/orders/types';
+import { SwapSide } from '../../constants';
 export type { SignableDeltaOrderData } from './helpers/buildDeltaOrderData';
 
+type SwapSideUnion = EnumerateLiteral<typeof SwapSide>;
+
 export type BuildDeltaOrderDataParams = {
   /** @description The address of the order owner */
   owner: string;
@@ -36,8 +40,6 @@ export type BuildDeltaOrderDataParams = {
   /** @description Partner string. */
   partner?: string;
 
-  /** @description The bridge input */
-  bridge?: Bridge;
   /** @description Destination Chain ID for Crosschain Orders */
   destChainId?: number;
   /** @description Whether the beneficiary is a contract. Needed to automatically fill in crosschain Bridge */
@@ -45,10 +47,14 @@ export type BuildDeltaOrderDataParams = {
 
   /** @description price response received from /delta/prices (getDeltaPrice method) */
   deltaPrice: Pick<
-    DeltaPrice,
-    'destAmount' | 'partner' | 'partnerFee' | 'destToken'
-  > &
-    Partial<Pick<BridgePrice, 'bridgeFee'>>;
+    BridgePrice,
+    | 'destAmount'
+    | 'partner'
+    | 'partnerFee'
+    | 'destToken'
+    | 'srcAmount'
+    | 'bridge'
+  >;
 
   /** @description partner fee in basis points (bps), 50bps=0.5% */
   partnerFeeBps?: number;
@@ -56,6 +62,11 @@ export type BuildDeltaOrderDataParams = {
   partnerAddress?: string;
   /** @description take surplus */
   partnerTakesSurplus?: boolean;
+
+  /** @description The side of the order. Default is SELL */
+  side?: SwapSideUnion;
+  /** @description Metadata for the order, hex string */
+  metadata?: string;
 };
 
 type BuildDeltaOrder = (
@@ -68,14 +79,6 @@ export type BuildDeltaOrderFunctions = {
   buildDeltaOrder: BuildDeltaOrder;
 };
 
-// for same-chain Orders, all 0 params
-const DEFAULT_BRIDGE: Bridge = {
-  maxRelayerFee: '0',
-  destinationChainId: 0,
-  outputToken: ZERO_ADDRESS,
-  multiCallHandler: ZERO_ADDRESS,
-};
-
 export const constructBuildDeltaOrder = (
   options: ConstructFetchInput
 ): BuildDeltaOrderFunctions => {
@@ -86,9 +89,6 @@ export const constructBuildDeltaOrder = (
   // cached internally for `partner`
   const { getPartnerFee } = constructGetPartnerFee(options);
 
-  const { buildCrosschainOrderBridge } =
-    constructBuildCrosschainOrderBridge(options);
-
   const buildDeltaOrder: BuildDeltaOrder = async (options, requestParams) => {
     const ParaswapDelta = await getDeltaContract(requestParams);
     if (!ParaswapDelta) {
@@ -121,58 +121,28 @@ export const constructBuildDeltaOrder = (
         partnerTakesSurplus ?? partnerFeeResponse.takeSurplus;
     }
 
-    ////// Bridge logic //////
-
-    // 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) {
-      // no bridge passed in input
-
-      if (options.destChainId && chainId !== options.destChainId) {
-        // crosschain Delta Order
-        const deltaPrice = options.deltaPrice;
-        assert(
-          deltaPrice.bridgeFee,
-          '`bridgeFee` 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,
-              },
-            },
-            requestParams
-          );
-
-        bridge = constructedBridge;
-        partialChangedOrder = orderChanges;
-      } else {
-        // 0-values bridge for same-chain Orders
-        bridge = DEFAULT_BRIDGE;
-      }
-    }
+    const swapSide = options.side ?? SwapSide.SELL;
+
+    const expectedAmount =
+      swapSide === SwapSide.SELL
+        ? options.deltaPrice.destAmount
+        : options.deltaPrice.srcAmount;
 
     const input: BuildDeltaOrderDataInput = {
       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,
+      expectedAmount,
       deadline: options.deadline,
       nonce: options.nonce?.toString(10),
       permit: options.permit,
+      kind: SwapSideToOrderKind[swapSide],
+      metadata: options.metadata,
 
       chainId,
       paraswapDeltaAddress: ParaswapDelta,
@@ -180,7 +150,7 @@ export const constructBuildDeltaOrder = (
       partnerTakesSurplus,
       partnerFeeBps,
 
-      bridge,
+      bridge: options.deltaPrice.bridge, // ZERO_BRIDGE for same-chain Orders
     };
 
     return buildDeltaSignableOrderData(input);