@velora-dex/sdk 8.0.0

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

@@ -0,0 +1,153 @@
+import { MarkOptional } from 'ts-essentials';
+import { Domain, ZERO_ADDRESS } from '../../common/orders/buildOrderData';
+import { Bridge, DeltaAuctionOrder } from './types';
+import { composeDeltaOrderPermit } from './composePermit';
+
+// 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 = {
+  Order: [
+    { name: 'owner', type: 'address' },
+    { name: 'beneficiary', type: 'address' },
+    { name: 'srcToken', type: 'address' },
+    { name: 'destToken', type: 'address' },
+    { name: 'srcAmount', type: 'uint256' },
+    { name: 'destAmount', type: 'uint256' },
+    { name: 'expectedDestAmount', type: 'uint256' },
+    { name: 'deadline', type: 'uint256' },
+    { name: 'nonce', type: 'uint256' },
+    { name: 'partnerAndFee', type: 'uint256' },
+    { name: 'permit', type: 'bytes' },
+    { name: 'bridge', type: 'Bridge' },
+  ],
+  Bridge: [
+    { name: 'maxRelayerFee', type: 'uint256' },
+    { name: 'destinationChainId', type: 'uint256' },
+    { name: 'outputToken', type: 'address' },
+    { name: 'multiCallHandler', type: 'address' },
+  ],
+};
+
+export type SignableDeltaOrderData = {
+  types: {
+    Order: typeof SWAP_ORDER_EIP_712_TYPES.Order;
+    Bridge: typeof SWAP_ORDER_EIP_712_TYPES.Bridge;
+  };
+  domain: Domain;
+  data: DeltaAuctionOrder;
+};
+
+type SignDeltaOrderInput = {
+  orderInput: DeltaAuctionOrder;
+  paraswapDeltaAddress: string;
+  chainId: number;
+};
+
+function produceDeltaOrderTypedData({
+  orderInput,
+  chainId,
+  paraswapDeltaAddress,
+}: SignDeltaOrderInput): SignableDeltaOrderData {
+  const typedData = {
+    types: {
+      Order: SWAP_ORDER_EIP_712_TYPES.Order,
+      Bridge: SWAP_ORDER_EIP_712_TYPES.Bridge,
+    },
+    domain: {
+      name: 'Portikus',
+      version: '2.0.0',
+      chainId,
+      verifyingContract: paraswapDeltaAddress,
+    },
+    data: orderInput,
+  };
+
+  return typedData;
+}
+
+export type DeltaOrderDataInput = MarkOptional<
+  Omit<DeltaAuctionOrder, 'partnerAndFee'>,
+  'beneficiary' | 'deadline' | 'nonce' | 'permit'
+>;
+
+export type BuildDeltaOrderDataInput = DeltaOrderDataInput & {
+  partnerAddress: string;
+  paraswapDeltaAddress: string;
+  partnerFeeBps: number;
+  partnerTakesSurplus?: boolean;
+  chainId: number;
+  bridge: Bridge;
+};
+
+// default deadline = 1 hour from now (may be changed later)
+export const DELTA_DEFAULT_EXPIRY = 60 * 60; // seconds
+
+export function buildDeltaSignableOrderData({
+  owner,
+  beneficiary = owner,
+
+  srcToken,
+  destToken,
+  srcAmount,
+  destAmount,
+  expectedDestAmount,
+
+  deadline = Math.floor(Date.now() / 1000 + DELTA_DEFAULT_EXPIRY),
+  nonce = Date.now().toString(10), // random enough to not cause collisions
+
+  permit = '0x',
+
+  partnerAddress,
+  partnerFeeBps,
+  partnerTakesSurplus = false,
+
+  chainId,
+  paraswapDeltaAddress,
+  bridge,
+}: BuildDeltaOrderDataInput): SignableDeltaOrderData {
+  const orderInput: DeltaAuctionOrder = {
+    owner,
+    beneficiary,
+    srcToken,
+    destToken,
+    srcAmount,
+    destAmount,
+    expectedDestAmount,
+    deadline,
+    nonce,
+    permit: composeDeltaOrderPermit({ permit, nonce }),
+    partnerAndFee: producePartnerAndFee({
+      partnerFeeBps,
+      partnerAddress,
+      partnerTakesSurplus,
+    }),
+    bridge,
+  };
+
+  return produceDeltaOrderTypedData({
+    orderInput,
+    chainId,
+    paraswapDeltaAddress,
+  });
+}
+
+type ProducePartnerAndFeeInput = {
+  partnerFeeBps: number;
+  partnerAddress: string;
+  partnerTakesSurplus: boolean;
+};
+
+// fee and address are encoded together
+function producePartnerAndFee({
+  partnerFeeBps,
+  partnerAddress,
+  partnerTakesSurplus,
+}: ProducePartnerAndFeeInput): string {
+  if (partnerAddress === ZERO_ADDRESS) return '0';
+
+  const partnerAndFee =
+    (BigInt(partnerAddress) << BigInt(96)) |
+    BigInt(partnerFeeBps.toFixed(0)) |
+    (BigInt(partnerTakesSurplus) << BigInt(8));
+
+  return partnerAndFee.toString(10);
+}

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

@@ -0,0 +1,76 @@
+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('')
+  );
+}

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

@@ -0,0 +1,32 @@
+import type { SignableDeltaOrderData } from './buildDeltaOrderData';
+
+export function sanitizeDeltaOrderData({
+  owner,
+  beneficiary,
+  srcToken,
+  destToken,
+  srcAmount,
+  destAmount,
+  expectedDestAmount,
+  deadline,
+  nonce,
+  permit,
+  partnerAndFee,
+  bridge,
+}: SignableDeltaOrderData['data'] &
+  Record<string, any>): SignableDeltaOrderData['data'] {
+  return {
+    owner,
+    beneficiary,
+    srcToken,
+    destToken,
+    srcAmount,
+    destAmount,
+    expectedDestAmount,
+    deadline,
+    nonce,
+    permit,
+    partnerAndFee,
+    bridge,
+  };
+}

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

@@ -0,0 +1,110 @@
+export type DeltaAuctionOrder = {
+  /** @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 amount of src token to swap */
+  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 deadline for the order */
+  deadline: number; // seconds
+  /** @description The nonce of the order */
+  nonce: string; // can be random, can even be Date.now()
+  /** @description Optional permit signature for the src token */
+  permit: string; //can be "0x"
+  /** @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 bridge input */
+  bridge: Bridge;
+};
+
+export type Bridge = {
+  maxRelayerFee: 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;
+};
+
+type DeltaAuctionStatus =
+  | 'NOT_STARTED'
+  | 'POSTED'
+  | 'RUNNING'
+  | 'EXECUTING'
+  | 'EXECUTED'
+  | 'FAILED'
+  | 'EXPIRED';
+
+type DeltaAuctionTransaction = {
+  id: string;
+  hash: string;
+  orderId: string;
+  bidId: string | null;
+  blockNumber: number;
+  blockHash: string;
+  gasUsed: bigint;
+  gasPrice: bigint;
+  blobGasUsed: bigint;
+  blobGasPrice: bigint;
+  index: number;
+  status: number;
+  from: string;
+  to: string;
+  receivedAmount: string;
+  receivedAmountUSD: number;
+  spentAmount: string;
+  spentAmountUSD: number;
+  filledPercent: number; // in base points
+  protocolFee: string;
+  partnerFee: string;
+  agent: string;
+  auctionId: string;
+};
+
+export type DeltaAuction = {
+  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;
+  partner: string;
+  referrerAddress: string | null;
+  expiresAt: string;
+  createdAt: string;
+  updatedAt: string;
+  partiallyFillable: boolean;
+
+  excludeAgents: string[] | null;
+  includeAgents: string[] | null;
+
+  bridgeMetadata: BridgeMetadata | null;
+  bridgeStatus: BridgeStatus | null;
+};
+
+export type BridgeMetadata = {
+  /** @description The amount that user should expect to get */
+  outputAmount: string;
+  /** @description The cross-chain deadline. If deadline passes, the bridgeStatus would be expired */
+  fillDeadline: number;
+  /** @description The deposit id */
+  depositId: number;
+  /** @description The transaction hash on the destination chain that fulfilled the order. When bridgeStatus='filled' */
+  fillTx?: string;
+  /** @description The transaction hash on the source chain that refunded the deposit. When bridgeStatus='refunded' */
+  depositRefundTxHash?: string;
+};
+
+//                                                             refunded is basically failed
+export type BridgeStatus = 'pending' | 'filled' | 'expired' | 'refunded';

package/src/methods/delta/index.ts

@@ -0,0 +1,146 @@
+import type { ConstructProviderFetchInput } from '../../types';
+import type { DeltaAuction } from './helpers/types';
+import {
+  BuildDeltaOrderDataParams,
+  BuildDeltaOrderFunctions,
+  constructBuildDeltaOrder,
+} from './buildDeltaOrder';
+import {
+  constructPostDeltaOrder,
+  PostDeltaOrderFunctions,
+} from './postDeltaOrder';
+import {
+  constructSignDeltaOrder,
+  SignDeltaOrderFunctions,
+} from './signDeltaOrder';
+import {
+  GetDeltaContractFunctions,
+  constructGetDeltaContract,
+} from './getDeltaContract';
+import {
+  constructGetDeltaPrice,
+  GetDeltaPriceFunctions,
+} from './getDeltaPrice';
+import {
+  constructGetDeltaOrders,
+  GetDeltaOrdersFunctions,
+} from './getDeltaOrders';
+import {
+  constructGetPartnerFee,
+  GetPartnerFeeFunctions,
+} from './getPartnerFee';
+import {
+  ApproveTokenForDeltaFunctions,
+  constructApproveTokenForDelta,
+} from './approveForDelta';
+import {
+  constructGetBridgeInfo,
+  GetBridgeInfoFunctions,
+} from './getBridgeInfo';
+import {
+  constructGetMulticallHandlers,
+  GetMulticallHandlersFunctions,
+} from './getMulticallHandlers';
+import {
+  constructIsTokenSupportedInDelta,
+  IsTokenSupportedInDeltaFunctions,
+} from './isTokenSupportedInDelta';
+import {
+  BuildCrosschainOrderBridgeFunctions,
+  constructBuildCrosschainOrderBridge,
+} from './buildCrosschainOrderBridge';
+
+export type SubmitDeltaOrderParams = BuildDeltaOrderDataParams & {
+  /** @description designates the Order as being able to be partially filled, as opposed to fill-or-kill */
+  partiallyFillable?: boolean;
+};
+
+type SubmitDeltaOrder = (
+  orderParams: SubmitDeltaOrderParams
+) => Promise<DeltaAuction>;
+
+export type SubmitDeltaOrderFuncs = {
+  submitDeltaOrder: SubmitDeltaOrder;
+};
+
+export const constructSubmitDeltaOrder = (
+  options: ConstructProviderFetchInput<any, 'signTypedDataCall'>
+): SubmitDeltaOrderFuncs => {
+  const { buildDeltaOrder } = constructBuildDeltaOrder(options);
+  const { signDeltaOrder } = constructSignDeltaOrder(options);
+  const { postDeltaOrder } = constructPostDeltaOrder(options);
+
+  const submitDeltaOrder: SubmitDeltaOrder = async (orderParams) => {
+    const orderData = await buildDeltaOrder(orderParams);
+    const signature = await signDeltaOrder(orderData);
+
+    const response = await postDeltaOrder({
+      signature,
+      partner: orderParams.partner,
+      order: orderData.data,
+      partiallyFillable: orderParams.partiallyFillable,
+    });
+
+    return response;
+  };
+
+  return { submitDeltaOrder };
+};
+
+export type DeltaOrderHandlers<T> = SubmitDeltaOrderFuncs &
+  ApproveTokenForDeltaFunctions<T> &
+  BuildDeltaOrderFunctions &
+  BuildCrosschainOrderBridgeFunctions &
+  GetDeltaOrdersFunctions &
+  GetDeltaPriceFunctions &
+  GetDeltaContractFunctions &
+  GetPartnerFeeFunctions &
+  GetMulticallHandlersFunctions &
+  GetBridgeInfoFunctions &
+  IsTokenSupportedInDeltaFunctions &
+  PostDeltaOrderFunctions &
+  SignDeltaOrderFunctions;
+
+/** @description construct SDK with every Delta Order-related method, fetching from API and Order signing */
+export const constructAllDeltaOrdersHandlers = <TxResponse>(
+  options: ConstructProviderFetchInput<
+    TxResponse,
+    'signTypedDataCall' | 'transactCall'
+  >
+): DeltaOrderHandlers<TxResponse> => {
+  const deltaOrdersGetters = constructGetDeltaOrders(options);
+  const deltaOrdersContractGetter = constructGetDeltaContract(options);
+  const deltaPrice = constructGetDeltaPrice(options);
+
+  const partnerFee = constructGetPartnerFee(options);
+  const bridgeInfo = constructGetBridgeInfo(options);
+  const isTokenSupportedInDelta = constructIsTokenSupportedInDelta(options);
+  const multicallHandlers = constructGetMulticallHandlers(options);
+
+  const approveTokenForDelta = constructApproveTokenForDelta(options);
+
+  const deltaOrdersSubmit = constructSubmitDeltaOrder(options);
+
+  const buildCrosschainOrderBridge =
+    constructBuildCrosschainOrderBridge(options);
+
+  const deltaOrdersBuild = constructBuildDeltaOrder(options);
+  const deltaOrdersSign = constructSignDeltaOrder(options);
+  const deltaOrdersPost = constructPostDeltaOrder(options);
+
+  return {
+    ...deltaOrdersGetters,
+    ...deltaOrdersContractGetter,
+    ...deltaPrice,
+    ...partnerFee,
+    ...bridgeInfo,
+    ...isTokenSupportedInDelta,
+    ...multicallHandlers,
+    ...approveTokenForDelta,
+    ...deltaOrdersSubmit,
+    ...deltaOrdersBuild,
+    ...deltaOrdersSign,
+    ...deltaOrdersPost,
+    ...buildCrosschainOrderBridge,
+  };
+};

package/src/methods/delta/isTokenSupportedInDelta.ts

@@ -0,0 +1,54 @@
+import { API_URL } from '../../constants';
+import { constructSearchString } from '../../helpers/misc';
+import type {
+  Address,
+  ConstructFetchInput,
+  RequestParameters,
+} from '../../types';
+
+type TokenSupportedInDeltaResponse = { supported: boolean };
+type IsTokenSupportedInDeltaQueryOptions = {
+  token: Address;
+  chainId: number;
+};
+
+type IsTokenSupportedInDelta = (
+  token: Address,
+  requestParams?: RequestParameters
+) => Promise<boolean>;
+
+export type IsTokenSupportedInDeltaFunctions = {
+  isTokenSupportedInDelta: IsTokenSupportedInDelta;
+};
+
+export const constructIsTokenSupportedInDelta = ({
+  apiURL = API_URL,
+  chainId,
+  fetcher,
+}: ConstructFetchInput): IsTokenSupportedInDeltaFunctions => {
+  const bridgeInfoUrl = `${apiURL}/delta/prices/is-token-supported` as const;
+
+  const isTokenSupportedInDelta: IsTokenSupportedInDelta = async (
+    token,
+    requestParams
+  ) => {
+    const search = constructSearchString<IsTokenSupportedInDeltaQueryOptions>({
+      token,
+      chainId,
+    });
+
+    const fetchURL = `${bridgeInfoUrl}/${search}` as const;
+
+    const data = await fetcher<TokenSupportedInDeltaResponse>({
+      url: fetchURL,
+      method: 'GET',
+      requestParams,
+    });
+
+    return data.supported;
+  };
+
+  return {
+    isTokenSupportedInDelta,
+  };
+};

package/src/methods/delta/postDeltaOrder.ts

@@ -0,0 +1,50 @@
+import { API_URL } from '../../constants';
+import type { ConstructFetchInput, RequestParameters } from '../../types';
+import { DeltaAuctionOrder, DeltaAuction } from './helpers/types';
+
+export type DeltaOrderToPost = {
+  /** @description Partner string */
+  partner?: string;
+  /** @description Referrer address */
+  referrerAddress?: string;
+  order: DeltaAuctionOrder;
+  /** @description Signature of the order from order.owner address. EOA signatures must be submitted in ERC-2098 Compact Representation. */
+  signature: string;
+  chainId: number;
+  /** @description designates the Order as being able to partially filled, as opposed to fill-or-kill */
+  partiallyFillable?: boolean;
+};
+
+export type PostDeltaOrderParams = Omit<DeltaOrderToPost, 'chainId'>;
+
+type DeltaOrderApiResponse = DeltaAuction;
+
+type PostDeltaOrder = (
+  postData: PostDeltaOrderParams,
+  requestParams?: RequestParameters
+) => Promise<DeltaOrderApiResponse>;
+
+export type PostDeltaOrderFunctions = {
+  postDeltaOrder: PostDeltaOrder;
+};
+
+export const constructPostDeltaOrder = ({
+  apiURL = API_URL,
+  chainId,
+  fetcher,
+}: ConstructFetchInput): PostDeltaOrderFunctions => {
+  const postOrderUrl = `${apiURL}/delta/orders` as const;
+
+  const postDeltaOrder: PostDeltaOrder = (postData, requestParams) => {
+    const deltaOrderToPost: DeltaOrderToPost = { ...postData, chainId };
+
+    return fetcher<DeltaOrderApiResponse>({
+      url: postOrderUrl,
+      method: 'POST',
+      data: deltaOrderToPost,
+      requestParams,
+    });
+  };
+
+  return { postDeltaOrder };
+};

package/src/methods/delta/signDeltaOrder.ts

@@ -0,0 +1,41 @@
+import type { ConstructProviderFetchInput } from '../../types';
+import { SignableDeltaOrderData } from './helpers/buildDeltaOrderData';
+import { sanitizeDeltaOrderData } from './helpers/misc';
+
+export type SignLimitOrderFunctions = {
+  signLimitOrder: (
+    signableOrderData: SignableDeltaOrderData
+  ) => Promise<string>;
+};
+
+type SignDeltaOrder = (
+  signableOrderData: SignableDeltaOrderData
+) => Promise<string>;
+
+export type SignDeltaOrderFunctions = {
+  signDeltaOrder: SignDeltaOrder;
+};
+
+// returns whatever `contractCaller` returns
+// to allow for better versatility
+export const constructSignDeltaOrder = (
+  options: Pick<
+    ConstructProviderFetchInput<any, 'signTypedDataCall'>,
+    'contractCaller'
+  >
+): SignDeltaOrderFunctions => {
+  const signDeltaOrder: SignDeltaOrder = async (typedData) => {
+    // types allow to pass OrderData & extra_stuff, but tx will break like that
+    const typedDataOnly: SignableDeltaOrderData = {
+      ...typedData,
+      data: sanitizeDeltaOrderData(typedData.data),
+    };
+    const signature = await options.contractCaller.signTypedDataCall(
+      typedDataOnly
+    );
+
+    return signature;
+  };
+
+  return { signDeltaOrder };
+};

package/src/methods/limitOrders/approveForOrder.ts

@@ -0,0 +1,36 @@
+import type { ConstructProviderFetchInput } from '../../types';
+import { ApproveToken, approveTokenMethodFactory } from '../../helpers/approve';
+import { constructApproveToken } from '../swap/approve';
+import { constructGetSpender } from '../swap/spender';
+
+export type ApproveTokenForLimitOrderFunctions<T> = {
+  /** @description approving AugustusRFQ as spender for makerAsset */
+  approveMakerTokenForLimitOrder: ApproveToken<T>;
+  /** @description approving AugustusRFQ as spender for takerAsset to call SDK.fillOrderDirectly */
+  approveTakerTokenForFillingP2POrderDirectly: ApproveToken<T>;
+  /** @description approving AugustusSwapper as spender for takerAsset for Limit Orders that will be executed through it */
+  approveTakerTokenForLimitOrder: ApproveToken<T>;
+};
+
+// returns whatever `contractCaller` returns
+// to allow for better versatility
+export const constructApproveTokenForLimitOrder = <T>(
+  options: ConstructProviderFetchInput<T, 'transactCall'>
+): ApproveTokenForLimitOrderFunctions<T> => {
+  // getAugustusRFQ is cached internally for the same instance of SDK
+  // so should persist across same apiUrl & network
+  const { getAugustusRFQ } = constructGetSpender(options);
+
+  const approveMakerTokenForLimitOrder: ApproveToken<T> =
+    approveTokenMethodFactory<T>(options.contractCaller, getAugustusRFQ);
+
+  // approving TokenTransaferProxy as for the swap
+  const { approveToken: approveTakerTokenForLimitOrder } =
+    constructApproveToken(options);
+
+  return {
+    approveMakerTokenForLimitOrder,
+    approveTakerTokenForFillingP2POrderDirectly: approveMakerTokenForLimitOrder,
+    approveTakerTokenForLimitOrder,
+  };
+};