@velora-dex/sdk 9.3.6 → 9.4.1-dev.1

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

@@ -0,0 +1,227 @@
+import { Domain } from '../../common/orders/buildOrderData';
+import {
+  Bridge,
+  TWAPDeltaOrder,
+  TWAPBuyDeltaOrder,
+  TWAPOnChainOrderType,
+  OnChainOrderMap,
+} from './types';
+import { DELTA_DEFAULT_EXPIRY, producePartnerAndFee } from './misc';
+
+const BRIDGE_EIP_712_TYPE = [
+  { name: 'protocolSelector', type: 'bytes4' },
+  { name: 'destinationChainId', type: 'uint256' },
+  { name: 'outputToken', type: 'address' },
+  { name: 'scalingFactor', type: 'int8' },
+  { name: 'protocolData', type: 'bytes' },
+];
+
+const TWAP_ORDER_EIP_712_TYPES = {
+  TWAPOrder: [
+    { name: 'owner', type: 'address' },
+    { name: 'beneficiary', type: 'address' },
+    { name: 'srcToken', type: 'address' },
+    { name: 'destToken', type: 'address' },
+    { name: 'nonce', type: 'uint256' },
+    { name: 'partnerAndFee', type: 'uint256' },
+    { name: 'deadline', type: 'uint64' },
+    { name: 'interval', type: 'uint64' },
+    { name: 'numSlices', type: 'uint32' },
+    { name: 'destAmountPerSlice', type: 'uint256' },
+    { name: 'totalSrcAmount', type: 'uint256' },
+    { name: 'permit', type: 'bytes' },
+    { name: 'metadata', type: 'bytes' },
+    { name: 'bridge', type: 'Bridge' },
+  ],
+  Bridge: BRIDGE_EIP_712_TYPE,
+};
+
+const TWAP_BUY_ORDER_EIP_712_TYPES = {
+  TWAPBuyOrder: [
+    { name: 'owner', type: 'address' },
+    { name: 'beneficiary', type: 'address' },
+    { name: 'srcToken', type: 'address' },
+    { name: 'destToken', type: 'address' },
+    { name: 'nonce', type: 'uint256' },
+    { name: 'partnerAndFee', type: 'uint256' },
+    { name: 'deadline', type: 'uint64' },
+    { name: 'interval', type: 'uint64' },
+    { name: 'numSlices', type: 'uint32' },
+    { name: 'totalDestAmount', type: 'uint256' },
+    { name: 'maxSrcAmount', type: 'uint256' },
+    { name: 'permit', type: 'bytes' },
+    { name: 'metadata', type: 'bytes' },
+    { name: 'bridge', type: 'Bridge' },
+  ],
+  Bridge: BRIDGE_EIP_712_TYPE,
+};
+
+export type SignableTWAPSellOrderData = {
+  types: typeof TWAP_ORDER_EIP_712_TYPES;
+  domain: Domain;
+  data: TWAPDeltaOrder;
+};
+
+export type SignableTWAPBuyOrderData = {
+  types: typeof TWAP_BUY_ORDER_EIP_712_TYPES;
+  domain: Domain;
+  data: TWAPBuyDeltaOrder;
+};
+
+export type SignableTWAPOrderData =
+  | SignableTWAPSellOrderData
+  | SignableTWAPBuyOrderData;
+
+type ProduceTWAPOrderTypedDataInput<T extends TWAPOnChainOrderType> = {
+  orderInput: OnChainOrderMap[T];
+  paraswapDeltaAddress: string;
+  chainId: number;
+  onChainOrderType: T;
+};
+
+export function produceTWAPOrderTypedData(
+  params: ProduceTWAPOrderTypedDataInput<'TWAPOrder'>
+): SignableTWAPSellOrderData;
+export function produceTWAPOrderTypedData(
+  params: ProduceTWAPOrderTypedDataInput<'TWAPBuyOrder'>
+): SignableTWAPBuyOrderData;
+export function produceTWAPOrderTypedData({
+  orderInput,
+  chainId,
+  paraswapDeltaAddress,
+  onChainOrderType,
+}: ProduceTWAPOrderTypedDataInput<TWAPOnChainOrderType>) {
+  const domain: Domain = {
+    name: 'Portikus',
+    version: '2.0.0',
+    chainId,
+    verifyingContract: paraswapDeltaAddress,
+  };
+
+  if (onChainOrderType === 'TWAPOrder') {
+    return {
+      types: TWAP_ORDER_EIP_712_TYPES,
+      domain,
+      data: orderInput,
+    };
+  }
+
+  return {
+    types: TWAP_BUY_ORDER_EIP_712_TYPES,
+    domain,
+    data: orderInput,
+  };
+}
+
+type TWAPOrderCommonInput = {
+  owner: string;
+  beneficiary?: string;
+  srcToken: string;
+  destToken: string;
+  nonce?: string;
+  deadline?: number;
+  permit?: string;
+  metadata?: string;
+  interval: number;
+  numSlices: number;
+  bridge: Bridge;
+
+  partnerAddress: string;
+  paraswapDeltaAddress: string;
+  partnerFeeBps: number;
+  partnerTakesSurplus?: boolean;
+  capSurplus?: boolean;
+  chainId: number;
+};
+
+export type BuildTWAPSellOrderDataInput = TWAPOrderCommonInput & {
+  onChainOrderType: 'TWAPOrder';
+  destAmountPerSlice: string;
+  totalSrcAmount: string;
+};
+
+export type BuildTWAPBuyOrderDataInput = TWAPOrderCommonInput & {
+  onChainOrderType: 'TWAPBuyOrder';
+  totalDestAmount: string;
+  maxSrcAmount: string;
+};
+
+export type BuildTWAPOrderDataInput =
+  | BuildTWAPSellOrderDataInput
+  | BuildTWAPBuyOrderDataInput;
+
+export function buildTWAPSignableOrderData(
+  input: BuildTWAPOrderDataInput
+): SignableTWAPOrderData {
+  const {
+    owner,
+    beneficiary = owner,
+    srcToken,
+    destToken,
+    nonce = Date.now().toString(10),
+    deadline = Math.floor(Date.now() / 1000 + DELTA_DEFAULT_EXPIRY),
+    permit = '0x',
+    metadata = '0x',
+    interval,
+    numSlices,
+    bridge,
+
+    partnerAddress,
+    partnerFeeBps,
+    partnerTakesSurplus = false,
+    capSurplus = true,
+    chainId,
+    paraswapDeltaAddress,
+    onChainOrderType,
+  } = input;
+
+  const partnerAndFee = producePartnerAndFee({
+    partnerFeeBps,
+    partnerAddress,
+    partnerTakesSurplus,
+    capSurplus,
+  });
+
+  const commonFields = {
+    owner,
+    beneficiary,
+    srcToken,
+    destToken,
+    nonce,
+    partnerAndFee,
+    deadline,
+    interval,
+    numSlices,
+    permit,
+    metadata,
+    bridge,
+  };
+
+  if (onChainOrderType === 'TWAPOrder') {
+    const orderInput: TWAPDeltaOrder = {
+      ...commonFields,
+      destAmountPerSlice: input.destAmountPerSlice,
+      totalSrcAmount: input.totalSrcAmount,
+    };
+
+    return produceTWAPOrderTypedData({
+      orderInput,
+      chainId,
+      paraswapDeltaAddress,
+      onChainOrderType: 'TWAPOrder',
+    });
+  }
+
+  const orderInput: TWAPBuyDeltaOrder = {
+    ...commonFields,
+    totalDestAmount: input.totalDestAmount,
+    maxSrcAmount: input.maxSrcAmount,
+  };
+
+  return produceTWAPOrderTypedData({
+    orderInput,
+    chainId,
+    paraswapDeltaAddress,
+    onChainOrderType: 'TWAPBuyOrder',
+  });
+}

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

@@ -1,4 +1,180 @@
+import { ZERO_ADDRESS } from '../../common/orders/buildOrderData';
 import type { SignableDeltaOrderData } from './buildDeltaOrderData';
+import type { SignableExternalOrderData } from './buildExternalOrderData';
+import type { SignableTWAPOrderData } from './buildTWAPOrderData';
+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;
+};
+
+export 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 +210,71 @@ 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,
+  };
+}
+
+export function sanitizeTWAPOrderData(
+  orderData: SignableTWAPOrderData['data']
+): SignableTWAPOrderData['data'] {
+  const common = {
+    owner: orderData.owner,
+    beneficiary: orderData.beneficiary,
+    srcToken: orderData.srcToken,
+    destToken: orderData.destToken,
+    nonce: orderData.nonce,
+    partnerAndFee: orderData.partnerAndFee,
+    deadline: orderData.deadline,
+    interval: orderData.interval,
+    numSlices: orderData.numSlices,
+    permit: orderData.permit,
+    metadata: orderData.metadata,
+    bridge: orderData.bridge,
+  };
+
+  if ('destAmountPerSlice' in orderData) {
+    return {
+      ...common,
+      destAmountPerSlice: orderData.destAmountPerSlice,
+      totalSrcAmount: orderData.totalSrcAmount,
+    };
+  }
+
+  return {
+    ...common,
+    totalDestAmount: orderData.totalDestAmount,
+    maxSrcAmount: orderData.maxSrcAmount,
+  };
+}

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

@@ -1,5 +1,44 @@
+import type { EnumerateLiteral } from '../../../types';
 import { SwapSide } from '../../../constants';
 
+export type SwapSideUnion = EnumerateLiteral<typeof SwapSide>;
+
+/** @description SELL with slippage: srcAmount provided, destAmount auto-computed from deltaPrice.destAmount */
+export type AmountsSellSlippage = {
+  /** @description Slippage in basis points (bps). 10000 = 100%, 50 = 0.5% */
+  slippage: number;
+  /** @description The amount of src token to swap */
+  srcAmount: string;
+  destAmount?: never;
+  /** @description The side of the order */
+  side?: 'SELL';
+};
+/** @description BUY with slippage: destAmount provided, srcAmount auto-computed from deltaPrice.srcAmount */
+export type AmountsBuySlippage = {
+  /** @description Slippage in basis points (bps). 10000 = 100%, 50 = 0.5% */
+  slippage: number;
+  /** @description The minimum amount of dest token to receive */
+  destAmount: string;
+  srcAmount?: never;
+  /** @description The side of the order */
+  side?: 'BUY';
+};
+/** @description Explicit amounts, no slippage (backward-compatible) */
+export type AmountsExplicit = {
+  slippage?: never;
+  /** @description The amount of src token to swap */
+  srcAmount: string;
+  /** @description The minimum amount of dest token to receive */
+  destAmount: string;
+  /** @description The side of the order. Default is SELL */
+  side?: SwapSideUnion;
+};
+
+export type AmountsWithSlippage =
+  | AmountsSellSlippage
+  | AmountsBuySlippage
+  | AmountsExplicit;
+
 enum OrderKind {
   Sell = 0,
   Buy = 1,
@@ -52,6 +91,79 @@ export type Bridge = {
   protocolData: string; // Hex string
 };
 
+export type ExternalDeltaOrder = {
+  /** @description The address of the order owner */
+  owner: string;
+  /** @description The address of the external handler contract */
+  handler: string;
+  /** @description The address of the src token */
+  srcToken: string;
+  /** @description The address of the dest token */
+  destToken: string;
+  /** @description The amount of src token to swap */
+  srcAmount: string;
+  /** @description The minimum amount of dest token to receive */
+  destAmount: string;
+  /** @description The expected amount of token to receive */
+  expectedAmount: string;
+  /** @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;
+  /** @description The nonce of the order */
+  nonce: string;
+  /** @description Optional permit signature for the src token */
+  permit: string;
+  /** @description Encoded partner address, fee bps, and flags for the order */
+  partnerAndFee: string;
+  /** @description Protocol-specific encoded bytes for the external handler */
+  data: string;
+};
+
+type TWAPDeltaOrderBase = {
+  /** @description The address of the order owner */
+  owner: string;
+  /** @description The address of the order beneficiary */
+  beneficiary: string; // beneficiary==owner if no transferTo
+  /** @description The address of the src token */
+  srcToken: string; // lowercase
+  /** @description The address of the dest token */
+  destToken: string; // lowercase
+  /** @description The nonce of the order */
+  nonce: string; // can be random, can even be Date.now()
+  /** @description Encoded partner address, fee bps, and flags for the order. partnerAndFee = (partner << 96) | (partnerTakesSurplus << 8) | fee in bps (max fee is 2%) */
+  partnerAndFee: string;
+  /** @description The deadline for the order */
+  deadline: number; // seconds
+  /** @description The interval between each slice execution */
+  interval: number; // seconds
+  /** @description The number of slices to execute */
+  numSlices: number;
+  /** @description Optional permit signature for the src token */
+  permit: string; //can be "0x"
+  /** @description Metadata for the order, hex string */
+  metadata: string;
+  /** @description The bridge input */
+  bridge: Bridge;
+};
+
+export type TWAPDeltaOrder = TWAPDeltaOrderBase & {
+  /** @description The amount of dest token to receive per slice */
+  destAmountPerSlice: string; // wei
+  /** @description The total amount of src token to swap */
+  totalSrcAmount: string; // wei
+  /** @description Optional permit signature for the src token */
+};
+
+export type TWAPBuyDeltaOrder = TWAPDeltaOrderBase & {
+  /** @description The total amount of dest token to buy across all slices */
+  totalDestAmount: string; // wei
+  /** @description The maximum amount of src token willing to spend */
+  maxSrcAmount: string; // wei
+};
+
 export type DeltaAuctionStatus =
   | 'NOT_STARTED'
   | 'AWAITING_PRE_SIGNATURE'
@@ -65,7 +177,7 @@ export type DeltaAuctionStatus =
   | 'SUSPENDED'
   | 'REFUNDED';
 
-type DeltaAuctionTransaction = {
+export type DeltaAuctionTransaction = {
   id: string;
   hash: string;
   orderId: string;
@@ -92,13 +204,18 @@ type DeltaAuctionTransaction = {
   auctionId: string;
 };
 
-export type DeltaAuction = {
+export type OnChainOrderMap = {
+  Order: DeltaAuctionOrder;
+  ExternalOrder: ExternalDeltaOrder;
+  TWAPOrder: TWAPDeltaOrder;
+  TWAPBuyOrder: TWAPBuyDeltaOrder;
+};
+
+type DeltaAuctionBase = {
   id: string;
   deltaVersion: string; // 1.0 or 2.0 currently
   user: string;
-  signature: string;
   status: DeltaAuctionStatus;
-  order: DeltaAuctionOrder;
   orderHash: string | null; // not available on old Orders only
   transactions: DeltaAuctionTransaction[];
   chainId: number;
@@ -115,13 +232,17 @@ 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
+  type: 'MARKET' | 'LIMIT';
 };
 
+export type DeltaAuction<T extends OnChainOrderType = OnChainOrderType> =
+  T extends T
+    ? DeltaAuctionBase & {
+        onChainOrderType: T;
+        order: OnChainOrderMap[T];
+      }
+    : never;
+
 export type BridgeMetadata = {
   /** @description The amount that user should expect to get */
   outputAmount: string;
@@ -138,6 +259,14 @@ export type BridgeMetadata = {
 //                                                             refunded is basically failed
 export type BridgeStatus = 'pending' | 'filled' | 'expired' | 'refunded';
 
+export type OnChainOrderType =
+  | 'Order'
+  | 'ExternalOrder'
+  | 'TWAPOrder'
+  | 'TWAPBuyOrder';
+
+export type TWAPOnChainOrderType = 'TWAPOrder' | 'TWAPBuyOrder';
+
 //// available on BridgePrice ////
 
 type BridgeQuoteFee = {