Feat/Delta support

README.md

@@ -205,4 +205,4 @@ Refer to [SDK API documentation](docs/md/modules.md) for detailed documentation
 To run `yarn test` it is necessary to provide `PROVIDER_URL=<mainnet_rpc_url>` environment variable.
 If it is necessary to run tests against a different API endpoint, provide `API_URL=url_to_API` environment variable.
 
-<img src="./docs/passed_tests.jpg" width=350 />
+<img src="./docs/passed_tests.png" width=350 />

src/examples/delta.ts

@@ -0,0 +1,125 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import axios from 'axios';
+import { ethers, Wallet } from 'ethersV5';
+import {
+  constructPartialSDK,
+  constructEthersContractCaller,
+  constructAxiosFetcher,
+  constructAllDeltaOrdersHandlers,
+} from '..';
+
+const fetcher = constructAxiosFetcher(axios);
+
+const provider = ethers.getDefaultProvider(1);
+const signer = Wallet.createRandom().connect(provider);
+const account = signer.address;
+const contractCaller = constructEthersContractCaller({
+  ethersProviderOrSigner: provider,
+  EthersContract: ethers.Contract,
+});
+
+// type AdaptersFunctions & ApproveTokenFunctions<ethers.ContractTransaction>
+const deltaSDK = constructPartialSDK(
+  {
+    chainId: 1,
+    fetcher,
+    contractCaller,
+  },
+  constructAllDeltaOrdersHandlers
+);
+
+const DAI_TOKEN = '0x6b175474e89094c44da98b954eedeac495271d0f';
+const PSP_TOKEN = '0xcafe001067cdef266afb7eb5a286dcfd277f3de5';
+
+async function simpleDeltaFlow() {
+  const amount = '1000000000000'; // wei
+
+  const deltaPrice = await deltaSDK.getDeltaPrice({
+    srcToken: DAI_TOKEN,
+    destToken: PSP_TOKEN,
+    amount: '1000000000000',
+    userAddress: account,
+    srcDecimals: 18,
+    destDecimals: 18,
+    // partner: "..." // if available
+  });
+
+  const DeltaContract = await deltaSDK.getDeltaContract();
+
+  // or sign a Permit1 or Permit2 TransferFrom for DeltaContract
+  await deltaSDK.approveTokenForDelta(amount, DAI_TOKEN);
+
+  const slippagePercent = 0.5;
+  const destAmountAfterSlippage = BigInt(
+    // get rid of exponential notation
+
+    +(+deltaPrice.destAmount * (1 - slippagePercent / 100)).toFixed(0)
+    // get rid of decimals
+  ).toString(10);
+
+  const deltaAuction = await deltaSDK.submitDeltaOrder({
+    deltaPrice,
+    owner: account,
+    // beneficiary: anotherAccount, // if need to send destToken to another account
+    // permit: "0x1234...", // if signed a Permit1 or Permit2 TransferFrom for DeltaContract
+    srcToken: DAI_TOKEN,
+    destToken: PSP_TOKEN,
+    srcAmount: amount,
+    destAmount: destAmountAfterSlippage, // minimum acceptable destAmount
+  });
+
+  // poll if necessary
+  const auction = await deltaSDK.getDeltaOrderById(deltaAuction.id);
+  if (auction?.status === 'EXECUTED') {
+    console.log('Auction was executed');
+  }
+}
+async function manualDeltaFlow() {
+  const amount = '1000000000000'; // wei
+
+  const deltaPrice = await deltaSDK.getDeltaPrice({
+    srcToken: DAI_TOKEN,
+    destToken: PSP_TOKEN,
+    amount: '1000000000000',
+    userAddress: account,
+    srcDecimals: 18,
+    destDecimals: 18,
+    // partner: "..." // if available
+  });
+
+  const DeltaContract = await deltaSDK.getDeltaContract();
+
+  // or sign a Permit1 or Permit2 TransferFrom for DeltaContract
+  await deltaSDK.approveTokenForDelta(amount, DAI_TOKEN);
+
+  const slippagePercent = 0.5;
+  const destAmountAfterSlippage = (
+    +deltaPrice.destAmount *
+    (1 - slippagePercent / 100)
+  ).toString(10);
+
+  const signableOrderData = await deltaSDK.buildDeltaOrder({
+    deltaPrice,
+    owner: account,
+    // beneficiary: anotherAccount, // if need to send destToken to another account
+    // permit: "0x1234...", // if signed a Permit1 or Permit2 TransferFrom for DeltaContract
+    srcToken: DAI_TOKEN,
+    destToken: PSP_TOKEN,
+    srcAmount: amount,
+    destAmount: destAmountAfterSlippage, // minimum acceptable destAmount
+  });
+
+  const signature = await deltaSDK.signDeltaOrder(signableOrderData);
+
+  const deltaAuction = await deltaSDK.postDeltaOrder({
+    // partner: "..." // if available
+    order: signableOrderData.data,
+    signature,
+  });
+
+  // poll if necessary
+  const auction = await deltaSDK.getDeltaOrderById(deltaAuction.id);
+  if (auction?.status === 'EXECUTED') {
+    console.log('Auction was executed');
+  }
+}

src/helpers/fetchers/fetch.ts

@@ -20,7 +20,7 @@ export const constructFetcher =
 
       // adding apiKey to headers if it's provided
       const apiHeaders = extra?.apiKey
-        ? { 'X-API-KEY': extra.apiKey, ...params.headers }
+        ? { 'X-API-KEY': extra.apiKey }
         : undefined;
 
       // all headers combined

src/helpers/misc.ts

@@ -158,3 +158,60 @@ export function runOnceAndCache<T, Args extends any[]>(
     return result ?? (result = func(...args));
   };
 }
+
+export function deriveCompactSignature(signature: string): string {
+  // Remove "0x" prefix if present
+  if (signature.startsWith('0x')) {
+    signature = signature.slice(2);
+  }
+
+  // Convert the hex string to a byte array
+  const bytes = new Uint8Array(signature.length / 2);
+  for (let i = 0; i < signature.length; i += 2) {
+    bytes[i / 2] = parseInt(signature.substr(i, 2), 16);
+  }
+
+  // Validate the signature length (64 or 65 bytes)
+  if (bytes.length !== 64 && bytes.length !== 65) {
+    throw new Error('Invalid signature length: must be 64 or 65 bytes');
+  }
+
+  // Extract r and s components
+  const r = `0x${Array.from(bytes.slice(0, 32), (b) =>
+    b.toString(16).padStart(2, '0')
+  ).join('')}`;
+  let v;
+
+  // Handle 64-byte (EIP-2098 compact) and 65-byte signatures
+  if (bytes.length === 64) {
+    // Extract v from the highest bit of s and clear the bit in s
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    v = 27 + (bytes[32]! >> 7);
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    bytes[32]! &= 0x7f; // Clear the highest bit
+  } else {
+    // Extract v directly for 65-byte signature
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    v = bytes[64]!;
+
+    // Normalize v to canonical form (27 or 28)
+    if (v < 27) {
+      v += 27;
+    }
+  }
+
+  // Compute yParityAndS (_vs) for the compact signature
+  const sBytes = Array.from(bytes.slice(32, 64));
+  if (v === 28) {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    sBytes[0]! |= 0x80; // Set the highest bit if v is 28
+  }
+  const yParityAndS = `0x${sBytes
+    .map((b) => b.toString(16).padStart(2, '0'))
+    .join('')}`;
+
+  // Construct the compact signature by concatenating r and yParityAndS
+  const compactSignature = r + yParityAndS.slice(2);
+
+  return compactSignature;
+}

src/helpers/providers/ethersV6.ts

@@ -43,8 +43,8 @@ export const constructContractCaller = (
 
     const callableContractFunction = contract.getFunction(contractMethod);
 
-    // returns whatever the Contract.method returns: BigNumber, string, boolean
-    return callableContractFunction(...args, normalizedOverrides);
+    // returns whatever the Contract["method"].staticCall returns: BigNumber, string, boolean
+    return callableContractFunction.staticCall(...args, normalizedOverrides);
   };
 
   const transactCall: TransactionContractCallerFn<
@@ -77,7 +77,7 @@ export const constructContractCaller = (
     // if no method for contractMethod, ethers will throw
     const callableContractFunction = contract.getFunction(contractMethod);
 
-    const txResponse = await callableContractFunction(
+    const txResponse = await callableContractFunction.send(
       ...args,
       normalizedOverrides
     );

src/index.ts

@@ -131,6 +131,48 @@ import type {
   ParaSwapVersionUnion as ParaSwapVersion,
 } from './types';
 
+import type {
+  DeltaAuctionOrder,
+  ParaswapDeltaAuction,
+} from './methods/delta/helpers/types';
+import {
+  BuildDeltaOrderDataParams,
+  BuildDeltaOrderFunctions,
+  constructBuildDeltaOrder,
+  SignableDeltaOrderData,
+} from './methods/delta/buildDeltaOrder';
+import {
+  constructPostDeltaOrder,
+  PostDeltaOrderFunctions,
+  PostDeltaOrderParams,
+} from './methods/delta/postDeltaOrder';
+import {
+  constructSignDeltaOrder,
+  SignDeltaOrderFunctions,
+} from './methods/delta/signDeltaOrder';
+import {
+  GetDeltaContractFunctions,
+  constructGetDeltaContract,
+} from './methods/delta/getDeltaContract';
+import {
+  constructGetDeltaPrice,
+  GetDeltaPriceFunctions,
+  DeltaPrice,
+  DeltaPriceParams,
+} from './methods/delta/getDeltaPrice';
+import {
+  constructGetDeltaOrders,
+  GetDeltaOrdersFunctions,
+} from './methods/delta/getDeltaOrders';
+import {
+  ApproveTokenForDeltaFunctions,
+  constructApproveTokenForDelta,
+} from './methods/delta/approveForDelta';
+import {
+  constructGetPartnerFee,
+  GetPartnerFeeFunctions,
+} from './methods/delta/getPartnerFee';
+
 export { constructSwapSDK, SwapSDKMethods } from './methods/swap';
 
 export {
@@ -139,6 +181,12 @@ export {
   LimitOrderHandlers,
 } from './methods/limitOrders';
 
+export {
+  constructAllDeltaOrdersHandlers,
+  constructSubmitDeltaOrder,
+  DeltaOrderHandlers,
+} from './methods/delta';
+
 export type {
   TransactionParams,
   BuildOptions,
@@ -198,7 +246,16 @@ export {
   constructApproveTokenForNFTOrder,
   constructGetNFTOrdersContract,
   constructBuildNFTOrderTx,
+  // Delta methods
+  constructBuildDeltaOrder,
+  constructPostDeltaOrder,
+  constructSignDeltaOrder,
+  constructGetDeltaContract,
+  constructGetDeltaPrice,
+  constructGetDeltaOrders,
+  constructApproveTokenForDelta,
   // different helpers
+  constructGetPartnerFee,
   constructEthersContractCaller, // same as constructEthersV5ContractCaller for backwards compatibility
   constructEthersV5ContractCaller,
   constructEthersV6ContractCaller,
@@ -256,11 +313,27 @@ export type {
   BuildNFTOrderInput,
   BuildNFTOrderDataInput,
   NFTOrdersUserParams,
+  //types for Delta methos
+  DeltaPrice,
+  DeltaPriceParams,
+  DeltaAuctionOrder,
+  ParaswapDeltaAuction,
+  BuildDeltaOrderDataParams,
+  BuildDeltaOrderFunctions,
+  SignableDeltaOrderData,
+  PostDeltaOrderFunctions,
+  PostDeltaOrderParams,
+  SignDeltaOrderFunctions,
+  GetDeltaContractFunctions,
+  GetDeltaPriceFunctions,
+  GetDeltaOrdersFunctions,
+  ApproveTokenForDeltaFunctions,
   //common
   ConstructFetchInput,
   ContractCallerFunctions,
   ConstructProviderFetchInput,
   // other types
+  GetPartnerFeeFunctions,
   Token,
   Address,
   AddressOrSymbol,

src/methods/delta/approveForDelta.ts

@@ -0,0 +1,35 @@
+import type { ConstructProviderFetchInput } from '../../types';
+import { ApproveToken, approveTokenMethodFactory } from '../../helpers/approve';
+import { constructGetDeltaContract } from './getDeltaContract';
+
+export type ApproveTokenForDeltaFunctions<T> = {
+  /** @description approving ParaswapDelta as spender for Token */
+  approveTokenForDelta: ApproveToken<T>;
+};
+
+// returns whatever `contractCaller` returns
+// to allow for better versatility
+export const constructApproveTokenForDelta = <T>(
+  options: ConstructProviderFetchInput<T, 'transactCall'>
+): ApproveTokenForDeltaFunctions<T> => {
+  // getAugustusRFQ is cached internally for the same instance of SDK
+  // so should persist across same apiUrl & network
+  const { getDeltaContract } = constructGetDeltaContract(options);
+
+  const getParaswapDelta = async () => {
+    const deltaContract = await getDeltaContract();
+    if (!deltaContract) {
+      throw new Error(`Delta is not available on chain ${options.chainId}`);
+    }
+    return deltaContract;
+  };
+
+  const approveTokenForDelta: ApproveToken<T> = approveTokenMethodFactory<T>(
+    options.contractCaller,
+    getParaswapDelta
+  );
+
+  return {
+    approveTokenForDelta,
+  };
+};