@velora-dex/sdk 8.0.0 → 8.1.1-dev.0

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

@@ -1,3 +1,15 @@
+import { SwapSide } from '../../../constants';
+
+enum OrderKind {
+  Sell = 0,
+  Buy = 1,
+}
+
+export const SwapSideToOrderKind = {
+  [SwapSide.SELL]: OrderKind.Sell,
+  [SwapSide.BUY]: OrderKind.Buy,
+} as const;
+
 export type DeltaAuctionOrder = {
   /** @description The address of the order owner */
   owner: string;
@@ -11,8 +23,12 @@ export type DeltaAuctionOrder = {
   srcAmount: string; // wei
   /** @description The minimum amount of dest token to receive */
   destAmount: string; // wei
-  /** @description The expected amount of dest token to receive */
-  expectedDestAmount: string; // wei
+  /** @description The expected amount of token to receive */
+  expectedAmount: string; // wei
+  /** @description The kind of the order */
+  kind: OrderKind;
+  /** @description Metadata for the order, hex string */
+  metadata: string;
   /** @description The deadline for the order */
   deadline: number; // seconds
   /** @description The nonce of the order */
@@ -26,22 +42,28 @@ export type DeltaAuctionOrder = {
 };
 
 export type Bridge = {
-  maxRelayerFee: string;
+  protocolSelector: string; // Hex string
   destinationChainId: number;
   /** @description The address of the output token. Same as Order.destToken but on destination chain, so can still be a different address */
   outputToken: string;
-  /** @description The address of the multiCallHandler on destination chain, used to unwrap WETH and send to Smart Contract receiver. Must be non-zero when receiver address is a SmartContract wallet and need to send Native ETH */
-  multiCallHandler: string;
+  scalingFactor: number;
+
+  /** @description Data specific to the protocol */
+  protocolData: string; // Hex string
 };
 
 type DeltaAuctionStatus =
   | 'NOT_STARTED'
-  | 'POSTED'
   | 'RUNNING'
   | 'EXECUTING'
   | 'EXECUTED'
   | 'FAILED'
-  | 'EXPIRED';
+  | 'EXPIRED'
+  | 'CANCELLED'; // @TODO check if added
+// these are not exposed, but are coerced into FAILED
+// | 'INSUFFICIENT_BALANCE'
+// | 'INSUFFICIENT_ALLOWANCE'
+// | 'INVALIDATED';
 
 type DeltaAuctionTransaction = {
   id: string;
@@ -91,6 +113,12 @@ export type DeltaAuction = {
 
   bridgeMetadata: BridgeMetadata | null;
   bridgeStatus: BridgeStatus | null;
+
+  // @TODO only returned after POST Order so far
+  // orderVersion: string; // "2.0.0"
+  // deltaGasOverhead: number;
+
+  type: 'MARKET' | 'LIMIT'; // @TODO when available in API for individual /order/:hash|:id
 };
 
 export type BridgeMetadata = {
@@ -108,3 +136,23 @@ export type BridgeMetadata = {
 
 //                                                             refunded is basically failed
 export type BridgeStatus = 'pending' | 'filled' | 'expired' | 'refunded';
+
+//// available on BridgePrice ////
+
+// so far
+type ProtocolName = 'Across' | 'StargateBus' | 'StargateTaxi';
+
+type BridgeQuoteFee = {
+  feeToken: string;
+  amount: string;
+  amountInSrcToken: string;
+  amountInUSD: string;
+};
+
+export type BridgePriceInfo = {
+  protocolName: ProtocolName;
+  destAmountAfterBridge: string;
+  destUSDAfterBridge: string;
+  fees: BridgeQuoteFee[];
+  estimatedTimeMs: number;
+};

package/src/methods/delta/index.ts

@@ -1,5 +1,4 @@
 import type { ConstructProviderFetchInput } from '../../types';
-import type { DeltaAuction } from './helpers/types';
 import {
   BuildDeltaOrderDataParams,
   BuildDeltaOrderFunctions,
@@ -7,6 +6,8 @@ import {
 } from './buildDeltaOrder';
 import {
   constructPostDeltaOrder,
+  DeltaOrderApiResponse,
+  DeltaOrderToPost,
   PostDeltaOrderFunctions,
 } from './postDeltaOrder';
 import {
@@ -49,15 +50,21 @@ import {
   BuildCrosschainOrderBridgeFunctions,
   constructBuildCrosschainOrderBridge,
 } from './buildCrosschainOrderBridge';
+import {
+  CancelDeltaOrderFunctions,
+  constructCancelDeltaOrder,
+} from './cancelDeltaOrder';
 
 export type SubmitDeltaOrderParams = BuildDeltaOrderDataParams & {
   /** @description designates the Order as being able to be partially filled, as opposed to fill-or-kill */
   partiallyFillable?: boolean;
-};
+  /** @description Referrer address */
+  referrerAddress?: string;
+} & Pick<DeltaOrderToPost, 'type' | 'includeAgents' | 'excludeAgents'>;
 
 type SubmitDeltaOrder = (
   orderParams: SubmitDeltaOrderParams
-) => Promise<DeltaAuction>;
+) => Promise<DeltaOrderApiResponse>;
 
 export type SubmitDeltaOrderFuncs = {
   submitDeltaOrder: SubmitDeltaOrder;
@@ -79,6 +86,10 @@ export const constructSubmitDeltaOrder = (
       partner: orderParams.partner,
       order: orderData.data,
       partiallyFillable: orderParams.partiallyFillable,
+      referrerAddress: orderParams.referrerAddress,
+      type: orderParams.type,
+      includeAgents: orderParams.includeAgents,
+      excludeAgents: orderParams.excludeAgents,
     });
 
     return response;
@@ -99,7 +110,8 @@ export type DeltaOrderHandlers<T> = SubmitDeltaOrderFuncs &
   GetBridgeInfoFunctions &
   IsTokenSupportedInDeltaFunctions &
   PostDeltaOrderFunctions &
-  SignDeltaOrderFunctions;
+  SignDeltaOrderFunctions &
+  CancelDeltaOrderFunctions;
 
 /** @description construct SDK with every Delta Order-related method, fetching from API and Order signing */
 export const constructAllDeltaOrdersHandlers = <TxResponse>(
@@ -128,6 +140,8 @@ export const constructAllDeltaOrdersHandlers = <TxResponse>(
   const deltaOrdersSign = constructSignDeltaOrder(options);
   const deltaOrdersPost = constructPostDeltaOrder(options);
 
+  const deltaOrdersCancel = constructCancelDeltaOrder(options);
+
   return {
     ...deltaOrdersGetters,
     ...deltaOrdersContractGetter,
@@ -141,6 +155,7 @@ export const constructAllDeltaOrdersHandlers = <TxResponse>(
     ...deltaOrdersBuild,
     ...deltaOrdersSign,
     ...deltaOrdersPost,
+    ...deltaOrdersCancel,
     ...buildCrosschainOrderBridge,
   };
 };

package/src/methods/delta/postDeltaOrder.ts

@@ -13,11 +13,21 @@ export type DeltaOrderToPost = {
   chainId: number;
   /** @description designates the Order as being able to partially filled, as opposed to fill-or-kill */
   partiallyFillable?: boolean;
+
+  /** @description Type of the order. MARKET or LIMIT. Default is MARKET */
+  type?: 'MARKET' | 'LIMIT';
+
+  includeAgents?: string[];
+  excludeAgents?: string[];
 };
 
 export type PostDeltaOrderParams = Omit<DeltaOrderToPost, 'chainId'>;
 
-type DeltaOrderApiResponse = DeltaAuction;
+export type DeltaOrderApiResponse = Omit<DeltaAuction, 'transactions'> & {
+  orderVersion: string; // "2.0.0"
+  deltaGasOverhead: number; // @TODO may be removed
+  type: 'MARKET' | 'LIMIT';
+};
 
 type PostDeltaOrder = (
   postData: PostDeltaOrderParams,

package/src/methods/quote/getQuote.ts

@@ -1,6 +1,6 @@
 import { API_URL, SwapSide } from '../../constants';
 import { constructSearchString } from '../../helpers/misc';
-import type { DeltaPrice } from '../delta/getDeltaPrice';
+import type { BridgePrice, DeltaPrice } from '../delta/getDeltaPrice';
 import type {
   ConstructFetchInput,
   EnumerateLiteral,
@@ -23,8 +23,8 @@ export type QuoteParams<M extends TradeMode = TradeMode> = {
   srcDecimals: number;
   /** @description Destination Token Decimals */
   destDecimals: number;
-  /** @description SELL or BUY */
-  side: SwapSideUnion;
+  /** @description SELL or BUY, default is SELL */
+  side?: SwapSideUnion;
   /** @description User's Wallet Address */
   userAddress?: string;
   /** @description Partner string */
@@ -48,6 +48,17 @@ export type QuoteWithMarketPrice = {
 
 export type QuoteWithDeltaPrice = {
   delta: DeltaPrice;
+  deltaAddress: string;
+};
+
+export type QuoteWithBridgePrice = {
+  delta: BridgePrice;
+  deltaAddress: string;
+};
+
+export type QuoteWithDeltaPriceAndBridgePrice = {
+  delta: DeltaPrice | BridgePrice;
+  deltaAddress: string;
 };
 
 export type QuoteWithMarketPriceAsFallback = QuoteWithMarketPrice & {
@@ -57,20 +68,40 @@ export type QuoteWithMarketPriceAsFallback = QuoteWithMarketPrice & {
 export type QuoteResponse =
   | QuoteWithDeltaPrice
   | QuoteWithMarketPrice
-  | QuoteWithMarketPriceAsFallback;
+  | QuoteWithBridgePrice
+  | QuoteWithMarketPriceAsFallback
+  | QuoteWithDeltaPriceAndBridgePrice;
 
 interface GetQuoteFunc {
   (
-    options: QuoteParams<'delta'>,
+    options: QuoteParams<'delta'> & { destChainId?: undefined },
     requestParams?: RequestParameters
   ): Promise<QuoteWithDeltaPrice>;
+  (
+    options: QuoteParams<'delta'> & { destChainId: number },
+    requestParams?: RequestParameters
+  ): Promise<QuoteWithBridgePrice>;
+  (
+    options: QuoteParams<'delta'>,
+    requestParams?: RequestParameters
+  ): Promise<QuoteWithDeltaPriceAndBridgePrice>;
   (
     options: QuoteParams<'market'>,
     requestParams?: RequestParameters
   ): Promise<QuoteWithMarketPrice>;
-  (options: QuoteParams<'all'>, requestParams?: RequestParameters): Promise<
+  (
+    options: QuoteParams<'all'> & { destChainId?: undefined },
+    requestParams?: RequestParameters
+  ): Promise<
     QuoteWithDeltaPrice | QuoteWithMarketPriceAsFallback // "all" mode tries for deltaPrice and falls back to market priceRoute
   >;
+  (
+    options: QuoteParams<'all'> & { destChainId: number },
+    requestParams?: RequestParameters
+  ): Promise<QuoteWithBridgePrice>;
+  (options: QuoteParams<'all'>, requestParams?: RequestParameters): Promise<
+    QuoteWithDeltaPriceAndBridgePrice | QuoteWithMarketPriceAsFallback // "all" mode tries for deltaPrice and falls back to market priceRoute
+  >;
   (
     options: QuoteParams,
     requestParams?: RequestParameters
@@ -89,17 +120,37 @@ export const constructGetQuote = ({
   const pricesUrl = `${apiURL}/quote` as const;
 
   function getQuote(
-    options: QuoteParams<'delta'>,
+    options: QuoteParams<'delta'> & { destChainId?: undefined },
     requestParams?: RequestParameters
   ): Promise<QuoteWithDeltaPrice>;
+  function getQuote(
+    options: QuoteParams<'delta'> & { destChainId: number },
+    requestParams?: RequestParameters
+  ): Promise<QuoteWithBridgePrice>;
+  function getQuote(
+    options: QuoteParams<'delta'>,
+    requestParams?: RequestParameters
+  ): Promise<QuoteWithDeltaPriceAndBridgePrice>;
   function getQuote(
     options: QuoteParams<'market'>,
     requestParams?: RequestParameters
   ): Promise<QuoteWithMarketPrice>;
+  function getQuote(
+    options: QuoteParams<'all'> & { destChainId?: undefined },
+    requestParams?: RequestParameters
+  ): Promise<
+    QuoteWithDeltaPrice | QuoteWithMarketPriceAsFallback // "all" mode tries for deltaPrice and falls back to market priceRoute
+  >;
+  function getQuote(
+    options: QuoteParams<'all'> & { destChainId: number },
+    requestParams?: RequestParameters
+  ): Promise<QuoteWithBridgePrice>;
   function getQuote(
     options: QuoteParams<'all'>,
     requestParams?: RequestParameters
-  ): Promise<QuoteWithDeltaPrice | QuoteWithMarketPriceAsFallback>;
+  ): Promise<
+    QuoteWithDeltaPriceAndBridgePrice | QuoteWithMarketPriceAsFallback
+  >;
   function getQuote(
     options: QuoteParams,
     requestParams?: RequestParameters
@@ -111,7 +162,7 @@ export const constructGetQuote = ({
     const search = constructSearchString<QuoteQueryOptions>({
       ...options,
       chainId,
-      // side: SwapSide.SELL, // so far SELL side only for Delta
+      side: options.side ?? SwapSide.SELL,
     });
 
     const fetchURL = `${pricesUrl}/${search}` as const;

package/dist/methods/delta/helpers/composePermit.d.ts

@@ -1,5 +0,0 @@
-import { DeltaAuctionOrder } from './types';
-type DeltaOrderPermitInput = Pick<DeltaAuctionOrder, 'permit' | 'nonce'>;
-export declare function composeDeltaOrderPermit({ permit, nonce, }: DeltaOrderPermitInput): string;
-export {};
-//# sourceMappingURL=composePermit.d.ts.map

package/dist/methods/delta/helpers/composePermit.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"composePermit.d.ts","sourceRoot":"","sources":["../../../../src/methods/delta/helpers/composePermit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAE5C,KAAK,qBAAqB,GAAG,IAAI,CAAC,iBAAiB,EAAE,QAAQ,GAAG,OAAO,CAAC,CAAC;AAEzE,wBAAgB,uBAAuB,CAAC,EACtC,MAAM,EACN,KAAK,GACN,EAAE,qBAAqB,GAAG,MAAM,CAiBhC"}

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

@@ -1,76 +0,0 @@
-import { DeltaAuctionOrder } from './types';
-
-type DeltaOrderPermitInput = Pick<DeltaAuctionOrder, 'permit' | 'nonce'>;
-
-export function composeDeltaOrderPermit({
-  permit,
-  nonce,
-}: DeltaOrderPermitInput): string {
-  // Can be empty Permit if allowance is available for srcToken
-  if (permit === '0x' || permit === '0x01') {
-    // 0x01 is a special permit value that signifies existing Permit2 allowance.
-    return permit;
-  }
-
-  // In the Contract, specifically for Permit2 transferFrom, we have signature consisting of
-  // bytes32(permit2nonce) + bytes64(compacted signature) = bytes96 Permit2 Transfer format
-
-  if (permit.length >= 194) {
-    // "0x".length + 96bytes*2 = 194, means permit already concatenated with nonce
-    // or it's a different type of Permit all together
-    return permit;
-  }
-
-  return encodePermit2Transfer(BigInt(nonce), permit);
-}
-
-function uintTo32ByteArrayBuffer(nonce: number | bigint) {
-  // Create a 32-byte ArrayBuffer
-  const buffer = new Uint8Array(32);
-
-  // Convert nonce to hex string and pad it to 64 hex characters (32 bytes)
-  let nonceHex = nonce.toString(16).padStart(64, '0');
-
-  // Convert the hex string to bytes and fill the ArrayBuffer
-  for (let i = 0; i < 32; i++) {
-    buffer[i] = parseInt(nonceHex.slice(i * 2, i * 2 + 2), 16);
-  }
-
-  return buffer;
-}
-
-function hexToByteArray(hexString: string) {
-  // Remove "0x" prefix if present
-  hexString = hexString.replace(/^0x/, '');
-
-  // Convert hex string to Uint8Array
-  const byteArray = new Uint8Array(hexString.length / 2);
-  for (let i = 0; i < hexString.length; i += 2) {
-    byteArray[i / 2] = parseInt(hexString.slice(i, i + 2), 16);
-  }
-  return byteArray;
-}
-
-function encodePermit2Transfer(nonce: number | bigint, signature: string) {
-  // Get 32-byte ArrayBuffer for nonce
-  const nonceBuffer = uintTo32ByteArrayBuffer(nonce);
-
-  // Convert signature hex string to Uint8Array (64 bytes)
-  const signatureBuffer = hexToByteArray(signature);
-  if (signatureBuffer.length !== 64) {
-    throw new Error('Signature must be exactly 64 bytes');
-  }
-
-  // Concatenate nonceBuffer and signatureBuffer
-  const packedBuffer = new Uint8Array(32 + 64);
-  packedBuffer.set(nonceBuffer, 0); // Copy nonceBuffer at the start
-  packedBuffer.set(signatureBuffer, 32); // Copy signatureBuffer after nonce
-
-  // Convert to hex string for output
-  return (
-    '0x' +
-    Array.from(packedBuffer)
-      .map((b) => b.toString(16).padStart(2, '0'))
-      .join('')
-  );
-}