@velora-dex/sdk 8.0.0

package/src/methods/common/orders/encoding.ts

@@ -0,0 +1,216 @@
+import { splitSignature } from './signature';
+
+type EncodeEIP_2612PermitFunctionInput = {
+  permitSignature: string;
+  owner: string;
+  spender: string;
+  value: string | bigint;
+  deadline: string | number | bigint;
+};
+
+// encoding params for Token.permit() Permit1 function
+export function encodeEIP_2612PermitFunctionInput({
+  owner,
+  spender,
+  value,
+  deadline,
+  permitSignature,
+}: EncodeEIP_2612PermitFunctionInput): string {
+  const { v, r, s } = splitSignature(permitSignature);
+
+  const encodedOwner = encodeAddress(owner);
+  const encodedSpender = encodeAddress(spender);
+  const encodedValue = encodeUint256(value);
+  const encodedDeadline = encodeUint256(deadline.toString());
+  const encodedV = encodeUint8(v);
+  const encodedR = encodeBytes32(r);
+  const encodedS = encodeBytes32(s);
+
+  // Concatenate all encoded values, stripping the "0x" prefix from each (except the first one)
+  return (
+    '0x' +
+    [
+      encodedOwner,
+      encodedSpender,
+      encodedValue,
+      encodedDeadline,
+      encodedV,
+      encodedR,
+      encodedS,
+    ]
+      .map((val) => val.slice(2)) // Remove "0x" prefix from each encoded value
+      .join('') // Concatenate the values
+  );
+}
+
+type EncodeDAIlikePermitFunctionInput = {
+  permitSignature: string;
+  holder: string;
+  spender: string;
+  nonce: number | bigint | string;
+  expiry: number | bigint | string;
+};
+
+// encoding params for DAIlike.permit() function
+export function encodeDAIlikePermitFunctionInput({
+  permitSignature,
+  holder,
+  spender,
+  nonce,
+  expiry,
+}: EncodeDAIlikePermitFunctionInput): string {
+  const { v, r, s } = splitSignature(permitSignature);
+
+  const encodedHolder = encodeAddress(holder);
+  const encodedSpender = encodeAddress(spender);
+  const encodedNonce = encodeUint256(nonce.toString());
+  const encodedExpiry = encodeUint256(expiry.toString());
+  const encodedV = encodeUint8(v);
+  const encodedR = encodeBytes32(r);
+  const encodedS = encodeBytes32(s);
+
+  // Concatenate all encoded values, stripping the "0x" prefix from each (except the first one)
+  return (
+    '0x' +
+    [
+      encodedHolder,
+      encodedSpender,
+      encodedNonce,
+      encodedExpiry,
+      encodeBool(true), //allowed=true
+      encodedV,
+      encodedR,
+      encodedS,
+    ]
+      .map((val) => val.slice(2)) // Remove "0x" prefix from each encoded value
+      .join('') // Concatenate the values
+  );
+}
+
+// encode an address (20 bytes) into 32 bytes
+export function encodeAddress(address: string): string {
+  const strippedAddress = address.replace(/^0x/, ''); // Remove "0x" prefix
+  return '0x' + strippedAddress.toLowerCase().padStart(64, '0');
+}
+
+// encode a uint256 value
+export function encodeUint256(value: string | bigint): string {
+  const bn = BigInt(value);
+  return '0x' + bn.toString(16).padStart(64, '0');
+}
+
+// encode a uint8 value
+export function encodeUint8(value: number | bigint): string {
+  return '0x' + value.toString(16).padStart(64, '0');
+}
+
+// encode a bytes32 value
+export function encodeBytes32(value: string): string {
+  const strippedValue = value.replace(/^0x/, ''); // Remove "0x" prefix
+  return '0x' + strippedValue.padStart(64, '0').toLowerCase();
+}
+
+//encode a boolean
+export function encodeBool(value: boolean): string {
+  const encodedValue = value ? '1' : '0';
+  // padded to 32 bytes
+  return '0x' + encodedValue.padStart(64, '0');
+}
+
+/* 
+const EIP_2612_PERMIT_ABI = [
+  {
+    constant: false,
+    inputs: [
+      {
+        name: 'owner',
+        type: 'address',
+      },
+      {
+        name: 'spender',
+        type: 'address',
+      },
+      {
+        name: 'value',
+        type: 'uint256',
+      },
+      {
+        name: 'deadline',
+        type: 'uint256',
+      },
+      {
+        name: 'v',
+        type: 'uint8',
+      },
+      {
+        name: 'r',
+        type: 'bytes32',
+      },
+      {
+        name: 's',
+        type: 'bytes32',
+      },
+    ],
+    name: 'permit',
+    outputs: [],
+    payable: false,
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+]; 
+*/
+
+/* 
+const DAI_EIP_2612_PERMIT_ABI = [
+  {
+    constant: false,
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'holder',
+        type: 'address',
+      },
+      {
+        internalType: 'address',
+        name: 'spender',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: 'nonce',
+        type: 'uint256',
+      },
+      {
+        internalType: 'uint256',
+        name: 'expiry',
+        type: 'uint256',
+      },
+      {
+        internalType: 'bool',
+        name: 'allowed',
+        type: 'bool',
+      },
+      {
+        internalType: 'uint8',
+        name: 'v',
+        type: 'uint8',
+      },
+      {
+        internalType: 'bytes32',
+        name: 'r',
+        type: 'bytes32',
+      },
+      {
+        internalType: 'bytes32',
+        name: 's',
+        type: 'bytes32',
+      },
+    ],
+    name: 'permit',
+    outputs: [],
+    payable: false,
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+];
+ */

package/src/methods/common/orders/misc.ts

@@ -0,0 +1,86 @@
+import type { LimitOrderFromApi } from '../../limitOrders/helpers/types';
+import { ZERO_ADDRESS } from './buildOrderData';
+import type { OrderType } from './types';
+
+type GetBaseFetchUrlInput = {
+  apiURL: string;
+  chainId: number;
+};
+
+export type BaseFetchUrlInputConstructor<Kind extends OrderKind> = (
+  params: GetBaseFetchUrlInput
+) => UrlByTypeFunction<Kind>;
+
+type OrderType2URLPart = {
+  LIMIT: 'orders';
+  P2P: 'p2p';
+};
+
+type OrderKind = 'nft' | 'ft';
+
+export type BaseFetchUrl<
+  Kind extends OrderKind,
+  Type extends OrderType = OrderType
+> = `${string}/${Kind}/${OrderType2URLPart[Type]}/${number}`;
+
+export type MinFetchUrl<Kind extends OrderKind> = `${string}/${Kind}/order`;
+export type OrderFillableBalanceFetchUrl<Kind extends OrderKind> =
+  `${string}/${Kind}/fillablebalance/${number}`;
+
+interface UrlByTypeFunction<Kind extends OrderKind> {
+  (): MinFetchUrl<Kind>;
+  (type: 'LIMIT'): BaseFetchUrl<Kind, 'LIMIT'>;
+  (type: 'P2P'): BaseFetchUrl<Kind, 'P2P'>;
+  (type: OrderType): BaseFetchUrl<Kind>;
+  (type: 'fillablebalance'): OrderFillableBalanceFetchUrl<Kind>;
+  (type?: OrderType | 'fillablebalance'):
+    | BaseFetchUrl<Kind>
+    | MinFetchUrl<Kind>
+    | OrderFillableBalanceFetchUrl<Kind>;
+}
+
+export function baseFetchUrlGetterFactory<Kind extends OrderKind>(
+  orderKind: Kind
+): BaseFetchUrlInputConstructor<Kind> {
+  return function constructBaseFetchUrlGetter({
+    chainId,
+    apiURL,
+  }: GetBaseFetchUrlInput): UrlByTypeFunction<Kind> {
+    function urlGetter(type: 'LIMIT'): BaseFetchUrl<Kind, 'LIMIT'>;
+    function urlGetter(type: 'P2P'): BaseFetchUrl<Kind, 'P2P'>;
+    function urlGetter(type: OrderType): BaseFetchUrl<Kind>;
+    function urlGetter(
+      type: 'fillablebalance'
+    ): OrderFillableBalanceFetchUrl<Kind>;
+    function urlGetter(): MinFetchUrl<Kind>;
+    function urlGetter(
+      type?: OrderType | 'fillablebalance'
+    ):
+      | BaseFetchUrl<Kind>
+      | MinFetchUrl<Kind>
+      | OrderFillableBalanceFetchUrl<Kind> {
+      if (!type) return `${apiURL}/${orderKind}/order` as const;
+
+      if (type === 'fillablebalance')
+        return `${apiURL}/${orderKind}/fillablebalance/${chainId}` as const;
+
+      const orderURLpart = type === 'LIMIT' ? 'orders' : 'p2p';
+      return `${apiURL}/${orderKind}/${orderURLpart}/${chainId}` as const;
+    }
+
+    return urlGetter;
+  };
+}
+
+// orders with taker = EOA address
+// that can't be filled through AugustusSwapper,
+// only through AugustusRFQ
+export function isOrderFillableDirectlyOnRFQOnly(
+  order: Pick<LimitOrderFromApi, 'taker' | 'takerFromMeta'>
+): boolean {
+  // with 0x taker fillable by anyone
+  if (order.taker === ZERO_ADDRESS) return false;
+
+  // same intended EOA taker and msg.sender taker
+  return order.taker.toLowerCase() === order.takerFromMeta.toLowerCase();
+}

package/src/methods/common/orders/signature.ts

@@ -0,0 +1,68 @@
+type SplitSignatureResult = {
+  v: number;
+  r: string;
+  s: string;
+  compact: string;
+};
+
+export function splitSignature(signature: string): SplitSignatureResult {
+  // 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.slice(i, 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 s: string;
+  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
+    v = 27 + (bytes[32]! >> 7);
+    bytes[32]! &= 0x7f; // Clear the highest bit
+    s = `0x${Array.from(bytes.slice(32, 64))
+      .map((b) => b.toString(16).padStart(2, '0'))
+      .join('')}`;
+  } else {
+    s = `0x${Array.from(bytes.slice(32, 64))
+      .map((b) => b.toString(16).padStart(2, '0'))
+      .join('')}`;
+
+    // Extract v directly for 65-byte signature
+    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 { v, r, s, compact: compactSignature };
+}

package/src/methods/common/orders/types.ts

@@ -0,0 +1,13 @@
+export type OrderTransaction = {
+  hash: string;
+  event_type: 'OrderFilled' | 'OrderCancelled';
+};
+
+export type OrderType = 'LIMIT' | 'P2P';
+
+// 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'
+export type OrderState = 'PENDING' | 'FULFILLED' | 'CANCELLED' | 'EXPIRED';
+
+export type BeneficiaryType = 'EOA' | 'SmartContract';

package/src/methods/delta/approveForDelta.ts

@@ -0,0 +1,38 @@
+import type {
+  ConstructProviderFetchInput,
+  RequestParameters,
+} from '../../types';
+import { ApproveToken, approveTokenMethodFactory } from '../../helpers/approve';
+import { constructGetDeltaContract } from './getDeltaContract';
+
+export type ApproveTokenForDeltaFunctions<T> = {
+  /** @description approving ParaswapDelta contract 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> => {
+  // getDeltaContract is cached internally for the same instance of SDK
+  // so should persist across same apiUrl & network
+  const { getDeltaContract } = constructGetDeltaContract(options);
+
+  const getParaswapDeltaAddress = async (requestParams?: RequestParameters) => {
+    const deltaContract = await getDeltaContract(requestParams);
+    if (!deltaContract) {
+      throw new Error(`Delta is not available on chain ${options.chainId}`);
+    }
+    return deltaContract;
+  };
+
+  const approveTokenForDelta: ApproveToken<T> = approveTokenMethodFactory<T>(
+    options.contractCaller,
+    getParaswapDeltaAddress
+  );
+
+  return {
+    approveTokenForDelta,
+  };
+};

package/src/methods/delta/buildCrosschainOrderBridge.ts

@@ -0,0 +1,84 @@
+import { assert } from 'ts-essentials';
+import type { ConstructFetchInput, RequestParameters } from '../../types';
+import { BridgePrice } from './getDeltaPrice';
+import { constructGetMulticallHandlers } from './getMulticallHandlers';
+import {
+  getDeltaBridgeAndDestToken,
+  GetDeltaBridgeAndDestTokenOutput,
+} from './helpers/across';
+import { BeneficiaryType } from '../common/orders/types';
+export type { SignableDeltaOrderData } from './helpers/buildDeltaOrderData';
+
+export type BuildCrosschainOrderBridgeParams = {
+  /** @description The address of the destination token on the destination chain */
+  destToken: string; // lowercase
+  /** @description Destination Chain ID for Crosschain Orders */
+  destChainId: number;
+  /** @description Whether the beneficiary is a contract. Needed to automatically fill in crosschain Bridge */
+  beneficiaryType: BeneficiaryType;
+
+  /** @description price response received from /delta/prices (getDeltaPrice method) */
+  deltaPrice: Pick<BridgePrice, 'bridgeFee' | 'destToken'>;
+};
+
+type BuildCrosschainOrderBridge = (
+  buildOrderParams: BuildCrosschainOrderBridgeParams,
+  requestParams?: RequestParameters
+) => Promise<GetDeltaBridgeAndDestTokenOutput>;
+
+export { GetDeltaBridgeAndDestTokenOutput as CrosschainOrderBridgeAndChanges };
+
+export type BuildCrosschainOrderBridgeFunctions = {
+  /** @description Build Orders to be posted to Delta API for execution */
+  buildCrosschainOrderBridge: BuildCrosschainOrderBridge;
+};
+
+export const constructBuildCrosschainOrderBridge = (
+  options: ConstructFetchInput
+): BuildCrosschainOrderBridgeFunctions => {
+  const { chainId } = options;
+
+  // cached internally for `multicall` contracts
+  const { getMulticallHandlers } = constructGetMulticallHandlers(options);
+
+  const buildCrosschainOrderBridge: BuildCrosschainOrderBridge = async (
+    { destToken, destChainId, beneficiaryType, deltaPrice },
+    requestParams
+  ) => {
+    assert(
+      chainId !== destChainId,
+      '`destChainId` must be different from `chainId` for crosschain Order.bridge'
+    );
+
+    const getMulticallHandler = async (chainId: number) => {
+      const multicallHandlersMap = await getMulticallHandlers(requestParams);
+      const multicallHandler = multicallHandlersMap[chainId];
+
+      assert(
+        multicallHandler,
+        `Multicall handler not found for chain ${chainId}`
+      );
+
+      return multicallHandler;
+    };
+
+    const { bridge, orderChanges } = await getDeltaBridgeAndDestToken({
+      destTokenDestChain: destToken,
+      destChainId: destChainId,
+      destTokenSrcChain: deltaPrice.destToken,
+      srcChainId: chainId,
+      bridgeFee: deltaPrice.bridgeFee,
+      beneficiaryType,
+      getMulticallHandler,
+    });
+
+    return {
+      bridge,
+      orderChanges,
+    };
+  };
+
+  return {
+    buildCrosschainOrderBridge,
+  };
+};

package/src/methods/delta/buildDeltaOrder.ts

@@ -0,0 +1,192 @@
+import { assert } from 'ts-essentials';
+import type { ConstructFetchInput, RequestParameters } from '../../types';
+import { ZERO_ADDRESS } from '../common/orders/buildOrderData';
+import { constructGetDeltaContract } from './getDeltaContract';
+import { BridgePrice, DeltaPrice } from './getDeltaPrice';
+import { constructGetPartnerFee } from './getPartnerFee';
+import {
+  buildDeltaSignableOrderData,
+  type BuildDeltaOrderDataInput,
+  type SignableDeltaOrderData,
+} from './helpers/buildDeltaOrderData';
+import { Bridge, DeltaAuctionOrder } from './helpers/types';
+import { constructBuildCrosschainOrderBridge } from './buildCrosschainOrderBridge';
+import { BeneficiaryType } from '../common/orders/types';
+export type { SignableDeltaOrderData } from './helpers/buildDeltaOrderData';
+
+export type BuildDeltaOrderDataParams = {
+  /** @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. For Crosschain Order - destination token on the destination chain */
+  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, deltaPrice.destAmount - slippage
+  /** @description The deadline for the order */
+  deadline?: number; // seconds
+  /** @description The nonce of the order */
+  nonce?: number | string; // can be random, can even be Date.now()
+  /** @description Optional permit signature for the src token https://developers.velora.xyz/api/velora-api/velora-delta-api/build-a-delta-order-to-sign#supported-permits-order#supported-permits */
+  permit?: string; //can be "0x"
+  /** @description Partner string. */
+  partner?: string;
+
+  /** @description The bridge input */
+  bridge?: Bridge;
+  /** @description Destination Chain ID for Crosschain Orders */
+  destChainId?: number;
+  /** @description Whether the beneficiary is a contract. Needed to automatically fill in crosschain Bridge */
+  beneficiaryType?: BeneficiaryType;
+
+  /** @description price response received from /delta/prices (getDeltaPrice method) */
+  deltaPrice: Pick<
+    DeltaPrice,
+    'destAmount' | 'partner' | 'partnerFee' | 'destToken'
+  > &
+    Partial<Pick<BridgePrice, 'bridgeFee'>>;
+
+  /** @description partner fee in basis points (bps), 50bps=0.5% */
+  partnerFeeBps?: number;
+  /** @description partner address */
+  partnerAddress?: string;
+  /** @description take surplus */
+  partnerTakesSurplus?: boolean;
+};
+
+type BuildDeltaOrder = (
+  buildOrderParams: BuildDeltaOrderDataParams,
+  requestParams?: RequestParameters
+) => Promise<SignableDeltaOrderData>;
+
+export type BuildDeltaOrderFunctions = {
+  /** @description Build Orders to be posted to Delta API for execution */
+  buildDeltaOrder: BuildDeltaOrder;
+};
+
+// for same-chain Orders, all 0 params
+const DEFAULT_BRIDGE: Bridge = {
+  maxRelayerFee: '0',
+  destinationChainId: 0,
+  outputToken: ZERO_ADDRESS,
+  multiCallHandler: ZERO_ADDRESS,
+};
+
+export const constructBuildDeltaOrder = (
+  options: ConstructFetchInput
+): BuildDeltaOrderFunctions => {
+  const { chainId } = options;
+
+  // cached internally
+  const { getDeltaContract } = constructGetDeltaContract(options);
+  // cached internally for `partner`
+  const { getPartnerFee } = constructGetPartnerFee(options);
+
+  const { buildCrosschainOrderBridge } =
+    constructBuildCrosschainOrderBridge(options);
+
+  const buildDeltaOrder: BuildDeltaOrder = async (options, requestParams) => {
+    const ParaswapDelta = await getDeltaContract(requestParams);
+    if (!ParaswapDelta) {
+      throw new Error(`Delta is not available on chain ${chainId}`);
+    }
+
+    ////// Partner logic //////
+
+    // externally supplied partner fee data takes precedence
+    let partnerAddress = options.partnerAddress;
+    let partnerFeeBps =
+      options.partnerFeeBps ?? options.deltaPrice.partnerFee * 100;
+    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;
+      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;
+      partnerTakesSurplus =
+        partnerTakesSurplus ?? partnerFeeResponse.takeSurplus;
+    }
+
+    ////// Bridge logic //////
+
+    // Bridge is necessary for Crosschain Delta Orders
+    let bridge = options.bridge;
+    let partialChangedOrder: Pick<DeltaAuctionOrder, 'destToken'> | null = null;
+
+    // give preference to user-provided bridge
+    if (!bridge) {
+      // no bridge passed in input
+
+      if (options.destChainId && chainId !== options.destChainId) {
+        // crosschain Delta Order
+        const deltaPrice = options.deltaPrice;
+        assert(
+          deltaPrice.bridgeFee,
+          '`bridgeFee` is required in `deltaPrice` for crosschain Delta Orders'
+        );
+
+        const { bridge: constructedBridge, orderChanges } =
+          await buildCrosschainOrderBridge(
+            {
+              destToken: options.destToken,
+              destChainId: options.destChainId,
+              beneficiaryType: options.beneficiaryType ?? 'EOA',
+              deltaPrice: {
+                bridgeFee: deltaPrice.bridgeFee,
+                destToken: deltaPrice.destToken,
+              },
+            },
+            requestParams
+          );
+
+        bridge = constructedBridge;
+        partialChangedOrder = orderChanges;
+      } else {
+        // 0-values bridge for same-chain Orders
+        bridge = DEFAULT_BRIDGE;
+      }
+    }
+
+    const input: BuildDeltaOrderDataInput = {
+      owner: options.owner,
+      beneficiary: options.beneficiary,
+      srcToken: options.srcToken,
+      // for some cases of WETH<->ETH crosschain swaps, the destToken is to WETH or ETH
+      destToken: partialChangedOrder?.destToken ?? options.destToken,
+      srcAmount: options.srcAmount,
+      destAmount: options.destAmount,
+      expectedDestAmount: options.deltaPrice.destAmount,
+      deadline: options.deadline,
+      nonce: options.nonce?.toString(10),
+      permit: options.permit,
+
+      chainId,
+      paraswapDeltaAddress: ParaswapDelta,
+      partnerAddress,
+      partnerTakesSurplus,
+      partnerFeeBps,
+
+      bridge,
+    };
+
+    return buildDeltaSignableOrderData(input);
+  };
+
+  return {
+    buildDeltaOrder,
+  };
+};