@morpho-org/bundler-sdk-viem 4.1.4 → 4.3.0

package/lib/esm/bundle.d.ts

@@ -0,0 +1,12 @@
+import type { SimulationState } from "@morpho-org/simulation-sdk";
+import type { Address } from "viem";
+import { type BundlingOptions } from "./operations.js";
+import type { InputBundlerOperation } from "./types/index.js";
+export declare const setupBundle: (inputOperations: InputBundlerOperation[], startData: SimulationState, receiver: Address, { supportsSignature, unwrapTokens, unwrapSlippage, ...options }?: BundlingOptions & {
+    supportsSignature?: boolean;
+    unwrapTokens?: Set<Address>;
+    unwrapSlippage?: bigint;
+}) => {
+    operations: import("./types/operations.js").BundlerOperation[];
+    bundle: import("./ActionBundle.js").ActionBundle<import("./types/actions.js").TransactionRequirement, import("./types/actions.js").SignatureRequirement>;
+};

package/lib/esm/bundle.js

@@ -0,0 +1,11 @@
+import { encodeBundle } from "./actions.js";
+import { finalizeBundle, populateBundle, } from "./operations.js";
+export const setupBundle = (inputOperations, startData, receiver, { supportsSignature, unwrapTokens, unwrapSlippage, ...options } = {}) => {
+    let { operations } = populateBundle(inputOperations, startData, options);
+    operations = finalizeBundle(operations, startData, receiver, unwrapTokens, unwrapSlippage);
+    const bundle = encodeBundle(operations, startData, supportsSignature);
+    return {
+        operations,
+        bundle,
+    };
+};

package/lib/esm/errors.d.ts

@@ -0,0 +1,30 @@
+import type { OperationType, SimulationResult } from "@morpho-org/simulation-sdk";
+import type { Address } from "viem";
+import type { ActionType, InputBundlerOperation } from "./types/index.js";
+export declare namespace BundlerErrors {
+    class Bundle extends Error {
+        readonly error: Error;
+        readonly index: number;
+        readonly inputOperation: InputBundlerOperation;
+        readonly steps: SimulationResult;
+        constructor(error: Error, index: number, inputOperation: InputBundlerOperation, steps: SimulationResult);
+    }
+    class MissingSignature extends Error {
+        constructor();
+    }
+    class MissingSwapData extends Error {
+        constructor();
+    }
+    class UnexpectedAction extends Error {
+        constructor(type: ActionType, chainId: number);
+    }
+    class UnexpectedSignature extends Error {
+        constructor(spender: Address);
+    }
+    class MissingSkimHandler extends Error {
+        constructor(type: OperationType);
+    }
+    class UnskimedToken extends Error {
+        constructor(token: Address);
+    }
+}

package/lib/esm/errors.js

@@ -0,0 +1,54 @@
+export var BundlerErrors;
+(function (BundlerErrors) {
+    class Bundle extends Error {
+        error;
+        index;
+        inputOperation;
+        steps;
+        constructor(error, index, inputOperation, steps) {
+            super(error.message);
+            this.error = error;
+            this.index = index;
+            this.inputOperation = inputOperation;
+            this.steps = steps;
+            this.stack = error.stack;
+        }
+    }
+    BundlerErrors.Bundle = Bundle;
+    class MissingSignature extends Error {
+        constructor() {
+            super(`missing signature`);
+        }
+    }
+    BundlerErrors.MissingSignature = MissingSignature;
+    class MissingSwapData extends Error {
+        constructor() {
+            super(`missing swap data`);
+        }
+    }
+    BundlerErrors.MissingSwapData = MissingSwapData;
+    class UnexpectedAction extends Error {
+        constructor(type, chainId) {
+            super(`unexpected action "${type}" on chain "${chainId}"`);
+        }
+    }
+    BundlerErrors.UnexpectedAction = UnexpectedAction;
+    class UnexpectedSignature extends Error {
+        constructor(spender) {
+            super(`unexpected signature consumer "${spender}"`);
+        }
+    }
+    BundlerErrors.UnexpectedSignature = UnexpectedSignature;
+    class MissingSkimHandler extends Error {
+        constructor(type) {
+            super(`missing skim handler for operation "${type}"`);
+        }
+    }
+    BundlerErrors.MissingSkimHandler = MissingSkimHandler;
+    class UnskimedToken extends Error {
+        constructor(token) {
+            super(`missing final skim for token "${token}"`);
+        }
+    }
+    BundlerErrors.UnskimedToken = UnskimedToken;
+})(BundlerErrors || (BundlerErrors = {}));

package/lib/esm/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./actions.js";
+export * from "./operations.js";
+export * from "./errors.js";
+export * from "./types/index.js";
+export * from "./BundlerAction.js";
+export * from "./bundle.js";
+export * from "./ActionBundle.js";
+export * from "./abis.js";

package/lib/esm/index.js

@@ -0,0 +1,8 @@
+export * from "./actions.js";
+export * from "./operations.js";
+export * from "./errors.js";
+export * from "./types/index.js";
+export * from "./BundlerAction.js";
+export * from "./bundle.js";
+export * from "./ActionBundle.js";
+export * from "./abis.js";

package/lib/esm/operations.d.ts

@@ -0,0 +1,78 @@
+import { type Address, type MarketId } from "@morpho-org/blue-sdk";
+import { type MaybeDraft, type Operation, type Operations, type PublicAllocatorOptions, type SimulationResult, type SimulationState } from "@morpho-org/simulation-sdk";
+import type { BundlerOperation, CallbackBundlerOperation, InputBundlerOperation } from "./types/index.js";
+/**
+ * The default target utilization above which the shared liquidity algorithm is triggered (scaled by WAD).
+ */
+export declare const DEFAULT_SUPPLY_TARGET_UTILIZATION = 905000000000000000n;
+export interface BundlingOptions {
+    withSimplePermit?: Set<Address>;
+    publicAllocatorOptions?: PublicAllocatorOptions & {
+        /**
+         * The target utilization of each market above which the shared liquidity algorithm is triggered (scaled by WAD).
+         */
+        supplyTargetUtilization?: Record<MarketId, bigint | undefined>;
+        /**
+         * The default target utilization above which the shared liquidity algorithm is triggered (scaled by WAD).
+         * @default 90.5%
+         */
+        defaultSupplyTargetUtilization?: bigint;
+    };
+    getRequirementOperations?: (requiredTokenAmounts: {
+        token: Address;
+        required: bigint;
+    }[]) => BundlerOperation[];
+}
+export declare const populateInputTransfer: ({ address, args: { amount, from } }: Operations["Erc20_Transfer"], data: MaybeDraft<SimulationState>, { hasSimplePermit }?: {
+    hasSimplePermit?: boolean;
+}) => Exclude<BundlerOperation, CallbackBundlerOperation>[];
+/**
+ * Simulates the input operation on the given simulation data with args tweaked so the bundler operates on behalf of the sender.
+ * Then, populates a bundle of operations made of:
+ * - required approvals to the bundler
+ * - required input transfers to the bundler
+ * - required token wrapping
+ * - the given operation
+ * @param inputOperation The input operation to populate a bundle for.
+ * @param data The simulation data to determine the required steps of the bundle to populate. If the provided simulation data is the result of a simulation
+ * of an already populated bundle, the `Transfer` and `Wrap` operation are only populated if required.
+ * @param wrapSlippage The slippage simulated during wraps. Should never be 0.
+ * @return The bundle of operations to optimize and skim before being encoded.
+ */
+export declare const populateSubBundle: (inputOperation: InputBundlerOperation, data: MaybeDraft<SimulationState>, options?: BundlingOptions) => BundlerOperation[];
+/**
+ * Merges unnecessary duplicate `Erc20_Approve`, `Erc20_Transfer` and `Erc20_Wrap`.
+ * Also redirects `Blue_Borrow|Withdraw|WithdrawCollateral` & `MetaMorpho_Withdraw` operations from the bundler to the receiver,
+ * as long as the tokens received (possibly ERC4626 shares) are not used afterwards in the bundle.
+ * For all the other remaining tokens, appends `Erc20_Transfer` operations to the bundle, from the bundler to the receiver.
+ * @param operations The bundle to optimize.
+ * @param startData The start data from which to simulate th bundle.
+ * @param receiver The receiver of skimmed tokens.
+ * @param unwrapTokens The set of tokens to unwrap before transferring to the receiver.
+ * @param unwrapSlippage The slippage simulated during unwraps. Should never be 0.
+ * @return The optimized bundle.
+ */
+export declare const finalizeBundle: (operations: BundlerOperation[], startData: SimulationState, receiver: Address, unwrapTokens?: Set<`0x${string}`>, unwrapSlippage?: bigint) => BundlerOperation[];
+export declare const populateBundle: (inputOperations: InputBundlerOperation[], data: MaybeDraft<SimulationState>, options?: BundlingOptions) => {
+    operations: BundlerOperation[];
+    steps: SimulationResult;
+};
+export declare const simulateRequiredTokenAmounts: (operations: Operation[], data: MaybeDraft<SimulationState>) => {
+    token: `0x${string}`;
+    required: bigint;
+}[];
+export declare const getSimulatedBundlerOperation: (operation: Omit<BundlerOperation, "sender">, { slippage }?: {
+    slippage?: bigint;
+}) => Operation;
+export declare const handleBundlerOperation: (options?: {
+    slippage?: bigint;
+}) => (operation: BundlerOperation, startData: MaybeDraft<SimulationState>, index?: number) => MaybeDraft<SimulationState>;
+export declare const handleBundlerOperations: (operations: BundlerOperation[], startData: MaybeDraft<SimulationState>, options?: {
+    slippage?: bigint;
+}) => SimulationResult;
+export declare const simulateBundlerOperation: (options?: {
+    slippage?: bigint;
+}) => (operation: BundlerOperation, startData: MaybeDraft<SimulationState>, index?: number) => MaybeDraft<SimulationState>;
+export declare const simulateBundlerOperations: (operations: BundlerOperation[], startData: MaybeDraft<SimulationState>, options?: {
+    slippage?: bigint;
+}) => SimulationResult;