Feat/external orders

src/examples/externalDelta.ts

@@ -0,0 +1,152 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import axios from 'axios';
+import { ethers, Wallet } from 'ethersV5';
+import {
+  constructPartialSDK,
+  constructEthersContractCaller,
+  constructAxiosFetcher,
+  constructAllDeltaOrdersHandlers,
+  SwapSide,
+} from '..';
+import { startStatusCheck } from './helpers/delta';
+
+const fetcher = constructAxiosFetcher(axios);
+
+const provider = ethers.getDefaultProvider(8453); // Base
+const signer = Wallet.createRandom().connect(provider);
+const account = signer.address;
+const contractCaller = constructEthersContractCaller({
+  ethersProviderOrSigner: signer,
+  EthersContract: ethers.Contract,
+});
+
+const deltaSDK = constructPartialSDK(
+  {
+    chainId: 8453, // Base
+    fetcher,
+    contractCaller,
+  },
+  constructAllDeltaOrdersHandlers
+);
+
+// Base tokens
+const USDC = '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913';
+const WETH = '0x4200000000000000000000000000000000000006';
+
+// Aave external handler on Base
+const AAVE_HANDLER = '0xe4c9d68f134b6d2380d124233002535ba786d5a1';
+
+// Aave order types passed as `data` field
+const AaveOrderTypes = {
+  COLLATERAL_SWAP:
+    '0x0000000000000000000000000000000000000000000000000000000000000000',
+  DEBT_SWAP:
+    '0x0000000000000000000000000000000000000000000000000000000000000001',
+  REPAY_WITH_COLLATERAL:
+    '0x0000000000000000000000000000000000000000000000000000000000000002',
+};
+
+// Aave Collateral Swap: swap one collateral asset for another (SELL side)
+async function collateralSwapFlow() {
+  const amount = (10 ** 6).toString(); // 1 USDC in wei
+
+  const deltaPrice = await deltaSDK.getDeltaPrice({
+    srcToken: USDC,
+    destToken: WETH,
+    amount,
+    userAddress: account,
+    srcDecimals: 6,
+    destDecimals: 18,
+    side: SwapSide.SELL,
+  });
+
+  const signableOrderData = await deltaSDK.buildExternalDeltaOrder({
+    deltaPrice,
+    owner: account,
+    handler: AAVE_HANDLER,
+    data: AaveOrderTypes.COLLATERAL_SWAP,
+    srcToken: USDC,
+    destToken: WETH,
+    srcAmount: amount,
+    slippage: 500, // 5% slippage in bps
+  });
+
+  const signature = await deltaSDK.signExternalDeltaOrder(signableOrderData);
+
+  const deltaAuction = await deltaSDK.postExternalDeltaOrder({
+    order: signableOrderData.data,
+    signature,
+  });
+
+  startStatusCheck(() => deltaSDK.getDeltaOrderById(deltaAuction.id));
+}
+
+// Aave Debt Swap: swap one debt for another (BUY side)
+async function debtSwapFlow() {
+  const debtAmount = (10 ** 6).toString(); // amount of debt to swap
+
+  const deltaPrice = await deltaSDK.getDeltaPrice({
+    srcToken: USDC,
+    destToken: WETH,
+    amount: debtAmount,
+    userAddress: account,
+    srcDecimals: 6,
+    destDecimals: 18,
+    side: SwapSide.BUY,
+  });
+
+  const signableOrderData = await deltaSDK.buildExternalDeltaOrder({
+    deltaPrice,
+    owner: account,
+    handler: AAVE_HANDLER,
+    data: AaveOrderTypes.DEBT_SWAP,
+    srcToken: USDC,
+    destToken: WETH,
+    destAmount: debtAmount,
+    slippage: 500, // 5% slippage in bps
+  });
+
+  const signature = await deltaSDK.signExternalDeltaOrder(signableOrderData);
+
+  const deltaAuction = await deltaSDK.postExternalDeltaOrder({
+    order: signableOrderData.data,
+    signature,
+  });
+
+  startStatusCheck(() => deltaSDK.getDeltaOrderById(deltaAuction.id));
+}
+
+// Aave Repay with Collateral: use collateral to repay debt (BUY side)
+async function repayWithCollateralFlow() {
+  const collateralAmount = (10 ** 6).toString();
+
+  const deltaPrice = await deltaSDK.getDeltaPrice({
+    srcToken: USDC,
+    destToken: WETH,
+    amount: collateralAmount,
+    userAddress: account,
+    srcDecimals: 6,
+    destDecimals: 18,
+    side: SwapSide.BUY,
+  });
+
+  const signableOrderData = await deltaSDK.buildExternalDeltaOrder({
+    deltaPrice,
+    owner: account,
+    handler: AAVE_HANDLER,
+    data: AaveOrderTypes.REPAY_WITH_COLLATERAL,
+    srcToken: USDC,
+    destToken: WETH,
+    destAmount: collateralAmount,
+    slippage: 500, // 5% slippage in bps
+  });
+
+  const signature = await deltaSDK.signExternalDeltaOrder(signableOrderData);
+
+  const deltaAuction = await deltaSDK.postExternalDeltaOrder({
+    order: signableOrderData.data,
+    signature,
+  });
+
+  startStatusCheck(() => deltaSDK.getDeltaOrderById(deltaAuction.id));
+}

src/index.ts

@@ -144,6 +144,7 @@ import type {
   BridgeMetadata,
   BridgeStatus,
   Bridge,
+  ExternalDeltaOrder,
 } from './methods/delta/helpers/types';
 import {
   BuildDeltaOrderDataParams,
@@ -203,6 +204,26 @@ import {
   IsTokenSupportedInDeltaFunctions,
 } from './methods/delta/isTokenSupportedInDelta';
 
+import {
+  constructBuildExternalDeltaOrder,
+  BuildExternalDeltaOrderFunctions,
+  BuildExternalDeltaOrderParams,
+} from './methods/delta/buildExternalDeltaOrder';
+import type { SignableExternalOrderData } from './methods/delta/helpers/buildExternalOrderData';
+import {
+  constructSignExternalDeltaOrder,
+  SignExternalDeltaOrderFunctions,
+} from './methods/delta/signExternalDeltaOrder';
+import {
+  constructPostExternalDeltaOrder,
+  PostExternalDeltaOrderFunctions,
+  PostExternalDeltaOrderParams,
+} from './methods/delta/postExternalDeltaOrder';
+import {
+  constructPreSignExternalDeltaOrder,
+  PreSignExternalDeltaOrderFunctions,
+} from './methods/delta/preSignExternalDeltaOrder';
+
 import {
   constructGetQuote,
   GetQuoteFunctions,
@@ -235,8 +256,10 @@ export {
 export {
   constructAllDeltaOrdersHandlers,
   constructSubmitDeltaOrder,
+  constructSubmitExternalDeltaOrder,
   DeltaOrderHandlers,
   SubmitDeltaOrderParams,
+  SubmitExternalDeltaOrderParams,
 } from './methods/delta';
 
 export type {
@@ -309,6 +332,11 @@ export {
   constructCancelDeltaOrder,
   constructDeltaTokenModule,
   constructApproveTokenForDelta,
+  // External Delta methods
+  constructBuildExternalDeltaOrder,
+  constructSignExternalDeltaOrder,
+  constructPostExternalDeltaOrder,
+  constructPreSignExternalDeltaOrder,
   // Quote methods
   constructGetQuote,
   // different helpers
@@ -407,6 +435,15 @@ export type {
   CancelAndWithdrawDeltaOrderParams,
   DepositNativeAndPreSignParams,
   DepositNativeAndPreSignDeltaOrderParams,
+  // External Delta types
+  ExternalDeltaOrder,
+  SignableExternalOrderData,
+  BuildExternalDeltaOrderParams,
+  BuildExternalDeltaOrderFunctions,
+  SignExternalDeltaOrderFunctions,
+  PostExternalDeltaOrderFunctions,
+  PostExternalDeltaOrderParams,
+  PreSignExternalDeltaOrderFunctions,
   // types for Quote methods
   GetQuoteFunctions,
   QuoteParams,

src/methods/delta/buildDeltaOrder.ts

@@ -1,8 +1,4 @@
-import type {
-  ConstructFetchInput,
-  EnumerateLiteral,
-  RequestParameters,
-} from '../../types';
+import type { ConstructFetchInput, RequestParameters } from '../../types';
 import { constructGetDeltaContract } from './getDeltaContract';
 import type { BridgePrice } from './getDeltaPrice';
 import { constructGetPartnerFee } from './getPartnerFee';
@@ -11,13 +7,14 @@ import {
   type BuildDeltaOrderDataInput,
   type SignableDeltaOrderData,
 } from './helpers/buildDeltaOrderData';
+import type { SwapSideUnion, AmountsWithSlippage } from './helpers/types';
 import { SwapSideToOrderKind } from './helpers/types';
+import { applySlippage } from './helpers/misc';
 import { SwapSide } from '../../constants';
 import type { MarkOptional } from 'ts-essentials';
 import { ZERO_ADDRESS } from '../common/orders/buildOrderData';
 export type { SignableDeltaOrderData } from './helpers/buildDeltaOrderData';
-
-export type SwapSideUnion = EnumerateLiteral<typeof SwapSide>;
+export type { SwapSideUnion } from './helpers/types';
 
 type BuildDeltaOrderDataParamsBase = {
   /** @description The address of the order owner */
@@ -68,39 +65,8 @@ type BuildDeltaOrderDataParamsBase = {
   metadata?: string;
 };
 
-/** @description SELL with slippage: srcAmount provided, destAmount auto-computed from deltaPrice.destAmount */
-type DeltaAmountsSellSlippage = {
-  /** @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 */
-type DeltaAmountsBuySlippage = {
-  /** @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) */
-type DeltaAmountsExplicit = {
-  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 BuildDeltaOrderDataParams = BuildDeltaOrderDataParamsBase &
-  (DeltaAmountsSellSlippage | DeltaAmountsBuySlippage | DeltaAmountsExplicit);
+  AmountsWithSlippage;
 
 type BuildDeltaOrder = (
   buildOrderParams: BuildDeltaOrderDataParams,
@@ -240,17 +206,3 @@ export const constructBuildDeltaOrder = (
     buildDeltaOrder,
   };
 };
-
-function applySlippage(
-  amount: string,
-  slippageBps: number,
-  increase: boolean
-): string {
-  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);
-}