@guru-fund/sdk 0.1.0

package/dist/router/velora.js

@@ -0,0 +1,279 @@
+import { Contract, solidityPacked } from 'ethers';
+import { TOLL_DIVISOR_20BPS } from '../constants.js';
+import { IPancakeQuoterV2__factory, UniswapV2Adapter__factory, UniswapV3Adapter__factory, UniswapV4Adapter__factory, } from '../typechain/index.js';
+import { connectV4Quoter, toAdapterPathKeys } from './getUniswapV4Route.js';
+import { SWAP_DEADLINE_SECONDS } from './constants.js';
+import { finalizeRouteQuote } from './finalizeRoute.js';
+const V2_ROUTER_ABI = [
+    'function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts)',
+];
+function connectV2Router(address, provider) {
+    return new Contract(address, V2_ROUTER_ABI, provider);
+}
+function connectV3Quoter(address, provider) {
+    return IPancakeQuoterV2__factory.connect(address, provider);
+}
+export function buildVeloraDexConfig(addresses) {
+    const cfg = {};
+    if (addresses.adapters.uniswapV2 && addresses.routers.uniswapV2) {
+        cfg.UniswapV2 = {
+            adapter: addresses.adapters.uniswapV2,
+            routerAddress: addresses.routers.uniswapV2,
+        };
+    }
+    if (addresses.adapters.pancakeV2 && addresses.routers.pancakeV2) {
+        cfg.PancakeSwapV2 = {
+            adapter: addresses.adapters.pancakeV2,
+            routerAddress: addresses.routers.pancakeV2,
+        };
+    }
+    if (addresses.adapters.uniswapV3 && addresses.quoters.uniswapV3) {
+        cfg.UniswapV3 = {
+            adapter: addresses.adapters.uniswapV3,
+            quoterAddress: addresses.quoters.uniswapV3,
+        };
+    }
+    if (addresses.adapters.pancakeV3 && addresses.quoters.pancakeV3) {
+        cfg.PancakeSwapV3 = {
+            adapter: addresses.adapters.pancakeV3,
+            quoterAddress: addresses.quoters.pancakeV3,
+        };
+    }
+    if (addresses.adapters.uniswapV4 && addresses.quoters.uniswapV4) {
+        cfg.UniswapV4 = {
+            adapter: addresses.adapters.uniswapV4,
+            quoterAddress: addresses.quoters.uniswapV4,
+        };
+    }
+    return cfg;
+}
+export function isDexConfigured(addresses, dex) {
+    return Boolean(buildVeloraDexConfig(addresses)[dex]);
+}
+function encodeV3Path(path) {
+    const pathEncoding = ['address'];
+    const pathToEncode = [path[0].tokenIn];
+    for (const hop of path) {
+        pathEncoding.push('uint24', 'address');
+        pathToEncode.push(Number(hop.fee), hop.tokenOut);
+    }
+    return solidityPacked(pathEncoding, pathToEncode);
+}
+export async function getRouteFromPath({ chainId, addresses, provider, simulator, dex, cachedPath, amountIn, toll, vault, controller, account, maxSlippageE3, prefixTxs, }) {
+    if (!cachedPath) {
+        throw new Error('No cached path');
+    }
+    const dexConfig = buildVeloraDexConfig(addresses);
+    switch (dex) {
+        case 'PancakeSwapV2':
+        case 'UniswapV2': {
+            if (cachedPath.type !== 'v2') {
+                throw new Error('Expected V2 path');
+            }
+            const entry = dexConfig[dex];
+            if (!entry) {
+                throw new Error(`DEX ${dex} not supported on chainId ${chainId}`);
+            }
+            const router = connectV2Router(entry.routerAddress, provider);
+            const adapter = entry.adapter;
+            const [grossAmountToReceive, blockNumber] = await Promise.all([
+                router
+                    .getAmountsOut(amountIn, cachedPath.path)
+                    .then((amounts) => amounts.at(-1)),
+                provider.getBlockNumber(),
+            ]);
+            let amountQuoted = grossAmountToReceive;
+            let amountToSend = amountIn;
+            if (toll.amount === 0n) {
+                toll.amount = grossAmountToReceive / TOLL_DIVISOR_20BPS;
+                amountQuoted -= toll.amount;
+            }
+            else {
+                amountToSend += toll.amount;
+            }
+            const deadline = Math.floor(Date.now() / 1000) + SWAP_DEADLINE_SECONDS;
+            const buildCallDataForAmount = (amountToReceive) => UniswapV2Adapter__factory.createInterface().encodeFunctionData('executeSwap', [
+                {
+                    amountToSend,
+                    amountToReceive,
+                    path: cachedPath.path,
+                    deadline,
+                },
+            ]);
+            const context = {
+                chainId,
+                blockNumber,
+                controller,
+                vault,
+                adapter,
+                account,
+                path: cachedPath.path,
+                buildCallDataForAmount,
+                simulator,
+                prefixTxs,
+            };
+            const { finalAmountToReceive, callData, effectiveSlippageBps, finalTollAmount, } = await finalizeRouteQuote({
+                context,
+                amountToSend,
+                amountQuoted,
+                initialTollAmount: toll.amount,
+                maxSlippageE3,
+            });
+            return {
+                adapter,
+                data: {
+                    amountToSend,
+                    amountToReceive: finalAmountToReceive,
+                    path: cachedPath.path,
+                    deadline,
+                },
+                callData,
+                toll: { ...toll, amount: finalTollAmount },
+                hops: cachedPath.hops,
+                effectiveSlippageBps,
+            };
+        }
+        case 'PancakeSwapV3':
+        case 'UniswapV3': {
+            if (cachedPath.type !== 'v3') {
+                throw new Error('Expected V3 path');
+            }
+            const entry = dexConfig[dex];
+            if (!entry) {
+                throw new Error(`DEX ${dex} not supported on chainId ${chainId}`);
+            }
+            const adapter = entry.adapter;
+            const quoter = connectV3Quoter(entry.quoterAddress, provider);
+            const encodedPath = encodeV3Path(cachedPath.path);
+            const [{ amountOut: grossAmountToReceive }, blockNumber] = await Promise.all([
+                quoter.quoteExactInput.staticCall(encodedPath, amountIn),
+                provider.getBlockNumber(),
+            ]);
+            let amountQuoted = grossAmountToReceive;
+            let amountToSend = amountIn;
+            if (toll.amount === 0n) {
+                toll.amount = grossAmountToReceive / TOLL_DIVISOR_20BPS;
+                amountQuoted -= toll.amount;
+            }
+            else {
+                amountToSend += toll.amount;
+            }
+            const deadline = Math.floor(Date.now() / 1000) + SWAP_DEADLINE_SECONDS;
+            const buildCallDataForAmount = (amountToReceive) => UniswapV3Adapter__factory.createInterface().encodeFunctionData('executeSwap', [
+                {
+                    amountToSend,
+                    amountToReceive,
+                    path: encodedPath,
+                    deadline,
+                },
+            ]);
+            const context = {
+                chainId,
+                blockNumber,
+                controller,
+                vault,
+                adapter,
+                account,
+                path: cachedPath.path,
+                buildCallDataForAmount,
+                simulator,
+                prefixTxs,
+            };
+            const { finalAmountToReceive, callData, effectiveSlippageBps, finalTollAmount, } = await finalizeRouteQuote({
+                context,
+                amountToSend,
+                amountQuoted,
+                initialTollAmount: toll.amount,
+                maxSlippageE3,
+            });
+            return {
+                adapter,
+                data: {
+                    amountToSend,
+                    amountToReceive: finalAmountToReceive,
+                    path: encodedPath,
+                    deadline,
+                },
+                callData,
+                toll: { ...toll, amount: finalTollAmount },
+                hops: cachedPath.hops,
+                effectiveSlippageBps,
+            };
+        }
+        case 'UniswapV4': {
+            if (cachedPath.type !== 'v4') {
+                throw new Error('Expected V4 path');
+            }
+            const entry = dexConfig[dex];
+            if (!entry) {
+                throw new Error(`DEX ${dex} not supported on chainId ${chainId}`);
+            }
+            const adapter = entry.adapter;
+            const quoter = connectV4Quoter(entry.quoterAddress, provider);
+            const pathKeys = toAdapterPathKeys(cachedPath.path);
+            const currencyIn = cachedPath.path[0].tokenIn;
+            const [[grossAmountToReceive], blockNumber] = await Promise.all([
+                quoter.quoteExactInput.staticCall({
+                    exactCurrency: currencyIn,
+                    path: pathKeys,
+                    exactAmount: amountIn,
+                }),
+                provider.getBlockNumber(),
+            ]);
+            let amountQuoted = grossAmountToReceive;
+            let amountToSend = amountIn;
+            if (toll.amount === 0n) {
+                toll.amount = grossAmountToReceive / TOLL_DIVISOR_20BPS;
+                amountQuoted -= toll.amount;
+            }
+            else {
+                amountToSend += toll.amount;
+            }
+            const deadline = Math.floor(Date.now() / 1000) + SWAP_DEADLINE_SECONDS;
+            const buildCallDataForAmount = (amountToReceive) => UniswapV4Adapter__factory.createInterface().encodeFunctionData('executeSwap', [
+                {
+                    amountToSend,
+                    amountToReceive,
+                    currencyIn,
+                    path: pathKeys,
+                    deadline,
+                },
+            ]);
+            const context = {
+                chainId,
+                blockNumber,
+                controller,
+                vault,
+                adapter,
+                account,
+                path: cachedPath.path,
+                buildCallDataForAmount,
+                simulator,
+                prefixTxs,
+            };
+            const { finalAmountToReceive, callData, effectiveSlippageBps, finalTollAmount, } = await finalizeRouteQuote({
+                context,
+                amountToSend,
+                amountQuoted,
+                initialTollAmount: toll.amount,
+                maxSlippageE3,
+            });
+            return {
+                adapter,
+                data: {
+                    amountToSend,
+                    amountToReceive: finalAmountToReceive,
+                    currencyIn,
+                    path: pathKeys,
+                    deadline,
+                },
+                callData,
+                toll: { ...toll, amount: finalTollAmount },
+                hops: cachedPath.hops,
+                effectiveSlippageBps,
+            };
+        }
+        default:
+            throw new Error('INVALID_DEX');
+    }
+}

package/dist/schemas/index.d.ts

@@ -0,0 +1,6 @@
+export { bigNumberish, slippageSettingsRecord } from './primitives';
+export { quoteDepositSchema } from './quoteDeposit';
+export { quoteWithdrawalSchema } from './quoteWithdrawal';
+export { quoteTradeSchema } from './quoteTrade';
+export { quoteHarvestSchema } from './quoteHarvest';
+export { quoteRebalanceSchema } from './quoteRebalance';

package/dist/schemas/index.js

@@ -0,0 +1,6 @@
+export { bigNumberish, slippageSettingsRecord } from './primitives.js';
+export { quoteDepositSchema } from './quoteDeposit.js';
+export { quoteWithdrawalSchema } from './quoteWithdrawal.js';
+export { quoteTradeSchema } from './quoteTrade.js';
+export { quoteHarvestSchema } from './quoteHarvest.js';
+export { quoteRebalanceSchema } from './quoteRebalance.js';

package/dist/schemas/primitives.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+export declare const bigNumberish: (message?: string) => z.ZodUnion<[z.ZodUnion<[z.ZodBigInt, z.ZodEffects<z.ZodNumber, bigint, number>]>, z.ZodEffects<z.ZodString, bigint, string>]>;
+export declare const slippageSettingsRecord: () => z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodUnion<[z.ZodBigInt, z.ZodEffects<z.ZodNumber, bigint, number>]>, z.ZodEffects<z.ZodString, bigint, string>]>>>;

package/dist/schemas/primitives.js

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export const bigNumberish = (message = 'Must be a bigint, integer number, or integer string') => z
+    .bigint()
+    .or(z.number().int().transform((v) => BigInt(v)))
+    .or(z
+    .string()
+    .regex(/^-?\d+$/, { message })
+    .transform((v) => BigInt(v)));
+export const slippageSettingsRecord = () => z.record(z.string(), bigNumberish()).optional();

package/dist/schemas/quoteDeposit.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+export declare const quoteDepositSchema: z.ZodObject<{
+    ledger: z.ZodString;
+    account: z.ZodString;
+    coin: z.ZodString;
+    amount: z.ZodUnion<[z.ZodUnion<[z.ZodBigInt, z.ZodEffects<z.ZodNumber, bigint, number>]>, z.ZodEffects<z.ZodString, bigint, string>]>;
+    referrerFeeBps: z.ZodUnion<[z.ZodUnion<[z.ZodBigInt, z.ZodEffects<z.ZodNumber, bigint, number>]>, z.ZodEffects<z.ZodString, bigint, string>]>;
+    slippageSettings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodUnion<[z.ZodBigInt, z.ZodEffects<z.ZodNumber, bigint, number>]>, z.ZodEffects<z.ZodString, bigint, string>]>>>;
+}, "strip", z.ZodTypeAny, {
+    ledger: string;
+    amount: bigint;
+    account: string;
+    coin: string;
+    referrerFeeBps: bigint;
+    slippageSettings?: Record<string, bigint> | undefined;
+}, {
+    ledger: string;
+    amount: string | number | bigint;
+    account: string;
+    coin: string;
+    referrerFeeBps: string | number | bigint;
+    slippageSettings?: Record<string, string | number | bigint> | undefined;
+}>;

package/dist/schemas/quoteDeposit.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { bigNumberish, slippageSettingsRecord } from './primitives.js';
+export const quoteDepositSchema = z.object({
+    ledger: z.string(),
+    account: z.string(),
+    coin: z.string(),
+    amount: bigNumberish(),
+    referrerFeeBps: bigNumberish(),
+    slippageSettings: slippageSettingsRecord(),
+});

package/dist/schemas/quoteHarvest.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export declare const quoteHarvestSchema: z.ZodObject<{
+    ledger: z.ZodString;
+    coin: z.ZodString;
+    isManagementFeeEligible: z.ZodOptional<z.ZodBoolean>;
+    slippageSettings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodUnion<[z.ZodBigInt, z.ZodEffects<z.ZodNumber, bigint, number>]>, z.ZodEffects<z.ZodString, bigint, string>]>>>;
+}, "strip", z.ZodTypeAny, {
+    ledger: string;
+    coin: string;
+    isManagementFeeEligible?: boolean | undefined;
+    slippageSettings?: Record<string, bigint> | undefined;
+}, {
+    ledger: string;
+    coin: string;
+    isManagementFeeEligible?: boolean | undefined;
+    slippageSettings?: Record<string, string | number | bigint> | undefined;
+}>;

package/dist/schemas/quoteHarvest.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { slippageSettingsRecord } from './primitives.js';
+export const quoteHarvestSchema = z.object({
+    ledger: z.string(),
+    coin: z.string(),
+    isManagementFeeEligible: z.boolean().optional(),
+    slippageSettings: slippageSettingsRecord(),
+});

package/dist/schemas/quoteRebalance.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export declare const quoteRebalanceSchema: z.ZodObject<{
+    ledger: z.ZodString;
+    targetWeights: z.ZodArray<z.ZodObject<{
+        token: z.ZodString;
+        weight: z.ZodUnion<[z.ZodUnion<[z.ZodBigInt, z.ZodEffects<z.ZodNumber, bigint, number>]>, z.ZodEffects<z.ZodString, bigint, string>]>;
+    }, "strip", z.ZodTypeAny, {
+        token: string;
+        weight: bigint;
+    }, {
+        token: string;
+        weight: string | number | bigint;
+    }>, "many">;
+    slippageSettings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodUnion<[z.ZodBigInt, z.ZodEffects<z.ZodNumber, bigint, number>]>, z.ZodEffects<z.ZodString, bigint, string>]>>>;
+}, "strip", z.ZodTypeAny, {
+    ledger: string;
+    targetWeights: {
+        token: string;
+        weight: bigint;
+    }[];
+    slippageSettings?: Record<string, bigint> | undefined;
+}, {
+    ledger: string;
+    targetWeights: {
+        token: string;
+        weight: string | number | bigint;
+    }[];
+    slippageSettings?: Record<string, string | number | bigint> | undefined;
+}>;

package/dist/schemas/quoteRebalance.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { bigNumberish, slippageSettingsRecord } from './primitives.js';
+export const quoteRebalanceSchema = z.object({
+    ledger: z.string(),
+    targetWeights: z.array(z.object({
+        token: z.string(),
+        weight: bigNumberish(),
+    })),
+    slippageSettings: slippageSettingsRecord(),
+});

package/dist/schemas/quoteTrade.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+export declare const quoteTradeSchema: z.ZodObject<{
+    ledger: z.ZodString;
+    tokenIn: z.ZodString;
+    tokenOut: z.ZodString;
+    amountIn: z.ZodUnion<[z.ZodUnion<[z.ZodBigInt, z.ZodEffects<z.ZodNumber, bigint, number>]>, z.ZodEffects<z.ZodString, bigint, string>]>;
+    maxSlippage: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodBigInt, z.ZodEffects<z.ZodNumber, bigint, number>]>, z.ZodEffects<z.ZodString, bigint, string>]>>;
+}, "strip", z.ZodTypeAny, {
+    ledger: string;
+    amountIn: bigint;
+    tokenIn: string;
+    tokenOut: string;
+    maxSlippage?: bigint | undefined;
+}, {
+    ledger: string;
+    amountIn: string | number | bigint;
+    tokenIn: string;
+    tokenOut: string;
+    maxSlippage?: string | number | bigint | undefined;
+}>;

package/dist/schemas/quoteTrade.js

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { bigNumberish } from './primitives.js';
+export const quoteTradeSchema = z.object({
+    ledger: z.string(),
+    tokenIn: z.string(),
+    tokenOut: z.string(),
+    amountIn: bigNumberish(),
+    maxSlippage: bigNumberish().optional(),
+});

package/dist/schemas/quoteWithdrawal.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+export declare const quoteWithdrawalSchema: z.ZodObject<{
+    ledger: z.ZodString;
+    account: z.ZodString;
+    shares: z.ZodUnion<[z.ZodUnion<[z.ZodBigInt, z.ZodEffects<z.ZodNumber, bigint, number>]>, z.ZodEffects<z.ZodString, bigint, string>]>;
+    coin: z.ZodString;
+    referrerFeeBps: z.ZodUnion<[z.ZodUnion<[z.ZodBigInt, z.ZodEffects<z.ZodNumber, bigint, number>]>, z.ZodEffects<z.ZodString, bigint, string>]>;
+    slippageSettings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodUnion<[z.ZodBigInt, z.ZodEffects<z.ZodNumber, bigint, number>]>, z.ZodEffects<z.ZodString, bigint, string>]>>>;
+}, "strip", z.ZodTypeAny, {
+    ledger: string;
+    account: string;
+    coin: string;
+    referrerFeeBps: bigint;
+    shares: bigint;
+    slippageSettings?: Record<string, bigint> | undefined;
+}, {
+    ledger: string;
+    account: string;
+    coin: string;
+    referrerFeeBps: string | number | bigint;
+    shares: string | number | bigint;
+    slippageSettings?: Record<string, string | number | bigint> | undefined;
+}>;

package/dist/schemas/quoteWithdrawal.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { bigNumberish, slippageSettingsRecord } from './primitives.js';
+export const quoteWithdrawalSchema = z.object({
+    ledger: z.string(),
+    account: z.string(),
+    shares: bigNumberish(),
+    coin: z.string(),
+    referrerFeeBps: bigNumberish(),
+    slippageSettings: slippageSettingsRecord(),
+});

package/dist/txBuilders/buildDepositTx.d.ts

@@ -0,0 +1,17 @@
+import type { AddressLike, BytesLike, TransactionRequest } from 'ethers';
+type ExternalCallStruct = {
+    adapter: AddressLike;
+    callData: BytesLike;
+};
+export interface BuildDepositTxParams {
+    controller: string;
+    ledger: string;
+    coin: string;
+    amount: bigint;
+    sharesOutMin: bigint;
+    extCalls: ExternalCallStruct[];
+    referrerFeeBps: bigint;
+    from: string;
+}
+export default function buildDepositTx(params: BuildDepositTxParams): TransactionRequest;
+export {};

package/dist/txBuilders/buildDepositTx.js

@@ -0,0 +1,18 @@
+import { FundController__factory } from '../typechain/index.js';
+export default function buildDepositTx(params) {
+    const data = FundController__factory.createInterface().encodeFunctionData('deposit', [
+        {
+            ledger: params.ledger,
+            coin: params.coin,
+            amount: params.amount,
+            sharesOutMin: params.sharesOutMin,
+            extCalls: params.extCalls,
+            referrerFeeBps: params.referrerFeeBps,
+        },
+    ]);
+    return {
+        to: params.controller,
+        from: params.from,
+        data,
+    };
+}

package/dist/txBuilders/buildHarvestTx.d.ts

@@ -0,0 +1,16 @@
+import type { AddressLike, BytesLike, TransactionRequest } from 'ethers';
+type ExternalCallStruct = {
+    adapter: AddressLike;
+    callData: BytesLike;
+};
+export interface BuildHarvestTxParams {
+    controller: string;
+    ledger: string;
+    coin: string;
+    fraction: bigint;
+    isManagementFeeEligible: boolean;
+    extCalls: ExternalCallStruct[];
+    from: string;
+}
+export default function buildHarvestTx(params: BuildHarvestTxParams): TransactionRequest;
+export {};

package/dist/txBuilders/buildHarvestTx.js

@@ -0,0 +1,17 @@
+import { FundController__factory } from '../typechain/index.js';
+export default function buildHarvestTx(params) {
+    const data = FundController__factory.createInterface().encodeFunctionData('harvest', [
+        {
+            ledger: params.ledger,
+            coin: params.coin,
+            fraction: params.fraction,
+            isManagementFeeEligible: params.isManagementFeeEligible,
+            extCalls: params.extCalls,
+        },
+    ]);
+    return {
+        to: params.controller,
+        from: params.from,
+        data,
+    };
+}

package/dist/txBuilders/buildTradeTx.d.ts

@@ -0,0 +1,9 @@
+import type { TransactionRequest } from 'ethers';
+export interface BuildTradeTxParams {
+    controller: string;
+    ledger: string;
+    adapter: string;
+    callData: string;
+    from: string;
+}
+export default function buildTradeTx(params: BuildTradeTxParams): TransactionRequest;

package/dist/txBuilders/buildTradeTx.js

@@ -0,0 +1,9 @@
+import { FundController__factory } from '../typechain/index.js';
+export default function buildTradeTx(params) {
+    const data = FundController__factory.createInterface().encodeFunctionData('executeTrade', [params.ledger, params.adapter, params.callData]);
+    return {
+        to: params.controller,
+        from: params.from,
+        data,
+    };
+}

package/dist/txBuilders/buildWithdrawTx.d.ts

@@ -0,0 +1,16 @@
+import type { AddressLike, BytesLike, TransactionRequest } from 'ethers';
+type ExternalCallStruct = {
+    adapter: AddressLike;
+    callData: BytesLike;
+};
+export interface BuildWithdrawTxParams {
+    controller: string;
+    ledger: string;
+    coin: string;
+    shares: bigint;
+    extCalls: ExternalCallStruct[];
+    referrerFeeBps: bigint;
+    from: string;
+}
+export default function buildWithdrawTx(params: BuildWithdrawTxParams): TransactionRequest;
+export {};

package/dist/txBuilders/buildWithdrawTx.js

@@ -0,0 +1,17 @@
+import { FundController__factory } from '../typechain/index.js';
+export default function buildWithdrawTx(params) {
+    const data = FundController__factory.createInterface().encodeFunctionData('withdraw', [
+        {
+            ledger: params.ledger,
+            coin: params.coin,
+            shares: params.shares,
+            extCalls: params.extCalls,
+            referrerFeeBps: params.referrerFeeBps,
+        },
+    ]);
+    return {
+        to: params.controller,
+        from: params.from,
+        data,
+    };
+}

package/dist/txBuilders/index.d.ts

@@ -0,0 +1,8 @@
+export { default as buildDepositTx } from './buildDepositTx';
+export type { BuildDepositTxParams } from './buildDepositTx';
+export { default as buildWithdrawTx } from './buildWithdrawTx';
+export type { BuildWithdrawTxParams } from './buildWithdrawTx';
+export { default as buildHarvestTx } from './buildHarvestTx';
+export type { BuildHarvestTxParams } from './buildHarvestTx';
+export { default as buildTradeTx } from './buildTradeTx';
+export type { BuildTradeTxParams } from './buildTradeTx';

package/dist/txBuilders/index.js

@@ -0,0 +1,4 @@
+export { default as buildDepositTx } from './buildDepositTx.js';
+export { default as buildWithdrawTx } from './buildWithdrawTx.js';
+export { default as buildHarvestTx } from './buildHarvestTx.js';
+export { default as buildTradeTx } from './buildTradeTx.js';