@gearbox-protocol/sdk 17.13.0-next.1 → 17.13.0-next.10

package/dist/types/onchain/utils/bytes32ToString.d.ts

@@ -1,5 +1,4 @@
 import { Hex } from "viem";
 //#region src/onchain/utils/bytes32ToString.d.ts
-declare function bytes32ToString(bytes: Hex): string;
-//#endregion
-export { bytes32ToString };
+export declare function bytes32ToString(bytes: Hex): string;
+//#endregion

package/dist/types/onchain/utils/childLogger.d.ts

@@ -1,6 +1,5 @@
 import { ILogger } from "../types/logger.js";
 import "../types/index.js";
 //#region src/onchain/utils/childLogger.d.ts
-declare function childLogger(module: string, logger?: ILogger): ILogger | undefined;
-//#endregion
-export { childLogger };
+export declare function childLogger(module: string, logger?: ILogger): ILogger | undefined;
+//#endregion

package/dist/types/onchain/utils/createRawTx.d.ts

@@ -9,6 +9,5 @@ import { Abi, Address, ContractFunctionName, EncodeFunctionDataParameters } from
  * Also RawTx data used to generate Governor execution batch, used to execute queued txs from EOA.
  * @returns
  */
-declare function createRawTx<const abi extends Abi | readonly unknown[], functionName extends ContractFunctionName<abi> | undefined = undefined>(to: Address, parameters: EncodeFunctionDataParameters<abi, functionName>, description?: string): RawTx;
-//#endregion
-export { createRawTx };
+export declare function createRawTx<const abi extends Abi | readonly unknown[], functionName extends ContractFunctionName<abi> | undefined = undefined>(to: Address, parameters: EncodeFunctionDataParameters<abi, functionName>, description?: string): RawTx;
+//#endregion

package/dist/types/onchain/utils/etherscan.d.ts

@@ -4,14 +4,13 @@ import { CreditAccountData } from "../base/types.js";
 import "../base/index.js";
 import { TransactionReceipt } from "viem";
 //#region src/onchain/utils/etherscan.d.ts
-type EtherscanURLParam = {
+export type EtherscanURLParam = {
   block: number;
 } | {
   tx: string;
 } | {
   address: string;
 };
-declare function etherscanUrl(entity: EtherscanURLParam | TransactionReceipt | CreditAccountData, networkOrChainId: NetworkType | number | bigint, safe?: string): string;
-declare function etherscanApiUrl(networkOrChainId: NetworkType | number | bigint): string;
-//#endregion
-export { EtherscanURLParam, etherscanApiUrl, etherscanUrl };
+export declare function etherscanUrl(entity: EtherscanURLParam | TransactionReceipt | CreditAccountData, networkOrChainId: NetworkType | number | bigint, safe?: string): string;
+export declare function etherscanApiUrl(networkOrChainId: NetworkType | number | bigint): string;
+//#endregion

package/dist/types/onchain/utils/filterDust.d.ts

@@ -8,8 +8,8 @@ import { Address } from "viem";
  * @param account
  * @returns
  */
-declare function filterDust(account: CreditAccountData): Record<Address, bigint>;
-interface FilterDustUSDOptions {
+export declare function filterDust(account: CreditAccountData): Record<Address, bigint>;
+export interface FilterDustUSDOptions {
   sdk: OnchainSDK;
   account: CreditAccountData;
   /**
@@ -17,6 +17,5 @@ interface FilterDustUSDOptions {
    */
   minBalanceUSD?: bigint;
 }
-declare function filterDustUSD(opts: FilterDustUSDOptions): Record<Address, bigint>;
-//#endregion
-export { FilterDustUSDOptions, filterDust, filterDustUSD };
+export declare function filterDustUSD(opts: FilterDustUSDOptions): Record<Address, bigint>;
+//#endregion

package/dist/types/onchain/utils/formatter.d.ts

@@ -1,23 +1,23 @@
 //#region src/onchain/utils/formatter.d.ts
-declare const toBigInt: (v: string | number | bigint | {
+export declare const toBigInt: (v: string | number | bigint | {
   type: "BigNumber";
   hex: string;
 }) => bigint;
-declare const percentFmt: (v: number | bigint | string, raw?: boolean) => string;
-declare function formatBNvalue(num: number | bigint | string | undefined, decimals: number, precision?: number, raw?: boolean): string;
-declare function formatBN(num: number | bigint | string | undefined, decimals: number, precision?: number): string;
-declare function fmtBinaryMask(mask: bigint): string;
-declare function numberWithCommas(x: number | bigint): string;
-declare function formatDuration(seconds: number, raw?: boolean): string;
-declare function formatNumberToString_(value: bigint | number): string;
-declare function formatTimestamp(timestamp: number, raw?: boolean): string;
+export declare const percentFmt: (v: number | bigint | string, raw?: boolean) => string;
+export declare function formatBNvalue(num: number | bigint | string | undefined, decimals: number, precision?: number, raw?: boolean): string;
+export declare function formatBN(num: number | bigint | string | undefined, decimals: number, precision?: number): string;
+export declare function fmtBinaryMask(mask: bigint): string;
+export declare function numberWithCommas(x: number | bigint): string;
+export declare function formatDuration(seconds: number, raw?: boolean): string;
+export declare function formatNumberToString_(value: bigint | number): string;
+export declare function formatTimestamp(timestamp: number, raw?: boolean): string;
 type BigNumberish = bigint | number | string;
-declare function rayToNumber(num: BigNumberish): number;
-declare function toBN(num: string, decimals: number): bigint;
-declare function shortAddress(address?: string): string;
-declare function shortHash(address?: string): string;
-declare function formatPercentage(healthFactor: number, decimals?: number): string;
-declare function formatLeverage(leverage: number, decimals?: number): string;
-declare function toSignificant(num: bigint, decimals: number, precision?: number): string;
+export declare function rayToNumber(num: BigNumberish): number;
+export declare function toBN(num: string, decimals: number): bigint;
+export declare function shortAddress(address?: string): string;
+export declare function shortHash(address?: string): string;
+export declare function formatPercentage(healthFactor: number, decimals?: number): string;
+export declare function formatLeverage(leverage: number, decimals?: number): string;
+export declare function toSignificant(num: bigint, decimals: number, precision?: number): string;
 //#endregion
-export { fmtBinaryMask, formatBN, formatBNvalue, formatDuration, formatLeverage, formatNumberToString_, formatPercentage, formatTimestamp, numberWithCommas, percentFmt, rayToNumber, shortAddress, shortHash, toBN, toBigInt, toSignificant };
+export {};

package/dist/types/onchain/utils/hex.d.ts

@@ -5,6 +5,5 @@ import { Hex } from "viem";
  * @param a
  * @param b
  */
-declare function hexEq(a?: Hex, b?: Hex): boolean;
-//#endregion
-export { hexEq };
+export declare function hexEq(a?: Hex, b?: Hex): boolean;
+//#endregion

package/dist/types/onchain/utils/internal/Hooks.d.ts

@@ -1,13 +1,12 @@
 //#region src/onchain/utils/internal/Hooks.d.ts
-interface IHooks<HookMap extends Record<string, any[]>> {
+export interface IHooks<HookMap extends Record<string, any[]>> {
   addHook: <K extends keyof HookMap>(hookName: K, fn: (...args: HookMap[K]) => void | Promise<void>) => void;
   removeHook: <K extends keyof HookMap>(hookName: K, fn: (...args: HookMap[K]) => void | Promise<void>) => void;
 }
-declare class Hooks<HookMap extends Record<string, any[]>> implements IHooks<HookMap> {
+export declare class Hooks<HookMap extends Record<string, any[]>> implements IHooks<HookMap> {
   #private;
   addHook<K extends keyof HookMap>(hookName: K, fn: (...args: HookMap[K]) => void | Promise<void>): void;
   removeHook<K extends keyof HookMap>(hookName: K, fn: (...args: HookMap[K]) => void | Promise<void>): void;
   triggerHooks<K extends keyof HookMap>(hookName: K, ...args: HookMap[K]): Promise<void>;
 }
-//#endregion
-export { Hooks, IHooks };
+//#endregion

package/dist/types/onchain/utils/isDust.d.ts

@@ -1,7 +1,7 @@
 import { OnchainSDK } from "../OnchainSDK.js";
 import { Address } from "viem";
 //#region src/onchain/utils/isDust.d.ts
-interface IsDustOptions {
+export interface IsDustOptions {
   sdk: OnchainSDK;
   token: Address;
   balance: bigint;
@@ -16,6 +16,5 @@ interface IsDustOptions {
  * @param opts
  * @returns
  */
-declare function isDust(opts: IsDustOptions): boolean;
-//#endregion
-export { IsDustOptions, isDust };
+export declare function isDust(opts: IsDustOptions): boolean;
+//#endregion

package/dist/types/onchain/utils/json.d.ts

@@ -1,5 +1,4 @@
 //#region src/onchain/utils/json.d.ts
-declare const json_stringify: (obj: any, space?: number) => string;
-declare const json_parse: (s: string) => any;
-//#endregion
-export { json_parse, json_stringify };
+export declare const json_stringify: (obj: any, space?: number) => string;
+export declare const json_parse: (s: string) => any;
+//#endregion

package/dist/types/onchain/utils/mappers.d.ts

@@ -1,13 +1,12 @@
 //#region src/onchain/utils/mappers.d.ts
-type PartialRecord<K extends keyof any, T> = { [P in K]?: T; };
-type SupportedValue = string | number;
-declare class TypedObjectUtils {
+export type PartialRecord<K extends keyof any, T> = { [P in K]?: T; };
+export type SupportedValue = string | number;
+export declare class TypedObjectUtils {
   static keys: <K extends SupportedValue, T>(o: Record<K, T>) => Array<K>;
   static entries: <K extends SupportedValue, T>(o: Record<K, T>) => Array<[K, T]>;
   static fromEntries: <K extends SupportedValue, T>(o: Array<[K, T]>) => Record<K, T>;
   static swapKeyValue: <K extends SupportedValue, T extends SupportedValue>(o: Record<K, T>) => Record<T, K>;
   static keyToLowercase: <K extends SupportedValue, T>(o: Record<K, T>) => Record<K, T>;
 }
-type Methods<T> = { [K in keyof T]: T[K] extends Function ? K : never; }[keyof T];
-//#endregion
-export { Methods, PartialRecord, SupportedValue, TypedObjectUtils };
+export type Methods<T> = { [K in keyof T]: T[K] extends Function ? K : never; }[keyof T];
+//#endregion

package/dist/types/onchain/utils/retry.d.ts

@@ -1,9 +1,8 @@
 //#region src/onchain/utils/retry.d.ts
-interface RetryOptions {
+export interface RetryOptions {
   attempts?: number;
   interval?: number;
   exponent?: number;
 }
-declare function retry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
-//#endregion
-export { RetryOptions, retry };
+export declare function retry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+//#endregion

package/dist/types/onchain/utils/toAddress.d.ts

@@ -2,6 +2,5 @@ import { BaseState, IBaseContract } from "../base/types.js";
 import "../base/index.js";
 import { Address } from "viem";
 //#region src/onchain/utils/toAddress.d.ts
-declare function toAddress(value: Address | BaseState | IBaseContract): Address;
-//#endregion
-export { toAddress };
+export declare function toAddress(value: Address | BaseState | IBaseContract): Address;
+//#endregion

package/dist/types/onchain/utils/trace.d.ts

@@ -4,7 +4,7 @@ import { Address, Hex } from "viem";
  * A single frame from Ethereum's `debug_traceTransaction` callTracer output.
  * Recursive: each frame may contain nested sub-calls.
  */
-interface CallTrace {
+export interface CallTrace {
   from: Address;
   to: Address;
   input: Hex;
@@ -28,7 +28,7 @@ interface CallTrace {
  * (`execute(address,bytes)` on the credit account), so matching on this
  * selector isolates the real protocol call.
  */
-declare const EXECUTE_BYTES_SELECTOR: "0x09c5eabe";
+export declare const EXECUTE_BYTES_SELECTOR: "0x09c5eabe";
 /**
  * Finds the shallowest non-reverted `CreditManager.execute(bytes)` call in a
  * trace subtree (breadth-first), or `undefined` if none exists.
@@ -38,14 +38,14 @@ declare const EXECUTE_BYTES_SELECTOR: "0x09c5eabe";
  * `execute(bytes)` calls - inside its subtree. The shallowest match is the
  * adapter's own protocol call, not a nested one.
  */
-declare function findExecuteBytes(node: CallTrace): CallTrace | undefined;
+export declare function findExecuteBytes(node: CallTrace): CallTrace | undefined;
 /**
  * Finds the first non-reverted CALL in a subtree whose `input` exactly matches
  * `input` (case-insensitive). Used to locate the leaf CALL to the target
  * contract: `execute(bytes)` forwards the calldata unchanged through the credit
  * account proxy DELEGATECALL down to the final CALL to the protocol contract.
  */
-declare function findCallWithInput(node: CallTrace, input: Hex): CallTrace | undefined;
+export declare function findCallWithInput(node: CallTrace, input: Hex): CallTrace | undefined;
 /**
  * Resolves the external protocol call performed by an adapter-level call trace.
  *
@@ -58,19 +58,18 @@ declare function findCallWithInput(node: CallTrace, input: Hex): CallTrace | und
  *
  * @param node - direct child node of the upper-level facade call trace
  */
-declare function resolveProtocolCall(node: CallTrace): {
+export declare function resolveProtocolCall(node: CallTrace): {
   contract: Address;
   calldata: Hex;
 } | undefined;
 /**
  * Finds the first non-reverted CALL to `target` anywhere in a trace subtree.
  */
-declare function findCallTo(node: CallTrace, target: Address): CallTrace | undefined;
+export declare function findCallTo(node: CallTrace, target: Address): CallTrace | undefined;
 /**
  * DFS walk of the call trace tree, collecting non-reverted CALL entries
  * to the given address.
  * Does not recurse into children of matched nodes
  */
-declare function collectTraces(node: CallTrace, target: Address): CallTrace[];
-//#endregion
-export { CallTrace, EXECUTE_BYTES_SELECTOR, collectTraces, findCallTo, findCallWithInput, findExecuteBytes, resolveProtocolCall };
+export declare function collectTraces(node: CallTrace, target: Address): CallTrace[];
+//#endregion

package/dist/types/onchain/utils/type-utils.d.ts

@@ -1,4 +1,3 @@
 //#region src/onchain/utils/type-utils.d.ts
-type PickSomeRequired<T, RequiredKeys extends keyof T, OptionalKeys extends keyof T> = Required<Pick<T, RequiredKeys>> & Partial<Pick<T, OptionalKeys>>;
-//#endregion
-export { PickSomeRequired };
+export type PickSomeRequired<T, RequiredKeys extends keyof T, OptionalKeys extends keyof T> = Required<Pick<T, RequiredKeys>> & Partial<Pick<T, OptionalKeys>>;
+//#endregion

package/dist/types/onchain/utils/viem/cast.d.ts

@@ -4,7 +4,6 @@ import { CallParameters } from "viem";
  * Builds the argument list of a `cast call --trace` command reproducing the call,
  * without the leading `cast` binary, so that it can be spawned directly.
  */
-declare function getCastTraceArgs(params: CallParameters, rpcUrl?: string): string[];
-declare function generateCastTraceCall(params: CallParameters, rpcUrl?: string): string;
-//#endregion
-export { generateCastTraceCall, getCastTraceArgs };
+export declare function getCastTraceArgs(params: CallParameters, rpcUrl?: string): string[];
+export declare function generateCastTraceCall(params: CallParameters, rpcUrl?: string): string;
+//#endregion

package/dist/types/onchain/utils/viem/executeDelegatedMulticalls.d.ts

@@ -7,7 +7,7 @@ import { Chain, Client, ContractFunctionParameters, Transport } from "viem";
  * Used to compose batched on-chain reads that are executed together inside a
  * single {@link simulateWithPriceUpdates} call.
  **/
-interface DelegatedMulticall {
+export interface DelegatedMulticall {
   /** Contract call parameters (ABI, address, function name, args). */
   call: ContractFunctionParameters;
   /** Callback invoked with the decoded return value after simulation. */
@@ -23,10 +23,9 @@ interface DelegatedMulticall {
  * @param opts - Price-update transactions, target block number, and optional
  *   gas limit forwarded to the simulation.
  **/
-declare function executeDelegatedMulticalls(client: Client<Transport, Chain>, multicalls: DelegatedMulticall[], opts: {
+export declare function executeDelegatedMulticalls(client: Client<Transport, Chain>, multicalls: DelegatedMulticall[], opts: {
   priceUpdates: IPriceUpdateTx[];
   blockNumber: bigint;
   gas?: bigint;
 }): Promise<void>;
-//#endregion
-export { DelegatedMulticall, executeDelegatedMulticalls };
+//#endregion

package/dist/types/onchain/utils/viem/executeMulticallBatches.d.ts

@@ -8,7 +8,7 @@ import { Chain, ContractFunctionParameters, MulticallResponse, PublicClient, Tra
  * maps N calls to one handler: some loaders need all their results at once
  * (e.g. two calls per token, or a map rebuilt only after every market answered).
  **/
-interface MulticallBatch {
+export interface MulticallBatch {
   /** Contract calls of this batch. */
   contracts: ContractFunctionParameters[];
   /** Callback invoked with the results of this batch's calls, in order. */
@@ -17,7 +17,7 @@ interface MulticallBatch {
 /**
  * Options for {@link executeMulticallBatches}.
  **/
-interface ExecuteMulticallBatchesOptions {
+export interface ExecuteMulticallBatchesOptions {
   /** Block to read at, defaults to the latest block. */
   blockNumber?: bigint;
 }
@@ -34,6 +34,5 @@ interface ExecuteMulticallBatchesOptions {
  * @param batches - Batches to execute together, empty ones are allowed.
  * @param opts - Block number forwarded to the multicall.
  **/
-declare function executeMulticallBatches(client: PublicClient<Transport, Chain>, batches: MulticallBatch[], opts?: ExecuteMulticallBatchesOptions): Promise<void>;
-//#endregion
-export { ExecuteMulticallBatchesOptions, MulticallBatch, executeMulticallBatches };
+export declare function executeMulticallBatches(client: PublicClient<Transport, Chain>, batches: MulticallBatch[], opts?: ExecuteMulticallBatchesOptions): Promise<void>;
+//#endregion

package/dist/types/onchain/utils/viem/sendRawTx.d.ts

@@ -3,13 +3,12 @@ import "../../types/index.js";
 import { Account, Chain, Client, SendTransactionRequest, SendTransactionReturnType, Transport } from "viem";
 import { EstimateGasParameters, SendTransactionParameters as SendTransactionParameters$1 } from "viem/actions";
 //#region src/onchain/utils/viem/sendRawTx.d.ts
-type SendRawTxParameters<chain extends Chain, account extends Account | undefined, request extends SendTransactionRequest<chain, chainOverride>, chainOverride extends Chain | undefined = undefined> = Omit<SendTransactionParameters$1<chain, account, chainOverride, request>, "data" | "to" | "value"> & {
+export type SendRawTxParameters<chain extends Chain, account extends Account | undefined, request extends SendTransactionRequest<chain, chainOverride>, chainOverride extends Chain | undefined = undefined> = Omit<SendTransactionParameters$1<chain, account, chainOverride, request>, "data" | "to" | "value"> & {
   tx: Pick<RawTx, "to" | "callData" | "value">;
 };
-declare function sendRawTx<chain extends Chain, account extends Account | undefined, const request extends SendTransactionRequest<chain, chainOverride>, chainOverride extends Chain | undefined>(client: Client<Transport, chain, account>, params: SendRawTxParameters<chain, account, request, chainOverride>): Promise<SendTransactionReturnType>;
-type EstimateRawTxGasParameters<chain extends Chain> = Omit<EstimateGasParameters<chain>, "data" | "to" | "value"> & {
+export declare function sendRawTx<chain extends Chain, account extends Account | undefined, const request extends SendTransactionRequest<chain, chainOverride>, chainOverride extends Chain | undefined>(client: Client<Transport, chain, account>, params: SendRawTxParameters<chain, account, request, chainOverride>): Promise<SendTransactionReturnType>;
+export type EstimateRawTxGasParameters<chain extends Chain> = Omit<EstimateGasParameters<chain>, "data" | "to" | "value"> & {
   tx: Pick<RawTx, "to" | "callData" | "value">;
 };
-declare function estimateRawTxGas<chain extends Chain, account extends Account | undefined>(client: Client<Transport, chain, account>, params: EstimateRawTxGasParameters<chain>): Promise<bigint>;
-//#endregion
-export { EstimateRawTxGasParameters, SendRawTxParameters, estimateRawTxGas, sendRawTx };
+export declare function estimateRawTxGas<chain extends Chain, account extends Account | undefined>(client: Client<Transport, chain, account>, params: EstimateRawTxGasParameters<chain>): Promise<bigint>;
+//#endregion

package/dist/types/onchain/utils/viem/simulateCall.d.ts

@@ -1,6 +1,6 @@
 import { Abi, BaseError, CallParameters, Chain, Client, Hex, Transport, UnionOmit } from "viem";
 //#region src/onchain/utils/viem/simulateCall.d.ts
-type SimulateCallParameters<chain extends Chain | undefined = Chain | undefined> = CallParameters<chain> & {
+export type SimulateCallParameters<chain extends Chain | undefined = Chain | undefined> = CallParameters<chain> & {
   /**
    * ABIs used to decode the function and any custom error, but only when the call reverts.
    * Nothing is appended implicitly: pass `errorAbis` yourself to have gearbox exceptions decoded.
@@ -10,8 +10,8 @@ type SimulateCallParameters<chain extends Chain | undefined = Chain | undefined>
 /**
  * Same as {@link SimulateCallParameters}, minus the parts a contract knows about itself.
  */
-type SimulateCallOptions<chain extends Chain | undefined = Chain | undefined> = UnionOmit<SimulateCallParameters<chain>, "to" | "data">;
-interface SimulateCallReturnType {
+export type SimulateCallOptions<chain extends Chain | undefined = Chain | undefined> = UnionOmit<SimulateCallParameters<chain>, "to" | "data">;
+export interface SimulateCallReturnType {
   /**
    * Raw bytes returned by the call, `0x` when the function returns nothing.
    */
@@ -28,8 +28,8 @@ interface SimulateCallReturnType {
  * @param parameters - viem call parameters, plus the ABIs used for error decoding.
  * @throws {@link SimulationError} when the call reverts or the request fails.
  */
-declare function simulateCall<chain extends Chain | undefined>(client: Client<Transport, chain>, parameters: SimulateCallParameters<chain>): Promise<SimulateCallReturnType>;
-type SimulationErrorType = SimulationError & {
+export declare function simulateCall<chain extends Chain | undefined>(client: Client<Transport, chain>, parameters: SimulateCallParameters<chain>): Promise<SimulateCallReturnType>;
+export type SimulationErrorType = SimulationError & {
   name: "SimulationError";
 };
 /**
@@ -38,7 +38,7 @@ type SimulationErrorType = SimulationError & {
  * The viem {@link ContractFunctionExecutionError} built from the revert data is kept as `cause`,
  * so `walk()` still finds `ContractFunctionRevertedError` and its decoded (or raw) revert data.
  */
-declare class SimulationError extends BaseError {
+export declare class SimulationError extends BaseError {
   /**
    * The call that failed, kept verbatim so that it can be replayed or traced.
    */
@@ -53,5 +53,4 @@ declare class SimulationError extends BaseError {
    */
   getCastTraceCall(rpcUrl?: string): string;
 }
-//#endregion
-export { SimulateCallOptions, SimulateCallParameters, SimulateCallReturnType, SimulationError, SimulationErrorType, simulateCall };
+//#endregion

package/dist/types/onchain/utils/viem/simulateMulticall.d.ts

@@ -1,6 +1,6 @@
 import { AbiStateMutability, Address, CallParameters, Chain, Client, ContractFunctionParameters, MulticallContracts, MulticallReturnType, Narrow, Transport } from "viem";
 //#region src/onchain/utils/viem/simulateMulticall.d.ts
-type SimulateMulticallParameters<contracts extends readonly unknown[] = readonly ContractFunctionParameters[], allowFailure extends boolean = true, options extends {
+export type SimulateMulticallParameters<contracts extends readonly unknown[] = readonly ContractFunctionParameters[], allowFailure extends boolean = true, options extends {
   optional?: boolean;
   properties?: Record<string, any>;
 } = {}> = Pick<CallParameters, "blockNumber" | "blockTag" | "gas" | "account" | "value"> & {
@@ -10,7 +10,7 @@ type SimulateMulticallParameters<contracts extends readonly unknown[] = readonly
   } & options>;
   multicallAddress?: Address | undefined;
 };
-interface SimulateMulticallReturnType<contracts extends readonly unknown[] = readonly ContractFunctionParameters[], allowFailure extends boolean = true, options extends {
+export interface SimulateMulticallReturnType<contracts extends readonly unknown[] = readonly ContractFunctionParameters[], allowFailure extends boolean = true, options extends {
   error?: Error;
 } = {
   error: Error;
@@ -32,6 +32,5 @@ interface SimulateMulticallReturnType<contracts extends readonly unknown[] = rea
  * @param parameters
  * @returns
  */
-declare function simulateMulticall<const contracts extends readonly unknown[], chain extends Chain | undefined, allowFailure extends boolean = true>(client: Client<Transport, chain>, parameters: SimulateMulticallParameters<contracts, allowFailure>): Promise<SimulateMulticallReturnType<contracts, allowFailure>>;
-//#endregion
-export { SimulateMulticallParameters, SimulateMulticallReturnType, simulateMulticall };
+export declare function simulateMulticall<const contracts extends readonly unknown[], chain extends Chain | undefined, allowFailure extends boolean = true>(client: Client<Transport, chain>, parameters: SimulateMulticallParameters<contracts, allowFailure>): Promise<SimulateMulticallReturnType<contracts, allowFailure>>;
+//#endregion

package/dist/types/onchain/utils/viem/simulateWithPriceUpdates.d.ts

@@ -3,7 +3,7 @@ import { IPriceUpdateTx } from "../../types/transactions.js";
 import "../../types/index.js";
 import { BaseError, CallParameters, Chain, Client, ContractFunctionParameters, MulticallContracts, MulticallReturnType, Narrow, Transport } from "viem";
 //#region src/onchain/utils/viem/simulateWithPriceUpdates.d.ts
-type SimulateWithPriceUpdatesParameters<contracts extends readonly unknown[] = readonly ContractFunctionParameters[], options extends {
+export type SimulateWithPriceUpdatesParameters<contracts extends readonly unknown[] = readonly ContractFunctionParameters[], options extends {
   optional?: boolean;
   properties?: Record<string, any>;
 } = {}> = SimulateMulticallParameters<contracts, false, options> & {
@@ -18,28 +18,27 @@ type SimulateWithPriceUpdatesParameters<contracts extends readonly unknown[] = r
    */
   forceBlockNumberCheck?: boolean;
 };
-type SimulateWithPriceUpdatesReturnType<contracts extends readonly unknown[] = readonly ContractFunctionParameters[], options extends {
+export type SimulateWithPriceUpdatesReturnType<contracts extends readonly unknown[] = readonly ContractFunctionParameters[], options extends {
   error?: Error;
 } = {
   error: Error;
 }> = MulticallReturnType<contracts, false, options>;
-declare function simulateWithPriceUpdates<const contracts extends readonly unknown[], chain extends Chain | undefined>(client: Client<Transport, chain>, parameters: SimulateWithPriceUpdatesParameters<contracts>): Promise<SimulateWithPriceUpdatesReturnType<contracts>>;
-declare function getSimulateWithPriceUpdatesError<contracts extends readonly unknown[]>(cause: Error | undefined, priceUpdates: IPriceUpdateTx[], calls: MulticallContracts<Narrow<contracts>>, results?: MulticallReturnType<Narrow<contracts>>, request?: CallParameters): SimulateWithPriceUpdatesError;
-type SimulateWithPriceUpdatesErrorType = SimulateWithPriceUpdatesError & {
+export declare function simulateWithPriceUpdates<const contracts extends readonly unknown[], chain extends Chain | undefined>(client: Client<Transport, chain>, parameters: SimulateWithPriceUpdatesParameters<contracts>): Promise<SimulateWithPriceUpdatesReturnType<contracts>>;
+export declare function getSimulateWithPriceUpdatesError<contracts extends readonly unknown[]>(cause: Error | undefined, priceUpdates: IPriceUpdateTx[], calls: MulticallContracts<Narrow<contracts>>, results?: MulticallReturnType<Narrow<contracts>>, request?: CallParameters): SimulateWithPriceUpdatesError;
+export type SimulateWithPriceUpdatesErrorType = SimulateWithPriceUpdatesError & {
   name: "SimulateWithPriceUpdatesError";
 };
-interface SimulateWithPriceUpdatesErrorParams {
+export interface SimulateWithPriceUpdatesErrorParams {
   timestamp?: bigint;
   priceUpdates: string[];
   calls: string[];
   request?: CallParameters;
 }
-declare class SimulateWithPriceUpdatesError extends BaseError {
+export declare class SimulateWithPriceUpdatesError extends BaseError {
   #private;
   cause?: Error;
   readonly timestamp?: bigint;
   constructor(cause: Error | undefined, params: SimulateWithPriceUpdatesErrorParams);
   getCastTraceCall(rpcUrl?: string): string;
 }
-//#endregion
-export { SimulateWithPriceUpdatesError, SimulateWithPriceUpdatesErrorParams, SimulateWithPriceUpdatesErrorType, SimulateWithPriceUpdatesParameters, SimulateWithPriceUpdatesReturnType, getSimulateWithPriceUpdatesError, simulateWithPriceUpdates };
+//#endregion

package/dist/types/onchain/utils/viem/watchBlocksAsync.d.ts

@@ -7,7 +7,7 @@ type Block$1<chain extends Chain | undefined = Chain> = GetBlockReturnType<chain
  *
  * @typeParam chain - The chain type, derived from the client.
  */
-interface WatchBlocksAsyncParameters<chain extends Chain | undefined = Chain> {
+export interface WatchBlocksAsyncParameters<chain extends Chain | undefined = Chain> {
   /**
    * Async callback invoked when a new block is received.
    * If the handler is still running when the next block arrives, the new block
@@ -30,7 +30,7 @@ interface WatchBlocksAsyncParameters<chain extends Chain | undefined = Chain> {
   pollingInterval?: number | undefined;
 }
 /** Unwatch function returned by {@link watchBlocksAsync}. */
-type WatchBlocksAsyncReturnType = () => void;
+export type WatchBlocksAsyncReturnType = () => void;
 /**
  * Polls for new blocks over HTTP and invokes an **async** `onBlock` handler.
  *
@@ -71,6 +71,6 @@ type WatchBlocksAsyncReturnType = () => void;
  * unwatch();
  * ```
  */
-declare function watchBlocksAsync<chain extends Chain | undefined>(client: Client<Transport, chain>, parameters: WatchBlocksAsyncParameters<chain>): WatchBlocksAsyncReturnType;
+export declare function watchBlocksAsync<chain extends Chain | undefined>(client: Client<Transport, chain>, parameters: WatchBlocksAsyncParameters<chain>): WatchBlocksAsyncReturnType;
 //#endregion
-export { WatchBlocksAsyncParameters, WatchBlocksAsyncReturnType, watchBlocksAsync };
+export {};

package/dist/types/onchain/utils/zod.d.ts

@@ -4,14 +4,13 @@ import { z } from "zod/v4";
 /**
  * A `bigint` codec that serializes into string, deserializes into bigint.
  */
-declare const ZodBigInt: () => z.ZodCodec<z.ZodUnion<[z.ZodString, z.ZodBigInt]>, z.ZodBigInt>;
+export declare const ZodBigInt: () => z.ZodCodec<z.ZodUnion<[z.ZodString, z.ZodBigInt]>, z.ZodBigInt>;
 /**
  * Like Address from abitype/zod, but converts an address into an address that is checksum encoded.
  */
-declare const ZodAddress: () => z.ZodCodec<z.ZodString, z.ZodCustom<Address, Address>>;
+export declare const ZodAddress: () => z.ZodCodec<z.ZodString, z.ZodCustom<Address, Address>>;
 /**
  * A `0x`-prefixed hex string, as viem's Hex.
  */
-declare const ZodHex: () => z.ZodCodec<z.ZodString, z.ZodCustom<Hex, Hex>>;
-//#endregion
-export { ZodAddress, ZodBigInt, ZodHex };
+export declare const ZodHex: () => z.ZodCodec<z.ZodString, z.ZodCustom<Hex, Hex>>;
+//#endregion

package/dist/types/onchain/validation/bundles/checkAccountQuotas.d.ts

@@ -11,6 +11,5 @@ import { CreditSuite } from "../../market/credit/CreditSuite.js";
  * simulated one are held to it by the same code — including the reading that a
  * quota the operation zeroed out is no longer held.
  */
-declare function checkAccountQuotas(suite: CreditSuite, account: Pick<AccountProjection, "quotas">): QuotaCountExceededError[];
-//#endregion
-export { checkAccountQuotas };
+export declare function checkAccountQuotas(suite: CreditSuite, account: Pick<AccountProjection, "quotas">): QuotaCountExceededError[];
+//#endregion

package/dist/types/onchain/validation/bundles/checkCollateralFunding.d.ts

@@ -4,8 +4,8 @@ import { OnchainSDK } from "../../OnchainSDK.js";
 import { WalletFundingError } from "./checkWallet.js";
 import { Address } from "viem";
 //#region src/onchain/validation/bundles/checkCollateralFunding.d.ts
-type CollateralFundingPreview = OpenStrategyPositionPreview | AdjustStrategyPositionPreview | RepayStrategyPositionPreview;
-interface CheckCollateralFundingInput {
+export type CollateralFundingPreview = OpenStrategyPositionPreview | AdjustStrategyPositionPreview | RepayStrategyPositionPreview;
+export interface CheckCollateralFundingInput {
   sdk: OnchainSDK;
   preview: CollateralFundingPreview;
   sender: Address;
@@ -17,6 +17,5 @@ interface CheckCollateralFundingInput {
  * `NATIVE_ADDRESS` entry; the facade wraps it into WETH, so the WETH allowance
  * covers both halves.
  */
-declare function checkCollateralFunding(input: CheckCollateralFundingInput): Promise<WalletFundingError[]>;
-//#endregion
-export { CheckCollateralFundingInput, CollateralFundingPreview, checkCollateralFunding };
+export declare function checkCollateralFunding(input: CheckCollateralFundingInput): Promise<WalletFundingError[]>;
+//#endregion

package/dist/types/onchain/validation/bundles/checkCreditOperation.d.ts

@@ -1,4 +1,4 @@
-import { AccountNotMidasGreenlistedError, DebtOutOfRangeError, ForbiddenTokenError, InsufficientCollateralError, InsufficientPoolLiquidityError, QuotaCountExceededError, QuotaLimitReachedError, RWAOpenRequirementsError } from "../../../model/errors/operation-errors.js";
+import { AccountNotMidasGreenlistedError, DebtOutOfRangeError, ForbiddenTokenError, InsufficientCollateralError, InsufficientPoolLiquidityError, QuotaAboveMaxError, QuotaCountExceededError, QuotaLimitReachedError, RWAOpenRequirementsError } from "../../../model/errors/operation-errors.js";
 import { AdjustStrategyPositionPreview, OpenStrategyPositionPreview } from "../../../model/previews.js";
 import "../../../model/index.js";
 import { OnchainSDK } from "../../OnchainSDK.js";
@@ -8,10 +8,10 @@ import { MarketStateError } from "./checkMarket.js";
 import { Address } from "viem";
 //#region src/onchain/validation/bundles/checkCreditOperation.d.ts
 /** {@inheritDoc checkCreditOperation} */
-type CreditOperationError = MarketStateError | DebtOutOfRangeError | InsufficientPoolLiquidityError | ForbiddenTokenError | QuotaCountExceededError | QuotaLimitReachedError | InsufficientCollateralError | WalletFundingError | RWAOpenRequirementsError | AccountNotMidasGreenlistedError;
+export type CreditOperationError = MarketStateError | DebtOutOfRangeError | InsufficientPoolLiquidityError | ForbiddenTokenError | QuotaCountExceededError | QuotaAboveMaxError | QuotaLimitReachedError | InsufficientCollateralError | WalletFundingError | RWAOpenRequirementsError | AccountNotMidasGreenlistedError;
 /** The two previews that carry a position for the thresholds to weigh. */
-type CreditOperationPreview = OpenStrategyPositionPreview | AdjustStrategyPositionPreview;
-interface CreditOperationArgs extends HealthFactorThresholds {
+export type CreditOperationPreview = OpenStrategyPositionPreview | AdjustStrategyPositionPreview;
+export interface CreditOperationArgs extends HealthFactorThresholds {
   sdk: OnchainSDK;
   preview: CreditOperationPreview;
   /** The wallet that signs. Its balances, allowances and RWA standing are read on-chain. */
@@ -27,6 +27,5 @@ interface CreditOperationArgs extends HealthFactorThresholds {
  * quota it increases, then the account it leaves behind, and last the wallet's
  * side.
  */
-declare function checkCreditOperation(args: CreditOperationArgs): Promise<CreditOperationError[]>;
-//#endregion
-export { CreditOperationArgs, CreditOperationError, CreditOperationPreview, checkCreditOperation };
+export declare function checkCreditOperation(args: CreditOperationArgs): Promise<CreditOperationError[]>;
+//#endregion

package/dist/types/onchain/validation/bundles/checkHealthFactors.d.ts

@@ -7,7 +7,7 @@ import "../../../model/index.js";
  * The factors a caller holds an account to. Omitting a threshold switches its
  * check off — there is no single right one.
  */
-interface HealthFactorThresholds {
+export interface HealthFactorThresholds {
   /** Lowest acceptable health factor at main prices, in bps. */
   minHealthFactor?: Bps;
   /** Lowest acceptable health factor at safe prices, in bps. */
@@ -26,7 +26,7 @@ interface HealthFactorThresholds {
  * numbers it is handed — and passing them one by one is what makes the choice
  * visible where it is made.
  */
-interface WeighedFactors extends Pick<AccountHoldings, "totalDebt">, Pick<AccountMetrics, "healthFactor" | "safeHealthFactor"> {}
+export interface WeighedFactors extends Pick<AccountHoldings, "totalDebt">, Pick<AccountMetrics, "healthFactor" | "safeHealthFactor"> {}
 /**
  * The account against whichever thresholds the caller holds it to, so a parsed
  * transaction and a simulated one are weighed by the same code.
@@ -34,6 +34,5 @@ interface WeighedFactors extends Pick<AccountHoldings, "totalDebt">, Pick<Accoun
  * A loan-free account is nothing to weigh: the health factor reports its
  * zero-debt sentinel and no threshold applies.
  */
-declare function checkHealthFactors(account: WeighedFactors, thresholds: HealthFactorThresholds): InsufficientCollateralError[];
-//#endregion
-export { HealthFactorThresholds, WeighedFactors, checkHealthFactors };
+export declare function checkHealthFactors(account: WeighedFactors, thresholds: HealthFactorThresholds): InsufficientCollateralError[];
+//#endregion