mirror of
https://github.com/orionprotocol/sdk.git
synced 2026-03-13 21:52:36 +03:00
413 lines
13 KiB
TypeScript
413 lines
13 KiB
TypeScript
import type { LibValidator } from "@orionprotocol/contracts/lib/ethers-v6/Exchange.js";
|
|
import { ethers, ZeroAddress } from "ethers";
|
|
import type { AddressLike, JsonRpcProvider, BigNumberish, BytesLike } from "ethers";
|
|
import cloneDeep from "lodash.clonedeep";
|
|
import { safeGet, SafeArray } from "../../utils/safeGetters.js";
|
|
import { simpleFetch } from "simple-typed-fetch";
|
|
import type Unit from "../index.js";
|
|
import { generateUni2Calls, generateUni2Call } from "./callGenerators/uniswapV2.js";
|
|
import {
|
|
generateUni3Calls,
|
|
generateOrion3Calls,
|
|
generateUni3Call,
|
|
generateOrion3Call,
|
|
} from "./callGenerators/uniswapV3.js";
|
|
import { exchangeToNativeDecimals, generateCalls, pathCallWithBalance } from "./callGenerators/utils.js";
|
|
import { generateTransferCall } from "./callGenerators/erc20.js";
|
|
import { generateCurveStableSwapCall } from "./callGenerators/curve.js";
|
|
import type { SingleSwap } from "../../types.js";
|
|
import { addressLikeToString } from "../../utils/addressLikeToString.js";
|
|
import { generateUnwrapAndTransferCall, generateWrapAndTransferCall } from "./callGenerators/weth.js";
|
|
import { getExchangeAllowance, getTotalBalance } from "../../utils/getBalance.js";
|
|
import { generateFeePaymentCall } from "./callGenerators/feePayment.js";
|
|
|
|
export type Factory = "UniswapV2" | "UniswapV3" | "Curve" | "OrionV2" | "OrionV3";
|
|
|
|
type BaseGenerateSwapCalldataParams = {
|
|
amount: BigNumberish;
|
|
minReturnAmount: BigNumberish;
|
|
initiatorAddress: string;
|
|
receiverAddress: string;
|
|
path: ArrayLike<SingleSwap>;
|
|
matcher?: AddressLike,
|
|
feeToken?: AddressLike,
|
|
fee?: BigNumberish;
|
|
}
|
|
|
|
export type GenerateSwapCalldataWithUnitParams = BaseGenerateSwapCalldataParams & {
|
|
unit: Unit;
|
|
};
|
|
|
|
export type GenerateSwapCalldataParams = BaseGenerateSwapCalldataParams & {
|
|
exchangeContractAddress: AddressLike;
|
|
wethAddress: AddressLike;
|
|
curveRegistryAddress: AddressLike;
|
|
swapExecutorContractAddress: AddressLike;
|
|
provider: JsonRpcProvider;
|
|
};
|
|
|
|
export async function generateSwapCalldataWithUnit({
|
|
amount,
|
|
minReturnAmount,
|
|
initiatorAddress,
|
|
receiverAddress,
|
|
path: arrayLikePath,
|
|
matcher = ZeroAddress,
|
|
feeToken = ZeroAddress,
|
|
fee = 0,
|
|
unit,
|
|
}: GenerateSwapCalldataWithUnitParams): Promise<{
|
|
calldata: string;
|
|
swapDescription: LibValidator.SwapDescriptionStruct;
|
|
value: bigint;
|
|
}> {
|
|
if (arrayLikePath == undefined || arrayLikePath.length == 0) {
|
|
throw new Error("Empty path");
|
|
}
|
|
const wethAddress = safeGet(unit.contracts, "WETH");
|
|
const curveRegistryAddress = safeGet(unit.contracts, "curveRegistry");
|
|
const { assetToAddress, swapExecutorContractAddress, exchangeContractAddress } = await simpleFetch(
|
|
unit.blockchainService.getInfo
|
|
)();
|
|
|
|
const arrayLikePathCopy = cloneDeep(arrayLikePath);
|
|
let path = SafeArray.from(arrayLikePathCopy);
|
|
|
|
path = SafeArray.from(arrayLikePathCopy).map((swapInfo) => {
|
|
swapInfo.assetIn = assetToAddress[swapInfo.assetIn] ?? swapInfo.assetIn
|
|
swapInfo.assetOut = assetToAddress[swapInfo.assetOut] ?? swapInfo.assetOut
|
|
swapInfo.assetIn = swapInfo.assetIn.toLowerCase()
|
|
swapInfo.assetOut = swapInfo.assetOut.toLowerCase()
|
|
return swapInfo;
|
|
});
|
|
|
|
return await generateSwapCalldata({
|
|
amount,
|
|
minReturnAmount,
|
|
receiverAddress,
|
|
initiatorAddress,
|
|
path,
|
|
matcher,
|
|
feeToken,
|
|
fee,
|
|
exchangeContractAddress,
|
|
wethAddress,
|
|
curveRegistryAddress,
|
|
swapExecutorContractAddress,
|
|
provider: unit.provider,
|
|
});
|
|
}
|
|
|
|
export async function generateSwapCalldata({
|
|
amount,
|
|
minReturnAmount,
|
|
initiatorAddress,
|
|
receiverAddress,
|
|
path: arrayLikePath,
|
|
matcher: matcherAddressLike = ZeroAddress,
|
|
feeToken: feeTokenAddressLike = ZeroAddress,
|
|
fee = 0,
|
|
exchangeContractAddress,
|
|
wethAddress: wethAddressLike,
|
|
curveRegistryAddress: curveRegistryAddressLike,
|
|
swapExecutorContractAddress: swapExecutorContractAddressLike,
|
|
provider,
|
|
}: GenerateSwapCalldataParams): Promise<{
|
|
calldata: string;
|
|
swapDescription: LibValidator.SwapDescriptionStruct;
|
|
value: bigint;
|
|
}> {
|
|
const wethAddress = await addressLikeToString(wethAddressLike);
|
|
const curveRegistryAddress = await addressLikeToString(curveRegistryAddressLike);
|
|
const swapExecutorContractAddress = await addressLikeToString(swapExecutorContractAddressLike);
|
|
const feeToken = await addressLikeToString(feeTokenAddressLike);
|
|
const matcher = await addressLikeToString(matcherAddressLike);
|
|
let path = SafeArray.from(arrayLikePath).map((swapInfo) => {
|
|
swapInfo.assetIn = swapInfo.assetIn.toLowerCase()
|
|
swapInfo.assetOut = swapInfo.assetOut.toLowerCase()
|
|
return swapInfo;
|
|
});
|
|
|
|
const { assetIn: srcToken } = path.first();
|
|
const { assetOut: dstToken } = path.last();
|
|
|
|
let swapDescription: LibValidator.SwapDescriptionStruct = {
|
|
srcToken,
|
|
dstToken,
|
|
srcReceiver: swapExecutorContractAddress,
|
|
dstReceiver: receiverAddress,
|
|
amount,
|
|
minReturnAmount,
|
|
flags: 0,
|
|
};
|
|
const amountNativeDecimals = await exchangeToNativeDecimals(srcToken, amount, provider);
|
|
const feeNativeDecimals = await exchangeToNativeDecimals(feeToken, fee, provider)
|
|
|
|
path = SafeArray.from(arrayLikePath).map((singleSwap) => {
|
|
if (singleSwap.assetIn == ethers.ZeroAddress) singleSwap.assetIn = wethAddress;
|
|
if (singleSwap.assetOut == ethers.ZeroAddress) singleSwap.assetOut = wethAddress;
|
|
return singleSwap;
|
|
});
|
|
|
|
let calls: BytesLike[];
|
|
({ swapDescription, calls } = await processSwaps(
|
|
swapDescription,
|
|
path,
|
|
amountNativeDecimals,
|
|
matcher,
|
|
feeToken,
|
|
feeNativeDecimals,
|
|
wethAddress,
|
|
swapExecutorContractAddress,
|
|
curveRegistryAddress,
|
|
provider
|
|
));
|
|
const calldata = generateCalls(calls);
|
|
|
|
const { useExchangeBalance, additionalTransferAmount } = await shouldUseExchangeBalance(
|
|
srcToken,
|
|
initiatorAddress,
|
|
exchangeContractAddress,
|
|
amountNativeDecimals,
|
|
provider
|
|
);
|
|
if (useExchangeBalance) {
|
|
swapDescription.flags = 1n << 255n;
|
|
}
|
|
const value = srcToken == ZeroAddress ? additionalTransferAmount : 0n;
|
|
return { swapDescription, calldata, value };
|
|
}
|
|
|
|
async function processSwaps(
|
|
swapDescription: LibValidator.SwapDescriptionStruct,
|
|
path: SafeArray<SingleSwap>,
|
|
amount: BigNumberish,
|
|
matcher: string,
|
|
feeToken: string,
|
|
fee: BigNumberish,
|
|
wethAddress: string,
|
|
swapExecutorContractAddress: string,
|
|
curveRegistryAddress: string,
|
|
provider: JsonRpcProvider
|
|
) {
|
|
const { factory: firstSwapFactory } = path.first();
|
|
const isSingleFactorySwap = path.every((singleSwap) => singleSwap.factory === firstSwapFactory);
|
|
let calls: BytesLike[];
|
|
if (isSingleFactorySwap) {
|
|
({ swapDescription, calls } = await processSingleFactorySwaps(
|
|
firstSwapFactory,
|
|
swapDescription,
|
|
path,
|
|
amount,
|
|
swapExecutorContractAddress,
|
|
curveRegistryAddress,
|
|
provider
|
|
));
|
|
} else {
|
|
({ swapDescription, calls } = await processMultiFactorySwaps(
|
|
swapDescription,
|
|
path,
|
|
amount,
|
|
swapExecutorContractAddress,
|
|
curveRegistryAddress,
|
|
provider
|
|
));
|
|
}
|
|
|
|
({swapDescription, calls} = await payFeeToMatcher(matcher, feeToken, fee, calls, swapDescription));
|
|
|
|
({ swapDescription, calls } = wrapOrUnwrapIfNeeded(
|
|
amount,
|
|
swapDescription,
|
|
calls,
|
|
swapExecutorContractAddress,
|
|
wethAddress
|
|
));
|
|
|
|
return { swapDescription, calls };
|
|
}
|
|
|
|
async function processSingleFactorySwaps(
|
|
factory: Factory,
|
|
swapDescription: LibValidator.SwapDescriptionStruct,
|
|
path: SafeArray<SingleSwap>,
|
|
amount: BigNumberish,
|
|
swapExecutorContractAddress: string,
|
|
curveRegistryAddress: string,
|
|
provider: JsonRpcProvider
|
|
) {
|
|
let calls: BytesLike[] = [];
|
|
switch (factory) {
|
|
case "OrionV2": {
|
|
swapDescription.srcReceiver = path.first().pool;
|
|
calls = await generateUni2Calls(path, swapExecutorContractAddress);
|
|
break;
|
|
}
|
|
case "UniswapV2": {
|
|
swapDescription.srcReceiver = path.first().pool;
|
|
calls = await generateUni2Calls(path, swapExecutorContractAddress);
|
|
break;
|
|
}
|
|
case "UniswapV3": {
|
|
calls = await generateUni3Calls(path, amount, swapExecutorContractAddress, provider);
|
|
break;
|
|
}
|
|
case "OrionV3": {
|
|
calls = await generateOrion3Calls(path, amount, swapExecutorContractAddress, provider);
|
|
break;
|
|
}
|
|
case "Curve": {
|
|
if (path.length > 1) {
|
|
throw new Error("Supporting only single stable swap on curve");
|
|
}
|
|
calls = await generateCurveStableSwapCall(
|
|
amount,
|
|
swapExecutorContractAddress,
|
|
path.first(),
|
|
provider,
|
|
swapExecutorContractAddress,
|
|
curveRegistryAddress
|
|
);
|
|
break;
|
|
}
|
|
default: {
|
|
throw new Error(`Factory ${factory} is not supported`);
|
|
}
|
|
}
|
|
return { swapDescription, calls };
|
|
}
|
|
|
|
async function processMultiFactorySwaps(
|
|
swapDescription: LibValidator.SwapDescriptionStruct,
|
|
path: SafeArray<SingleSwap>,
|
|
amount: BigNumberish,
|
|
swapExecutorContractAddress: string,
|
|
curveRegistryAddress: string,
|
|
provider: JsonRpcProvider
|
|
) {
|
|
let calls: BytesLike[] = [];
|
|
for (const swap of path) {
|
|
switch (swap.factory) {
|
|
case "OrionV2": {
|
|
let transferCall = generateTransferCall(swap.assetIn, swap.pool, 0);
|
|
transferCall = pathCallWithBalance(transferCall, swap.assetIn);
|
|
const uni2Call = generateUni2Call(swap.pool, swap.assetIn, swap.assetOut, swapExecutorContractAddress);
|
|
calls.push(transferCall, uni2Call);
|
|
break;
|
|
}
|
|
case "UniswapV2": {
|
|
let transferCall = generateTransferCall(swap.assetIn, swap.pool, 0);
|
|
transferCall = pathCallWithBalance(transferCall, swap.assetIn);
|
|
const uni2Call = generateUni2Call(swap.pool, swap.assetIn, swap.assetOut, swapExecutorContractAddress);
|
|
calls.push(transferCall, uni2Call);
|
|
break;
|
|
}
|
|
case "UniswapV3": {
|
|
let uni3Call = await generateUni3Call(swap, 0, swapExecutorContractAddress, provider);
|
|
uni3Call = pathCallWithBalance(uni3Call, swap.assetIn);
|
|
calls.push(uni3Call);
|
|
break;
|
|
}
|
|
case "OrionV3": {
|
|
let orion3Call = await generateOrion3Call(swap, 0, swapExecutorContractAddress, provider);
|
|
orion3Call = pathCallWithBalance(orion3Call, swap.assetIn);
|
|
calls.push(orion3Call);
|
|
break;
|
|
}
|
|
case "Curve": {
|
|
let curveCalls = await generateCurveStableSwapCall(
|
|
amount,
|
|
swapExecutorContractAddress,
|
|
swap,
|
|
provider,
|
|
swapExecutorContractAddress,
|
|
curveRegistryAddress,
|
|
true
|
|
);
|
|
calls.push(...curveCalls);
|
|
break;
|
|
}
|
|
default: {
|
|
throw new Error(`Factory ${swap.factory} is not supported`);
|
|
}
|
|
}
|
|
}
|
|
return { swapDescription, calls };
|
|
}
|
|
|
|
async function payFeeToMatcher(
|
|
matcher: string,
|
|
feeToken: string,
|
|
feeAmount: BigNumberish,
|
|
calls: BytesLike[],
|
|
swapDescription: LibValidator.SwapDescriptionStruct,
|
|
) {
|
|
if (BigInt(feeAmount) !== 0n && feeToken === swapDescription.dstToken) {
|
|
const feePaymentCall = generateFeePaymentCall(matcher, feeToken, feeAmount)
|
|
calls.push(feePaymentCall)
|
|
}
|
|
return {swapDescription, calls}
|
|
}
|
|
|
|
function wrapOrUnwrapIfNeeded(
|
|
amount: BigNumberish,
|
|
swapDescription: LibValidator.SwapDescriptionStruct,
|
|
calls: BytesLike[],
|
|
swapExecutorContractAddress: string,
|
|
wethAddress: string
|
|
) {
|
|
const {dstReceiver, srcReceiver, srcToken, dstToken} = swapDescription;
|
|
if (srcToken === ZeroAddress) {
|
|
const wrapCall = generateWrapAndTransferCall(srcReceiver, { value: amount });
|
|
swapDescription.srcReceiver = swapExecutorContractAddress;
|
|
calls = ([wrapCall] as BytesLike[]).concat(calls);
|
|
}
|
|
if (dstToken === ZeroAddress) {
|
|
let unwrapCall = generateUnwrapAndTransferCall(dstReceiver, 0);
|
|
unwrapCall = pathCallWithBalance(unwrapCall, wethAddress);
|
|
calls.push(unwrapCall);
|
|
} else {
|
|
let transferCall = generateTransferCall(dstToken, dstReceiver, 0);
|
|
transferCall = pathCallWithBalance(transferCall, dstToken);
|
|
calls.push(transferCall);
|
|
}
|
|
return { swapDescription, calls };
|
|
}
|
|
|
|
async function shouldUseExchangeBalance(
|
|
srcToken: AddressLike,
|
|
initiatorAddress: AddressLike,
|
|
exchangeContractAddress: AddressLike,
|
|
amount: bigint,
|
|
provider: JsonRpcProvider
|
|
) {
|
|
const { walletBalance, exchangeBalance } = await getTotalBalance(
|
|
srcToken,
|
|
initiatorAddress,
|
|
exchangeContractAddress,
|
|
provider
|
|
);
|
|
const exchangeAllowance = await getExchangeAllowance(srcToken, initiatorAddress, exchangeContractAddress, provider);
|
|
|
|
if (walletBalance + exchangeBalance < amount) {
|
|
throw new Error(
|
|
`Not enough balance to make swap, totalBalance - ${walletBalance + exchangeBalance} swapAmount - ${amount}`
|
|
);
|
|
}
|
|
let useExchangeBalance = true;
|
|
let additionalTransferAmount = 0n;
|
|
|
|
if (walletBalance >= amount || exchangeBalance == 0n) {
|
|
useExchangeBalance = false;
|
|
additionalTransferAmount = amount;
|
|
} else {
|
|
additionalTransferAmount = exchangeBalance >= amount ? 0n : amount - exchangeBalance;
|
|
if (srcToken !== ZeroAddress && additionalTransferAmount > exchangeAllowance) {
|
|
throw new Error(
|
|
`Not enough allowance to make swap, allowance - ${exchangeAllowance} needed allowance - ${additionalTransferAmount}`
|
|
);
|
|
}
|
|
}
|
|
return { useExchangeBalance, additionalTransferAmount };
|
|
}
|