@velora-dex/sdk 8.0.0

package/src/methods/limitOrders/helpers/buildOrderData.ts

@@ -0,0 +1,121 @@
+import { getRandomInt } from '../../../helpers/misc';
+import type { Address, APIVersion } from '../../../types';
+import {
+  Domain,
+  name,
+  version,
+  ZERO_ADDRESS,
+} from '../../common/orders/buildOrderData';
+
+const Order = [
+  { name: 'nonceAndMeta', type: 'uint256' },
+  { name: 'expiry', type: 'uint128' },
+  { name: 'makerAsset', type: 'address' },
+  { name: 'takerAsset', type: 'address' },
+  { name: 'maker', type: 'address' },
+  { name: 'taker', type: 'address' },
+  { name: 'makerAmount', type: 'uint256' },
+  { name: 'takerAmount', type: 'uint256' },
+];
+
+export interface BuildOrderDataInput {
+  chainId: number;
+  verifyingContract: Address;
+  nonce?: number;
+  expiry: number;
+  makerAsset: Address;
+  takerAsset: Address;
+  makerAmount: string;
+  takerAmount: string;
+  maker: Address;
+  // OrderData.taker must be Augustus (or other Executor) for p2p limitOrders to involve swap through Augustus
+  /** @description actual user taker which will go into nonceAndMeta */
+  taker?: Address;
+  /** @description contract executor (Augustus or similar) that is allowed to execute the order, gois in Order.taker */
+  contractTaker?: Address;
+
+  AugustusAddress: Address;
+  AppVersion: APIVersion;
+}
+
+export type SignableOrderData = {
+  types: { Order: typeof Order };
+  domain: Domain;
+  data: OrderData;
+};
+
+export type OrderData = {
+  nonceAndMeta: string;
+  expiry: number;
+  makerAsset: string;
+  takerAsset: string;
+  maker: string;
+  taker: string;
+  makerAmount: string;
+  takerAmount: string;
+};
+
+export function buildOrderData({
+  chainId,
+  verifyingContract,
+  nonce = getRandomInt(),
+  expiry,
+  makerAsset,
+  takerAsset,
+  makerAmount,
+  takerAmount,
+  maker,
+  AugustusAddress,
+  // if taker is specified -- p2p order for that taker only to fill through Augustus (v5) or directly (v6)-- taker = Augustus | _taker, takerInNonce = _taker
+  // if taker is not specified -- limitOrder for anyone to fill through Augustus or not -- taker = Zero, takerInNonce = Zero
+  taker: takerInNonce = ZERO_ADDRESS,
+  // if given, overrides the above choices made based on `taker`
+  contractTaker,
+  // for v6 only support taker=_taker for OTC orders
+  AppVersion,
+}: BuildOrderDataInput): SignableOrderData {
+  // first 160 bits is taker address (for p2p orders),
+  // or 0 for limitOrders, so that anyone can be the taker of the Order
+  const nonceAndMeta = (
+    BigInt(takerInNonce) +
+    (BigInt(nonce) << BigInt(160))
+  ).toString(10);
+
+  let taker: string;
+  // contractTaker overrides always
+  if (contractTaker) {
+    taker = contractTaker;
+  } else if (takerInNonce === ZERO_ADDRESS) {
+    // no takerInNonce -> not p2p order -> allow anyone to fill (not only Augustus)
+    taker = ZERO_ADDRESS;
+  } else {
+    // otherwise for p2p order ->
+    if (AppVersion.startsWith('6.')) {
+      //support 6.1+ versions
+
+      // limit taker to EOA for v6 version (no Arbitrary Token Swaps + OTC Fill, or OTC Fill through AugustusSwapper)
+      taker = takerInNonce;
+    } else {
+      // on v5
+      // -> fill through Augustus only
+      taker = AugustusAddress;
+    }
+  }
+
+  const order: OrderData = {
+    nonceAndMeta,
+    expiry,
+    makerAsset,
+    takerAsset,
+    maker,
+    taker,
+    makerAmount,
+    takerAmount,
+  };
+
+  return {
+    types: { Order },
+    domain: { name, version, chainId, verifyingContract },
+    data: order,
+  };
+}

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

@@ -0,0 +1,64 @@
+import {
+  BaseFetchUrl,
+  baseFetchUrlGetterFactory,
+  BaseFetchUrlInputConstructor,
+  MinFetchUrl,
+  OrderFillableBalanceFetchUrl,
+} from '../../common/orders/misc';
+import type { OrderData } from './buildOrderData';
+
+export function sanitizeOrderData({
+  nonceAndMeta,
+  expiry,
+  makerAsset,
+  takerAsset,
+  maker,
+  taker,
+  makerAmount,
+  takerAmount,
+}: OrderData & Record<string, any>): OrderData {
+  return {
+    nonceAndMeta,
+    expiry,
+    makerAsset,
+    takerAsset,
+    maker,
+    taker,
+    makerAmount,
+    takerAmount,
+  };
+}
+
+/* 
+GET
+/ft/orders/:chainId/maker/:walletAddress
+/ft/orders/:chainId/taker/:walletAddress
+/ft/p2p/:chainId/maker/:walletAddress
+/ft/p2p/:chainId/taker/:walletAddress
+*/
+export type GetOrdersURLs = `${BaseFetchUrl<'ft'>}/${
+  | 'taker'
+  | 'maker'}/${string}`;
+
+/*
+GET
+/ft/fillablebalance/:chainId/:walletAddress/:makerAsset?
+*/
+export type GetRequiredAllowanceURL =
+  `${OrderFillableBalanceFetchUrl<'ft'>}/${string}${`/${string}` | ''}`;
+
+/*
+GET
+/ft/order/:orderHash (get you p2p or orders)
+*/
+export type GetOrderURL = `${MinFetchUrl<'ft'>}/${string}`;
+
+/* 
+POST create order
+/ft/orders/:chainId/
+/ft/p2p/:chainId/
+*/
+export type PostOrderURLs = BaseFetchUrl<'ft'>;
+
+export const constructBaseFetchUrlGetter: BaseFetchUrlInputConstructor<'ft'> =
+  baseFetchUrlGetterFactory('ft');

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

@@ -0,0 +1,70 @@
+import type { OrderData } from './buildOrderData';
+
+export type LimitOrderType = 'LIMIT' | 'P2P';
+
+export type LimitOrder = LimitOrderFromApi;
+
+export type LimitOrderToSend = OrderData & {
+  permitMakerAsset?: string;
+  signature: string;
+};
+
+export type LimitOrdersApiResponse = {
+  limit: number;
+  offset: number;
+  total: number;
+  hasMore: boolean;
+  orders: LimitOrderFromApi[];
+};
+export type LimitOrderApiResponse = {
+  order: LimitOrderFromApi;
+};
+
+// display states such as EXPIRED and PARTIALLY_FILLLED derived on client side
+// returned by API but can be calculated too, EXPIRED == order.expiry < Date.now()/1000
+// PARTIALLY_FILLED == order.fillableBalance < order.makerAmount && order.fillableBalance !== '0'
+// SUSPENDED status was introduced for Limit orders to indicate that orders where makers lacked sufficient funds
+// to fulfill them would no longer be tracked. This status is similar to CANCELLED, but it reduces any ambiguity that might
+// arise when debugging or when users view their CANCELLED orders.
+export type LimitOrderState =
+  | 'DRAFT'
+  | 'PENDING'
+  | 'FULFILLED'
+  | 'CANCELLED'
+  | 'SUSPENDED'
+  | 'EXPIRED';
+
+export type LimitOrderEvent = '';
+
+export type LimitOrderTransaction = {
+  hash: string;
+  event_type: 'OrderFilled' | 'OrderCancelled';
+};
+
+export type LimitOrderFromApi = {
+  chainId: number;
+  nonceAndMeta: string; // uiint
+  expiry: number; // timestamp
+  maker: string; // address
+  taker: string; // address
+  makerAsset: string; // address
+  takerAsset: string; // address
+  makerAmount: string; // wei
+  takerAmount: string; // wei
+  makerBalance: string; // min(fillableBalance, allowance(maker), balance(maker)]
+  signature: string; // supplied by FE
+  permitMakerAsset: null | string; // address
+  orderHash: string; // hex string
+  createdAt: number; // timestamp
+  updatedAt: number; // timestamp
+  state: LimitOrderState;
+  /** @description transaction with the last event pertaining to the order: OrderFilled or OrderCancelled */
+  transactionHash: null | string;
+  // not yet returned
+  // transactions: LimitOrderTransaction[];
+  type: LimitOrderType;
+  takerFromMeta: string; // the intended receiver, eg receiving address of p2p order where `taker` would be augustus
+  fillableBalance: string; // amount that remains to be filled
+  reservedBalance: string; // amount that is currently reserved in this order
+  swappableBalance: string; // actual amount that can be filled at this time
+};

package/src/methods/limitOrders/index.ts

@@ -0,0 +1,154 @@
+import type {
+  ConstructProviderFetchInput,
+  RequestParameters,
+} from '../../types';
+import type { LimitOrderToSend, LimitOrderFromApi } from './helpers/types';
+import {
+  BuildLimitOrderFunctions,
+  BuildLimitOrderInput,
+  constructBuildLimitOrder,
+} from './buildOrder';
+import {
+  CancelLimitOrderFunctions,
+  constructCancelLimitOrder,
+} from './cancelOrder';
+import { constructGetLimitOrders, GetLimitOrdersFunctions } from './getOrders';
+import { constructPostLimitOrder, PostLimitOrderFunctions } from './postOrder';
+import { constructSignLimitOrder, SignLimitOrderFunctions } from './signOrder';
+import {
+  constructApproveTokenForLimitOrder,
+  ApproveTokenForLimitOrderFunctions,
+} from './approveForOrder';
+import {
+  GetLimitOrdersContractFunctions,
+  constructGetLimitOrdersContract,
+} from './getOrdersContract';
+import {
+  BuildLimitOrdersTxFunctions,
+  constructBuildLimitOrderTx,
+} from './transaction';
+import type { Address } from '@paraswap/core';
+import {
+  FillOrderDirectlyFunctions,
+  constructFillOrderDirectly,
+} from './fillOrderDirectly';
+
+type SubmitLimitOrder = (
+  buildLimitOrderParams: BuildLimitOrderInput,
+  extra?: { permitMakerAsset?: string },
+  requestParams?: RequestParameters
+) => Promise<LimitOrderFromApi>;
+
+type SubmitP2POrder = (
+  buildLimitOrderParams: BuildLimitOrderInput & { taker: Address },
+  extra?: { permitMakerAsset?: string },
+  requestParams?: RequestParameters
+) => Promise<LimitOrderFromApi>;
+
+export type SubmitLimitOrderFuncs = {
+  submitLimitOrder: SubmitLimitOrder;
+  submitP2POrder: SubmitP2POrder;
+};
+
+export const constructSubmitLimitOrder = (
+  options: ConstructProviderFetchInput<any, 'signTypedDataCall'>
+): SubmitLimitOrderFuncs => {
+  const { buildLimitOrder } = constructBuildLimitOrder(options);
+  const { signLimitOrder } = constructSignLimitOrder(options);
+  const { postLimitOrder, postP2POrder } = constructPostLimitOrder(options);
+
+  const prepareLimitOrder = async (
+    buildLimitOrderParams: BuildLimitOrderInput,
+    extra?: { permitMakerAsset?: string }
+  ): Promise<LimitOrderToSend> => {
+    const orderData = await buildLimitOrder(buildLimitOrderParams);
+    const signature = await signLimitOrder(orderData);
+
+    const orderWithSignature: LimitOrderToSend = {
+      ...orderData.data,
+      ...extra,
+      signature,
+    };
+
+    return orderWithSignature;
+  };
+
+  const submitLimitOrder: SubmitLimitOrder = async (
+    buildLimitOrderParams,
+    extra = {},
+    requestParams
+  ) => {
+    const orderWithSignature: LimitOrderToSend = await prepareLimitOrder(
+      buildLimitOrderParams,
+      extra
+    );
+
+    const newOrder = await postLimitOrder(orderWithSignature, requestParams);
+
+    return newOrder;
+  };
+
+  const submitP2POrder: SubmitP2POrder = async (
+    buildLimitOrderParams,
+    extra = {},
+    requestParams
+  ) => {
+    const orderWithSignature: LimitOrderToSend = await prepareLimitOrder(
+      buildLimitOrderParams,
+      extra
+    );
+
+    const newOrder = await postP2POrder(orderWithSignature, requestParams);
+
+    return newOrder;
+  };
+
+  return { submitLimitOrder, submitP2POrder };
+};
+
+export type LimitOrderHandlers<T> = SubmitLimitOrderFuncs &
+  BuildLimitOrderFunctions &
+  SignLimitOrderFunctions &
+  PostLimitOrderFunctions &
+  GetLimitOrdersFunctions &
+  GetLimitOrdersContractFunctions &
+  BuildLimitOrdersTxFunctions &
+  CancelLimitOrderFunctions<T> &
+  ApproveTokenForLimitOrderFunctions<T> &
+  FillOrderDirectlyFunctions<T>;
+
+/** @description construct SDK with every LimitOrders-related method, fetching from API and contract calls */
+export const constructAllLimitOrdersHandlers = <TxResponse>(
+  options: ConstructProviderFetchInput<
+    TxResponse,
+    'signTypedDataCall' | 'transactCall' | 'staticCall'
+  >
+): LimitOrderHandlers<TxResponse> => {
+  const limitOrdersGetters = constructGetLimitOrders(options);
+  const limitOrdersContractGetter = constructGetLimitOrdersContract(options);
+
+  const limitOrdersSubmit = constructSubmitLimitOrder(options);
+  const limitOrdersBuild = constructBuildLimitOrder(options);
+  const limitOrdersSign = constructSignLimitOrder(options);
+  const limitOrdersPost = constructPostLimitOrder(options);
+
+  const limitOrdersCancel = constructCancelLimitOrder(options);
+  const limitOrdersApproveToken = constructApproveTokenForLimitOrder(options);
+
+  const limitOrdersFillOrderDirectly = constructFillOrderDirectly(options);
+
+  const limitOrdersBuildTx = constructBuildLimitOrderTx(options);
+
+  return {
+    ...limitOrdersGetters,
+    ...limitOrdersContractGetter,
+    ...limitOrdersSubmit,
+    ...limitOrdersBuild,
+    ...limitOrdersSign,
+    ...limitOrdersPost,
+    ...limitOrdersCancel,
+    ...limitOrdersApproveToken,
+    ...limitOrdersFillOrderDirectly,
+    ...limitOrdersBuildTx,
+  };
+};

package/src/methods/limitOrders/postOrder.ts

@@ -0,0 +1,74 @@
+import { API_URL } from '../../constants';
+import type { ConstructFetchInput, RequestParameters } from '../../types';
+import { constructBaseFetchUrlGetter, PostOrderURLs } from './helpers/misc';
+import type {
+  LimitOrderApiResponse,
+  LimitOrderToSend,
+  LimitOrderFromApi,
+  LimitOrderType,
+} from './helpers/types';
+
+type PostLimitOrder = (
+  limitOrderWithSignatureAndPermit: LimitOrderToSend,
+  requestParams?: RequestParameters
+) => Promise<LimitOrderFromApi>;
+
+export type PostLimitOrderFunctions = {
+  postLimitOrder: PostLimitOrder;
+  postP2POrder: PostLimitOrder;
+};
+
+export const constructPostLimitOrder = ({
+  apiURL = API_URL,
+  chainId,
+  fetcher,
+}: ConstructFetchInput): PostLimitOrderFunctions => {
+  const getBaseFetchURLByOrderType = constructBaseFetchUrlGetter({
+    apiURL,
+    chainId,
+  });
+
+  const postTypedOrder = async (
+    limitOrderWithSignatureAndPermit: LimitOrderToSend,
+    type: LimitOrderType,
+    requestParams?: RequestParameters
+  ): Promise<LimitOrderFromApi> => {
+    const fetchURL = getBaseFetchURLByOrderType(type);
+
+    const { order: newOrder } = await fetcher<
+      LimitOrderApiResponse,
+      PostOrderURLs
+    >({
+      url: fetchURL,
+      method: 'POST',
+      data: limitOrderWithSignatureAndPermit,
+      requestParams,
+    });
+
+    return newOrder;
+  };
+
+  const postLimitOrder: PostLimitOrder = (
+    limitOrderWithSignatureAndPermit,
+    requestParams
+  ) => {
+    return postTypedOrder(
+      limitOrderWithSignatureAndPermit,
+      'LIMIT',
+      requestParams
+    );
+  };
+
+  const postP2POrder: PostLimitOrder = (
+    limitOrderWithSignatureAndPermit,
+    requestParams
+  ) => {
+    return postTypedOrder(
+      limitOrderWithSignatureAndPermit,
+      'P2P',
+      requestParams
+    );
+  };
+
+  return { postLimitOrder, postP2POrder };
+};

package/src/methods/limitOrders/signOrder.ts

@@ -0,0 +1,29 @@
+import type { ConstructProviderFetchInput } from '../../types';
+import type { SignableOrderData } from './buildOrder';
+import { sanitizeOrderData } from './helpers/misc';
+
+export type SignLimitOrderFunctions = {
+  signLimitOrder: (signableOrderData: SignableOrderData) => Promise<string>;
+};
+
+// returns whatever `contractCaller` returns
+// to allow for better versatility
+export const constructSignLimitOrder = (
+  options: Pick<
+    ConstructProviderFetchInput<any, 'signTypedDataCall'>,
+    'contractCaller'
+  >
+): SignLimitOrderFunctions => {
+  const signLimitOrder: SignLimitOrderFunctions['signLimitOrder'] = (
+    typedData
+  ) => {
+    // types allow to pass OrderData & extra_stuff, but tx will break like that
+    const typedDataOnly: SignableOrderData = {
+      ...typedData,
+      data: sanitizeOrderData(typedData.data),
+    };
+    return options.contractCaller.signTypedDataCall(typedDataOnly);
+  };
+
+  return { signLimitOrder };
+};