@velora-dex/sdk 9.3.6 → 9.4.0

package/src/methods/delta/buildExternalDeltaOrder.ts

@@ -0,0 +1,124 @@
+import type { ConstructFetchInput, RequestParameters } from '../../types';
+import { constructGetDeltaContract } from './getDeltaContract';
+import type { DeltaPrice } from './getDeltaPrice';
+import { constructGetPartnerFee } from './getPartnerFee';
+import {
+  buildExternalOrderSignableData,
+  type BuildExternalOrderDataInput,
+  type SignableExternalOrderData,
+} from './helpers/buildExternalOrderData';
+import type { AmountsWithSlippage } from './helpers/types';
+import { SwapSideToOrderKind } from './helpers/types';
+import type { MarkOptional } from 'ts-essentials';
+import { resolvePartnerFee, resolveAmounts } from './helpers/misc';
+export type { SignableExternalOrderData } from './helpers/buildExternalOrderData';
+
+type BuildExternalDeltaOrderParamsBase = {
+  /** @description The address of the order owner */
+  owner: string;
+  /** @description The address of the external handler contract */
+  handler: string;
+  /** @description Protocol-specific encoded bytes for the external handler */
+  data: string;
+  /** @description The address of the src token */
+  srcToken: string;
+  /** @description The address of the dest token */
+  destToken: string;
+  /** @description The deadline for the order */
+  deadline?: number;
+  /** @description The nonce of the order */
+  nonce?: number | string;
+  /** @description Optional permit signature for the src token */
+  permit?: string;
+  /** @description Partner string */
+  partner?: string;
+  /** @description partner fee in basis points (bps), 50bps=0.5% */
+  partnerFeeBps?: number;
+  /** @description partner address */
+  partnerAddress?: string;
+  /** @description take surplus */
+  partnerTakesSurplus?: boolean;
+  /** @description A boolean indicating whether the surplus should be capped. True by default */
+  capSurplus?: boolean;
+  /** @description Metadata for the order, hex string */
+  metadata?: string;
+
+  /** @description price response received from /delta/prices (getDeltaPrice method) */
+  deltaPrice: MarkOptional<
+    Pick<
+      DeltaPrice,
+      'destAmount' | 'partner' | 'partnerFee' | 'destToken' | 'srcAmount'
+    >,
+    'partner' | 'partnerFee'
+  >;
+};
+
+export type BuildExternalDeltaOrderParams = BuildExternalDeltaOrderParamsBase &
+  AmountsWithSlippage;
+
+type BuildExternalDeltaOrder = (
+  buildOrderParams: BuildExternalDeltaOrderParams,
+  requestParams?: RequestParameters
+) => Promise<SignableExternalOrderData>;
+
+export type BuildExternalDeltaOrderFunctions = {
+  /** @description Build External Orders to be posted to Delta API for execution */
+  buildExternalDeltaOrder: BuildExternalDeltaOrder;
+};
+
+export const constructBuildExternalDeltaOrder = (
+  options: ConstructFetchInput
+): BuildExternalDeltaOrderFunctions => {
+  const { chainId } = options;
+
+  // cached internally
+  const { getDeltaContract } = constructGetDeltaContract(options);
+  // cached internally for `partner`
+  const { getPartnerFee } = constructGetPartnerFee(options);
+
+  const buildExternalDeltaOrder: BuildExternalDeltaOrder = async (
+    options,
+    requestParams
+  ) => {
+    const ParaswapDelta = await getDeltaContract(requestParams);
+    if (!ParaswapDelta) {
+      throw new Error(`Delta is not available on chain ${chainId}`);
+    }
+
+    const { partnerAddress, partnerFeeBps, partnerTakesSurplus } =
+      await resolvePartnerFee(options, getPartnerFee, requestParams);
+
+    const { srcAmount, destAmount, expectedAmount, swapSide } =
+      resolveAmounts(options);
+
+    const input: BuildExternalOrderDataInput = {
+      owner: options.owner,
+      handler: options.handler,
+      srcToken: options.srcToken,
+      destToken: options.deltaPrice.destToken,
+      srcAmount,
+      destAmount,
+      expectedAmount,
+      deadline: options.deadline,
+      nonce: options.nonce?.toString(10),
+      permit: options.permit,
+      kind: SwapSideToOrderKind[swapSide],
+      metadata: options.metadata,
+      data: options.data,
+
+      chainId,
+      paraswapDeltaAddress: ParaswapDelta,
+      partnerAddress,
+      partnerTakesSurplus,
+      partnerFeeBps,
+
+      capSurplus: options.capSurplus,
+    };
+
+    return buildExternalOrderSignableData(input);
+  };
+
+  return {
+    buildExternalDeltaOrder,
+  };
+};

package/src/methods/delta/getDeltaOrders.ts

@@ -5,9 +5,14 @@ import type {
   ConstructFetchInput,
   RequestParameters,
 } from '../../types';
-import type { DeltaAuction, DeltaAuctionStatus } from './helpers/types';
+import type {
+  DeltaAuction,
+  DeltaAuctionStatus,
+  OnChainOrderType,
+} from './helpers/types';
 
-export type DeltaOrderFromAPI = Omit<DeltaAuction, 'signature'>;
+/** @deprecated Use DeltaAuction directly */
+export type DeltaOrderFromAPI = DeltaAuction;
 
 export type DeltaOrderFilterByStatus =
   | DeltaAuctionStatus
@@ -20,14 +25,14 @@ export type DeltaOrderFilterByStatus =
 type GetDeltaOrderById = (
   orderId: string,
   requestParams?: RequestParameters
-) => Promise<DeltaOrderFromAPI>;
+) => Promise<DeltaAuction>;
 
 type GetDeltaOrderByHash = (
   orderHash: string,
   requestParams?: RequestParameters
-) => Promise<DeltaOrderFromAPI>;
+) => Promise<DeltaAuction>;
 
-type OrdersFilter = {
+type OrdersFilter<T extends OnChainOrderType = OnChainOrderType> = {
   /** @description Order.owner to fetch Delta Order for */
   userAddress: Address;
   /** @description Pagination option, page. Default 1 */
@@ -48,16 +53,23 @@ type OrdersFilter = {
   status?: DeltaOrderFilterByStatus[];
   /** @description Filter by type. MARKET, LIMIT. Orders with both types are returned if not specified */
   type?: 'MARKET' | 'LIMIT';
+  /** @description Filter by on-chain order type. Order, ExternalOrder. Orders of all types are returned if not specified */
+  onChainOrderType?: T;
 };
 type OrderFiltersQuery = Omit<OrdersFilter, 'chainId' | 'status'> & {
   chainId?: string;
   status?: string;
 };
 
-type GetDeltaOrders = (
-  options: OrdersFilter,
-  requestParams?: RequestParameters
-) => Promise<DeltaOrderFromAPI[]>;
+type GetDeltaOrders = {
+  <T extends OnChainOrderType>(
+    options: OrdersFilter<T> & { onChainOrderType: T },
+    requestParams?: RequestParameters
+  ): Promise<DeltaAuction<T>[]>;
+  (options: OrdersFilter, requestParams?: RequestParameters): Promise<
+    DeltaAuction[]
+  >;
+};
 
 type GetRequiredBalanceParams = {
   userAddress: Address;
@@ -89,7 +101,7 @@ export const constructGetDeltaOrders = ({
   ) => {
     const fetchURL = `${baseUrl}/${orderId}` as const;
 
-    const order = await fetcher<DeltaOrderFromAPI>({
+    const order = await fetcher<DeltaAuction>({
       url: fetchURL,
       method: 'GET',
       requestParams,
@@ -104,7 +116,7 @@ export const constructGetDeltaOrders = ({
   ) => {
     const fetchURL = `${baseUrl}/hash/${orderHash}` as const;
 
-    const order = await fetcher<DeltaOrderFromAPI>({
+    const order = await fetcher<DeltaAuction>({
       url: fetchURL,
       method: 'GET',
       requestParams,
@@ -113,7 +125,12 @@ export const constructGetDeltaOrders = ({
     return order;
   };
 
-  const getDeltaOrders: GetDeltaOrders = async (options, requestParams) => {
+  const getDeltaOrders: GetDeltaOrders = async <
+    T extends OnChainOrderType = OnChainOrderType
+  >(
+    options: OrdersFilter<T>,
+    requestParams?: RequestParameters
+  ) => {
     const chainIdString = options.chainId?.join(',');
     const statusString = options.status?.join(',');
 
@@ -122,13 +139,14 @@ export const constructGetDeltaOrders = ({
       page: options.page,
       limit: options.limit,
       type: options.type,
+      onChainOrderType: options.onChainOrderType,
       chainId: chainIdString,
       status: statusString,
     });
 
     const fetchURL = `${baseUrl}${search}` as const;
 
-    const orders = await fetcher<DeltaOrderFromAPI[]>({
+    const orders = await fetcher<DeltaAuction<T>[]>({
       url: fetchURL,
       method: 'GET',
       requestParams,

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

@@ -0,0 +1,20 @@
+export const PreSignatureModuleAbi = [
+  {
+    inputs: [
+      {
+        internalType: 'bytes32',
+        name: 'orderHash',
+        type: 'bytes32',
+      },
+      {
+        internalType: 'bool',
+        name: 'preSigned',
+        type: 'bool',
+      },
+    ],
+    name: 'setPreSignature',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+] as const;

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

@@ -1,6 +1,7 @@
 import { MarkOptional } from 'ts-essentials';
-import { Domain, ZERO_ADDRESS } from '../../common/orders/buildOrderData';
+import { Domain } from '../../common/orders/buildOrderData';
 import { Bridge, DeltaAuctionOrder } from './types';
+import { DELTA_DEFAULT_EXPIRY, producePartnerAndFee } from './misc';
 
 // Order(address owner,address beneficiary,address srcToken,address destToken,uint256 srcAmount,uint256 destAmount,uint256 deadline,uint256 nonce,bytes permit, bridge Bridge)";
 const SWAP_ORDER_EIP_712_TYPES = {
@@ -64,7 +65,7 @@ export function produceDeltaOrderTypedData({
   chainId,
   paraswapDeltaAddress,
 }: SignDeltaOrderInput): SignableDeltaOrderData {
-  const typedData = {
+  return {
     types: {
       Order: SWAP_ORDER_EIP_712_TYPES.Order,
       Bridge: SWAP_ORDER_EIP_712_TYPES.Bridge,
@@ -77,8 +78,6 @@ export function produceDeltaOrderTypedData({
     },
     data: orderInput,
   };
-
-  return typedData;
 }
 
 export type DeltaOrderDataInput = MarkOptional<
@@ -99,9 +98,6 @@ export type BuildDeltaOrderDataInput = MarkOptional<
   bridge: Bridge;
 };
 
-// default deadline = 1 hour for now (may be changed later)
-export const DELTA_DEFAULT_EXPIRY = 60 * 60; // seconds
-
 export function buildDeltaSignableOrderData({
   owner,
   beneficiary = owner,
@@ -157,31 +153,3 @@ export function buildDeltaSignableOrderData({
     paraswapDeltaAddress,
   });
 }
-
-type ProducePartnerAndFeeInput = {
-  partnerFeeBps: number;
-  partnerAddress: string;
-  partnerTakesSurplus: boolean;
-  capSurplus: boolean;
-};
-
-// fee and address are encoded together
-function producePartnerAndFee({
-  partnerFeeBps,
-  partnerAddress,
-  partnerTakesSurplus,
-  capSurplus,
-}: ProducePartnerAndFeeInput): string {
-  const capSurplusShifted = BigInt(capSurplus) << BigInt(9);
-  if (partnerAddress === ZERO_ADDRESS) {
-    return capSurplusShifted.toString(10);
-  } else {
-    const partnerAndFee =
-      (BigInt(partnerAddress) << BigInt(96)) |
-      BigInt(partnerFeeBps.toFixed(0)) |
-      (BigInt(partnerTakesSurplus) << BigInt(8)) |
-      capSurplusShifted;
-
-    return partnerAndFee.toString(10);
-  }
-}

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

@@ -0,0 +1,129 @@
+import { MarkOptional } from 'ts-essentials';
+import { Domain } from '../../common/orders/buildOrderData';
+import { ExternalDeltaOrder } from './types';
+import { DELTA_DEFAULT_EXPIRY, producePartnerAndFee } from './misc';
+
+const EXTERNAL_ORDER_EIP_712_TYPES = {
+  ExternalOrder: [
+    { name: 'owner', type: 'address' },
+    { name: 'handler', type: 'address' },
+    { name: 'srcToken', type: 'address' },
+    { name: 'destToken', type: 'address' },
+    { name: 'srcAmount', type: 'uint256' },
+    { name: 'destAmount', type: 'uint256' },
+    { name: 'expectedAmount', type: 'uint256' },
+    { name: 'deadline', type: 'uint256' },
+    { name: 'kind', type: 'uint8' },
+    { name: 'nonce', type: 'uint256' },
+    { name: 'partnerAndFee', type: 'uint256' },
+    { name: 'permit', type: 'bytes' },
+    { name: 'metadata', type: 'bytes' },
+    { name: 'data', type: 'bytes' },
+  ],
+};
+
+export type SignableExternalOrderData = {
+  types: {
+    ExternalOrder: typeof EXTERNAL_ORDER_EIP_712_TYPES.ExternalOrder;
+  };
+  domain: Domain;
+  data: ExternalDeltaOrder;
+};
+
+type SignExternalOrderInput = {
+  orderInput: ExternalDeltaOrder;
+  paraswapDeltaAddress: string;
+  chainId: number;
+};
+
+export function produceExternalOrderTypedData({
+  orderInput,
+  chainId,
+  paraswapDeltaAddress,
+}: SignExternalOrderInput): SignableExternalOrderData {
+  return {
+    types: {
+      ExternalOrder: EXTERNAL_ORDER_EIP_712_TYPES.ExternalOrder,
+    },
+    domain: {
+      name: 'Portikus',
+      version: '2.0.0',
+      chainId,
+      verifyingContract: paraswapDeltaAddress,
+    },
+    data: orderInput,
+  };
+}
+
+export type ExternalOrderDataInput = MarkOptional<
+  Omit<ExternalDeltaOrder, 'partnerAndFee'>,
+  'deadline' | 'nonce' | 'permit'
+>;
+
+export type BuildExternalOrderDataInput = MarkOptional<
+  ExternalOrderDataInput,
+  'metadata'
+> & {
+  partnerAddress: string;
+  paraswapDeltaAddress: string;
+  partnerFeeBps: number;
+  partnerTakesSurplus?: boolean;
+  capSurplus?: boolean;
+  chainId: number;
+};
+
+export function buildExternalOrderSignableData({
+  owner,
+  handler,
+
+  srcToken,
+  destToken,
+  srcAmount,
+  destAmount,
+  expectedAmount,
+
+  deadline = Math.floor(Date.now() / 1000 + DELTA_DEFAULT_EXPIRY),
+  nonce = Date.now().toString(10),
+
+  permit = '0x',
+
+  kind,
+  metadata = '0x',
+  data,
+
+  partnerAddress,
+  partnerFeeBps,
+  partnerTakesSurplus = false,
+  capSurplus = true,
+
+  chainId,
+  paraswapDeltaAddress,
+}: BuildExternalOrderDataInput): SignableExternalOrderData {
+  const orderInput: ExternalDeltaOrder = {
+    owner,
+    handler,
+    srcToken,
+    destToken,
+    srcAmount,
+    destAmount,
+    expectedAmount,
+    deadline,
+    nonce,
+    permit,
+    partnerAndFee: producePartnerAndFee({
+      partnerFeeBps,
+      partnerAddress,
+      partnerTakesSurplus,
+      capSurplus,
+    }),
+    kind,
+    metadata,
+    data,
+  };
+
+  return produceExternalOrderTypedData({
+    orderInput,
+    chainId,
+    paraswapDeltaAddress,
+  });
+}

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

@@ -1,4 +1,179 @@
+import { ZERO_ADDRESS } from '../../common/orders/buildOrderData';
 import type { SignableDeltaOrderData } from './buildDeltaOrderData';
+import type { SignableExternalOrderData } from './buildExternalOrderData';
+import type { GetPartnerFeeFunctions } from '../getPartnerFee';
+import type { RequestParameters } from '../../../types';
+import type { AmountsWithSlippage, SwapSideUnion } from './types';
+import { SwapSide } from '../../../constants';
+import { assert } from 'ts-essentials';
+
+// default deadline = 10 min
+export const DELTA_DEFAULT_EXPIRY = 10 * 60; // seconds
+
+type ProducePartnerAndFeeInput = {
+  partnerFeeBps: number;
+  partnerAddress: string;
+  partnerTakesSurplus: boolean;
+  capSurplus: boolean;
+};
+
+// fee and address are encoded together
+export function producePartnerAndFee({
+  partnerFeeBps,
+  partnerAddress,
+  partnerTakesSurplus,
+  capSurplus,
+}: ProducePartnerAndFeeInput): string {
+  const capSurplusShifted = BigInt(capSurplus) << BigInt(9);
+  if (partnerAddress === ZERO_ADDRESS) {
+    return capSurplusShifted.toString(10);
+  } else {
+    const partnerAndFee =
+      (BigInt(partnerAddress) << BigInt(96)) |
+      BigInt(partnerFeeBps.toFixed(0)) |
+      (BigInt(partnerTakesSurplus) << BigInt(8)) |
+      capSurplusShifted;
+
+    return partnerAndFee.toString(10);
+  }
+}
+
+type ApplySlippageInput = {
+  amount: string;
+  slippageBps: number;
+  increase: boolean;
+};
+
+function applySlippage({
+  amount,
+  slippageBps,
+  increase,
+}: ApplySlippageInput): string {
+  assert(
+    Number.isInteger(slippageBps) && slippageBps >= 0 && slippageBps <= 10_000,
+    'slippageBps must be an integer between 0 and 10_000'
+  );
+
+  const BPS_BASE = 10_000n;
+  const amt = BigInt(amount);
+  const bps = BigInt(slippageBps);
+
+  return increase
+    ? ((amt * (BPS_BASE + bps)) / BPS_BASE).toString(10)
+    : ((amt * (BPS_BASE - bps)) / BPS_BASE).toString(10);
+}
+
+export type ResolvePartnerFeeInput = {
+  partnerAddress?: string;
+  partnerFeeBps?: number;
+  partnerTakesSurplus?: boolean;
+  partner?: string;
+  deltaPrice: { partner?: string; partnerFee?: number };
+};
+
+export type ResolvedPartnerFee = {
+  partnerAddress: string;
+  partnerFeeBps: number;
+  partnerTakesSurplus: boolean;
+};
+
+export async function resolvePartnerFee(
+  options: ResolvePartnerFeeInput,
+  getPartnerFee: GetPartnerFeeFunctions['getPartnerFee'],
+  requestParams?: RequestParameters
+): Promise<ResolvedPartnerFee> {
+  // externally supplied partner fee data takes precedence
+  let partnerAddress = options.partnerAddress;
+  let partnerFeeBps =
+    options.partnerFeeBps ??
+    (options.deltaPrice.partnerFee
+      ? options.deltaPrice.partnerFee * 100
+      : undefined);
+  let partnerTakesSurplus = options.partnerTakesSurplus;
+
+  // if fee given, takeSurplus is ignored
+  const feeOrTakeSurplusSupplied =
+    partnerFeeBps !== undefined || partnerTakesSurplus !== undefined;
+
+  if (partnerAddress === undefined || feeOrTakeSurplusSupplied) {
+    const partner = options.partner || options.deltaPrice.partner;
+    if (!partner) {
+      // if no partner given in options or deltaPrice, default partnerAddress to zero,
+      // unless supplied explicitly
+      partnerAddress = partnerAddress ?? ZERO_ADDRESS;
+    } else {
+      const partnerFeeResponse = await getPartnerFee(
+        { partner },
+        requestParams
+      );
+
+      partnerAddress = partnerAddress ?? partnerFeeResponse.partnerAddress;
+      // deltaPrice.partnerFee and partnerFeeResponse.partnerFee should be the same, but give priority to externally provided
+      partnerFeeBps = partnerFeeBps ?? partnerFeeResponse.partnerFee * 100;
+      partnerTakesSurplus =
+        partnerTakesSurplus ?? partnerFeeResponse.takeSurplus;
+    }
+  }
+
+  return {
+    partnerAddress: partnerAddress!,
+    partnerFeeBps: partnerFeeBps ?? 0,
+    partnerTakesSurplus: partnerTakesSurplus ?? false,
+  };
+}
+
+export type ResolveAmountsInput = AmountsWithSlippage & {
+  deltaPrice: { destAmount: string; srcAmount: string };
+};
+
+export type ResolvedAmounts = {
+  srcAmount: string;
+  destAmount: string;
+  expectedAmount: string;
+  swapSide: SwapSideUnion;
+};
+
+export function resolveAmounts(options: ResolveAmountsInput): ResolvedAmounts {
+  let srcAmount: string;
+  let destAmount: string;
+
+  const swapSide: SwapSideUnion =
+    options.slippage !== undefined
+      ? options.srcAmount !== undefined
+        ? SwapSide.SELL
+        : SwapSide.BUY
+      : options.side ?? SwapSide.SELL;
+
+  if (options.slippage !== undefined) {
+    if (options.srcAmount !== undefined) {
+      // SELL with slippage: destAmount auto-computed
+      srcAmount = options.srcAmount;
+      destAmount = applySlippage({
+        amount: options.deltaPrice.destAmount,
+        slippageBps: options.slippage,
+        increase: false,
+      });
+    } else {
+      // BUY with slippage: srcAmount auto-computed
+      destAmount = options.destAmount;
+      srcAmount = applySlippage({
+        amount: options.deltaPrice.srcAmount,
+        slippageBps: options.slippage,
+        increase: true,
+      });
+    }
+  } else {
+    srcAmount = options.srcAmount;
+    destAmount = options.destAmount;
+  }
+
+  const expectedAmount =
+    swapSide === SwapSide.SELL
+      ? options.deltaPrice.destAmount
+      : options.deltaPrice.srcAmount;
+
+  return { srcAmount, destAmount, expectedAmount, swapSide };
+}
 
 export function sanitizeDeltaOrderData({
   owner,
@@ -34,3 +209,38 @@ export function sanitizeDeltaOrderData({
     metadata,
   };
 }
+
+export function sanitizeExternalOrderData({
+  owner,
+  handler,
+  srcToken,
+  destToken,
+  srcAmount,
+  destAmount,
+  expectedAmount,
+  deadline,
+  nonce,
+  permit,
+  partnerAndFee,
+  kind,
+  metadata,
+  data,
+}: SignableExternalOrderData['data'] &
+  Record<string, any>): SignableExternalOrderData['data'] {
+  return {
+    owner,
+    handler,
+    srcToken,
+    destToken,
+    srcAmount,
+    destAmount,
+    expectedAmount,
+    deadline,
+    nonce,
+    permit,
+    partnerAndFee,
+    kind,
+    metadata,
+    data,
+  };
+}