@gearbox-protocol/sdk 16.0.0-next.2 → 16.0.0-next.21

package/dist/types/onchain/types/transactions.d.ts

@@ -0,0 +1,40 @@
+import { Address, Hex } from "viem";
+//#region src/onchain/types/transactions.d.ts
+interface ContractMethod {
+  inputs: any[];
+  name: string;
+  payable: boolean;
+}
+/**
+ * A transaction plus the ABI metadata needed to render and replay it.
+ */
+interface RawTx {
+  to: Address;
+  value: string;
+  signature: string;
+  callData: Hex;
+  contractMethod: ContractMethod;
+  contractInputsValues: Record<string, any>;
+  description?: string;
+}
+/**
+ * Wrapper interface for RawTx with diagnostic data
+ */
+interface IPriceUpdateTx<Data extends {
+  timestamp: number;
+  priceFeed: Address;
+} = {
+  priceFeed: Address;
+  timestamp: number;
+}> {
+  raw: RawTx;
+  data: Data;
+  pretty: string;
+  validateTimestamp: (timestamp: bigint) => "valid" | "too old" | "in future";
+}
+interface MultiCall {
+  target: Address;
+  callData: Hex;
+}
+//#endregion
+export { ContractMethod, IPriceUpdateTx, MultiCall, RawTx };

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

@@ -0,0 +1,101 @@
+import { Address } from "viem";
+//#region src/onchain/utils/AddressMap.d.ts
+/**
+ * Case-insensitive map keyed by EVM addresses.
+ *
+ * All keys are checksummed via viem's {@link getAddress} on insertion and
+ * lookup, so `0xabc...` and `0xABC...` resolve to the same entry.
+ *
+ * @typeParam T - Type of values stored in the map.
+ */
+declare class AddressMap<T> {
+  #private;
+  /**
+   * @param entries - Optional initial key-value pairs. Address strings are checksummed automatically.
+   * @param name - Optional label used in error messages when a lookup fails.
+   */
+  constructor(entries?: Array<[string, T]>, name?: string);
+  /**
+   * Adds or updates a value. Passing `undefined` removes the entry.
+   * @param address - EVM address (checksummed automatically).
+   * @param value - Value to store, or `undefined` to delete the entry.
+   * @throws If the map has been {@link freeze | frozen}.
+   */
+  upsert(address: string, value: T | undefined): void;
+  /**
+   * Inserts a value, throwing if the address is already present.
+   * @param address - EVM address (checksummed automatically).
+   * @param value - Value to store.
+   * @throws If the map has been {@link freeze | frozen} or if `address` already exists.
+   */
+  insert(address: string, value: T): void;
+  /**
+   * Checks whether an address is present in the map.
+   * @param address - EVM address (case-insensitive).
+   */
+  has(address: string): boolean;
+  /**
+   * Looks up a value by EVM address (case-insensitive).
+   * @param address - EVM address to look up.
+   * @returns The stored value, or `undefined` if not present.
+   */
+  get(address: string): T | undefined;
+  /**
+   * Looks up a value by EVM address, throwing if the address is absent.
+   * @param address - EVM address to look up.
+   * @throws If `address` is not in the map.
+   */
+  mustGet(address: string): T;
+  /**
+   * Removes an entry by address. No-op if the address is absent.
+   * @param address - EVM address to remove.
+   */
+  delete(address: string): void;
+  /**
+   * Removes all entries from the map.
+   **/
+  clear(): void;
+  /**
+   * Returns all entries as an array of `[checksummedAddress, value]` tuples.
+   **/
+  entries(): Array<[Address, T]>;
+  /**
+   * Returns all values in insertion order.
+   **/
+  values(): T[];
+  /**
+   * Returns all checksummed addresses in insertion order.
+   **/
+  keys(): Address[];
+  /**
+   * Returns an unfrozen shallow copy of the map.
+   **/
+  clone(): AddressMap<T>;
+  /**
+   * Converts the map to a plain `Record<Address, T>` object.
+   **/
+  asRecord(): Record<Address, T>;
+  /**
+   * Number of entries in the map.
+   **/
+  get size(): number;
+  /**
+   * Prevents further mutations. Any subsequent call to {@link upsert},
+   * {@link insert}, or {@link delete} will throw.
+   */
+  freeze(): void;
+  protected get name(): string | undefined;
+  /**
+   * Creates an `AddressMap` from a plain record object.
+   * @param record - Object whose keys are EVM addresses.
+   */
+  static fromRecord<T>(record: Record<Address, T>): AddressMap<T>;
+  /**
+   * Creates an `AddressMap` by extracting an address from each array element.
+   * @param array - Source items.
+   * @param mapFn - Function that returns the address key for a given item.
+   */
+  static fromMappedArray<T>(array: T[], mapFn: (item: T) => Address): AddressMap<T>;
+}
+//#endregion
+export { AddressMap };

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

@@ -0,0 +1,28 @@
+import { Address } from "viem";
+//#region src/onchain/utils/AddressSet.d.ts
+/**
+ * Case-insensitive set of EVM addresses.
+ *
+ * All addresses are checksummed via viem's {@link getAddress} on insertion and
+ * lookup, so `0xabc...` and `0xABC...` are treated as the same entry.
+ */
+declare class AddressSet extends Set<Address> {
+  /**
+   * @param entries - Optional initial addresses. Each is checksummed automatically.
+   */
+  constructor(entries?: Iterable<Address>);
+  add(value: Address): this;
+  delete(value: Address): boolean;
+  has(value: Address): boolean;
+  difference<U>(other: ReadonlySetLike<U>): AddressSet;
+  /**
+   * Returns all addresses as an array.
+   **/
+  asArray(): Address[];
+  /**
+   * Maps each address through `fn` and returns the resulting array.
+   **/
+  map<T>(fn: (address: Address) => T): T[];
+}
+//#endregion
+export { AddressSet };

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

@@ -0,0 +1,47 @@
+import { AddressMap } from "./AddressMap.js";
+import { Asset } from "../base/types.js";
+import { Address } from "viem";
+//#region src/onchain/utils/AssetsMap.d.ts
+/**
+ * Case-insensitive map from EVM token addresses to bigint balances.
+ * Missing keys are treated as `0n`.
+ */
+declare class AssetsMap extends AddressMap<bigint> {
+  /**
+   * @param entries - Optional initial entries as `[address, balance]` tuples or {@link Asset} objects.
+   * @param name - Optional label used in error messages when a lookup fails.
+   */
+  constructor(entries?: Array<[string, bigint] | Asset>, name?: string);
+  /**
+   * Looks up a token balance, treating a missing key as `0n`.
+   */
+  getOrZero(address: string): bigint;
+  /**
+   * Adds `amount` to the token balance, treating a missing key as `0n`.
+   */
+  inc(address: string, amount: bigint): void;
+  /**
+   * Subtracts `amount` from the token balance, treating a missing key as `0n`.
+   */
+  dec(address: string, amount: bigint): void;
+  /**
+   * Per-token difference `this - before`, non-zero entries only.
+   *
+   * Assumes this map's keys are a superset of `before`'s keys; tokens present
+   * only in `before` are not reported.
+   */
+  difference(before: AssetsMap): AssetsMap;
+  /**
+   * Sums `fn` over all entries.
+   */
+  sum(fn: (token: Address, balance: bigint) => bigint): bigint;
+  /**
+   * Converts the map to an array of {@link Asset} objects.
+   * @param minBalance - If provided, keeps only entries with a balance
+   * strictly greater than this threshold (e.g. `1n` to filter out dust).
+   */
+  toAssets(minBalance?: bigint): Asset[];
+  clone(): AssetsMap;
+}
+//#endregion
+export { AssetsMap };

package/dist/types/onchain/utils/abi-decode.d.ts

@@ -0,0 +1,26 @@
+import { Abi, DecodeFunctionDataReturnType, Hex } from "viem";
+//#region src/onchain/utils/abi-decode.d.ts
+/**
+ * Given an ABI and calldata (or 4-byte selector), returns the function
+ * signature (e.g. `"balanceOf(address)"`) by matching against selectors
+ * computed from the ABI's function items.
+ *
+ * @throws if no matching function is found in the ABI
+ */
+declare function getFunctionSignature(abi: Abi | readonly unknown[], calldataOrSelector: Hex): string;
+/**
+ * Converts decoded function args (as decoded by viem, i.e. as array) to named map of args
+ * Can return undefined if function is not found in ABI
+ * @param abi
+ * @param functionName
+ * @param args
+ * @returns
+ */
+declare function functionArgsToMap<T extends Abi | readonly unknown[]>(abi: T, functionName: string, args: DecodeFunctionDataReturnType<T>["args"]): Record<string, string>;
+/**
+ * Converts decoded function args to a named record preserving original types.
+ * Unlike {@link functionArgsToMap}, values are not stringified.
+ */
+declare function functionArgsToRecord<T extends Abi | readonly unknown[]>(abi: T, functionName: string, args: DecodeFunctionDataReturnType<T>["args"]): Record<string, unknown>;
+//#endregion
+export { functionArgsToMap, functionArgsToRecord, getFunctionSignature };

package/dist/types/onchain/utils/bigint-math.d.ts

@@ -0,0 +1,51 @@
+//#region src/onchain/utils/bigint-math.d.ts
+/**
+ * Utility namespace for common `bigint` operations.
+ *
+ * The constructor is private because this class is not meant to be
+ * instantiated; all helpers are exposed as static functions.
+ */
+declare class BigIntMath {
+  private constructor();
+  /**
+   * Returns the absolute (non-negative) value of a bigint.
+   *
+   * @param x Input value.
+   * @returns `x` when `x` is already non-negative, otherwise `-x`.
+   */
+  static abs: (x: bigint) => bigint;
+  /**
+   * Returns the greater of two bigint values.
+   * @param values - The values to find the maximum of.
+   * @returns The maximum value.
+   */
+  static max: (...values: bigint[]) => bigint;
+  /**
+   * Returns the smaller of two bigint values.
+   * @param values - The values to find the minimum of.
+   * @returns The minimum value.
+   */
+  static min: (...values: bigint[]) => bigint;
+  /**
+   * Returns the negative form of a bigint if it is currently positive.
+   *
+   * Useful when a value should be represented as an outflow/debit:
+   * - positive values become negative
+   * - zero and negative values are returned unchanged
+   *
+   * @param a Input value.
+   * @returns A non-positive bigint representation of `a`.
+   */
+  static neg: (a: bigint) => bigint;
+  /**
+   * Divides rounding toward positive infinity.
+   *
+   * @param a - Dividend; must not be negative.
+   * @param b - Divisor; must be positive — zero throws, negative returns
+   * nonsense rather than the ceiling.
+   * @returns The smallest integer that is at least `a / b`.
+   **/
+  static ceilDiv: (a: bigint, b: bigint) => bigint;
+}
+//#endregion
+export { BigIntMath };

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

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

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

@@ -0,0 +1,6 @@
+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 };

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

@@ -0,0 +1,14 @@
+import { RawTx } from "../types/transactions.js";
+import "../types/index.js";
+import { Abi, Address, ContractFunctionName, EncodeFunctionDataParameters } from "viem";
+//#region src/onchain/utils/createRawTx.d.ts
+/**
+ * @dev Creates a raw transaction data to be processed by the TxBatcher
+ * RawTx is a type that contains all the data needed to create different types of batches,
+ * like Multisig Safe batch over governor/timelock, or multisig direct call.
+ * 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 };

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

@@ -0,0 +1,17 @@
+import { NetworkType } from "../chain/chains.js";
+import "../chain/index.js";
+import { CreditAccountData } from "../base/types.js";
+import "../base/index.js";
+import { TransactionReceipt } from "viem";
+//#region src/onchain/utils/etherscan.d.ts
+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 };

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

@@ -0,0 +1,22 @@
+import { CreditAccountData } from "../base/types.js";
+import { OnchainSDK } from "../OnchainSDK.js";
+import "../base/index.js";
+import { Address } from "viem";
+//#region src/onchain/utils/filterDust.d.ts
+/**
+ * Helper function to filter out low-balance assets
+ * @param account
+ * @returns
+ */
+declare function filterDust(account: CreditAccountData): Record<Address, bigint>;
+interface FilterDustUSDOptions {
+  sdk: OnchainSDK;
+  account: CreditAccountData;
+  /**
+   * Dust threshold in USD, without decimals
+   */
+  minBalanceUSD?: bigint;
+}
+declare function filterDustUSD(opts: FilterDustUSDOptions): Record<Address, bigint>;
+//#endregion
+export { FilterDustUSDOptions, filterDust, filterDustUSD };

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

@@ -0,0 +1,23 @@
+//#region src/onchain/utils/formatter.d.ts
+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;
+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;
+//#endregion
+export { fmtBinaryMask, formatBN, formatBNvalue, formatDuration, formatLeverage, formatNumberToString_, formatPercentage, formatTimestamp, numberWithCommas, percentFmt, rayToNumber, shortAddress, shortHash, toBN, toBigInt, toSignificant };

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

@@ -0,0 +1,10 @@
+import { Hex } from "viem";
+//#region src/onchain/utils/hex.d.ts
+/**
+ * Returns if two hex strings are equal
+ * @param a
+ * @param b
+ */
+declare function hexEq(a?: Hex, b?: Hex): boolean;
+//#endregion
+export { hexEq };

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

@@ -0,0 +1,20 @@
+import { AddressMap } from "./AddressMap.js";
+import { AddressSet } from "./AddressSet.js";
+import { AssetsMap } from "./AssetsMap.js";
+import { functionArgsToMap, functionArgsToRecord, getFunctionSignature } from "./abi-decode.js";
+import { BigIntMath } from "./bigint-math.js";
+import { bytes32ToString } from "./bytes32ToString.js";
+import { childLogger } from "./childLogger.js";
+import { createRawTx } from "./createRawTx.js";
+import { EtherscanURLParam, etherscanApiUrl, etherscanUrl } from "./etherscan.js";
+import { FilterDustUSDOptions, filterDust, filterDustUSD } from "./filterDust.js";
+import { fmtBinaryMask, formatBN, formatBNvalue, formatDuration, formatLeverage, formatNumberToString_, formatPercentage, formatTimestamp, numberWithCommas, percentFmt, rayToNumber, shortAddress, shortHash, toBN, toBigInt, toSignificant } from "./formatter.js";
+import { hexEq } from "./hex.js";
+import { IsDustOptions, isDust } from "./isDust.js";
+import { json_parse, json_stringify } from "./json.js";
+import { Methods, PartialRecord, SupportedValue, TypedObjectUtils } from "./mappers.js";
+import { RetryOptions, retry } from "./retry.js";
+import { toAddress } from "./toAddress.js";
+import { PickSomeRequired } from "./type-utils.js";
+import { ZodAddress, ZodBigInt, ZodHex } from "./zod.js";
+export { AddressMap, AddressSet, AssetsMap, BigIntMath, EtherscanURLParam, FilterDustUSDOptions, IsDustOptions, Methods, PartialRecord, PickSomeRequired, RetryOptions, SupportedValue, TypedObjectUtils, ZodAddress, ZodBigInt, ZodHex, bytes32ToString, childLogger, createRawTx, etherscanApiUrl, etherscanUrl, filterDust, filterDustUSD, fmtBinaryMask, formatBN, formatBNvalue, formatDuration, formatLeverage, formatNumberToString_, formatPercentage, formatTimestamp, functionArgsToMap, functionArgsToRecord, getFunctionSignature, hexEq, isDust, json_parse, json_stringify, numberWithCommas, percentFmt, rayToNumber, retry, shortAddress, shortHash, toAddress, toBN, toBigInt, toSignificant };

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

@@ -0,0 +1,13 @@
+//#region src/onchain/utils/internal/Hooks.d.ts
+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> {
+  #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 };

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

@@ -0,0 +1,21 @@
+import { OnchainSDK } from "../OnchainSDK.js";
+import { Address } from "viem";
+//#region src/onchain/utils/isDust.d.ts
+interface IsDustOptions {
+  sdk: OnchainSDK;
+  token: Address;
+  balance: bigint;
+  creditManager: Address;
+  /**
+   * Dust threshold in USD, without decimals
+   */
+  minBalanceUSD?: bigint;
+}
+/**
+ * Checks if balance of token is dust, by checking getting usd prices from oracle
+ * @param opts
+ * @returns
+ */
+declare function isDust(opts: IsDustOptions): boolean;
+//#endregion
+export { IsDustOptions, isDust };

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

@@ -0,0 +1,5 @@
+//#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 };

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

@@ -0,0 +1,13 @@
+//#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 {
+  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 };

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

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

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

@@ -0,0 +1,7 @@
+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 };

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

@@ -0,0 +1,4 @@
+//#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 };

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

@@ -0,0 +1,10 @@
+import { CallParameters } from "viem";
+//#region src/onchain/utils/viem/cast.d.ts
+/**
+ * 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 };

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

@@ -0,0 +1,32 @@
+import { IPriceUpdateTx } from "../../types/transactions.js";
+import "../../types/index.js";
+import { Chain, Client, ContractFunctionParameters, Transport } from "viem";
+//#region src/onchain/utils/viem/executeDelegatedMulticalls.d.ts
+/**
+ * A contract call paired with a callback that receives its decoded result.
+ * Used to compose batched on-chain reads that are executed together inside a
+ * single {@link simulateWithPriceUpdates} call.
+ **/
+interface DelegatedMulticall {
+  /** Contract call parameters (ABI, address, function name, args). */
+  call: ContractFunctionParameters;
+  /** Callback invoked with the decoded return value after simulation. */
+  onResult: (resp: unknown) => void;
+}
+/**
+ * Executes multiple contract read calls in a single
+ * {@link simulateWithPriceUpdates} batch and dispatches each result to its
+ * corresponding {@link DelegatedMulticall.onResult} callback.
+ *
+ * @param client - Viem public client.
+ * @param multicalls - Calls to execute with their result handlers.
+ * @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: {
+  priceUpdates: IPriceUpdateTx[];
+  blockNumber: bigint;
+  gas?: bigint;
+}): Promise<void>;
+//#endregion
+export { DelegatedMulticall, executeDelegatedMulticalls };

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

@@ -0,0 +1,39 @@
+import { Chain, ContractFunctionParameters, MulticallResponse, PublicClient, Transport } from "viem";
+//#region src/onchain/utils/viem/executeMulticallBatches.d.ts
+/**
+ * A group of contract calls owned by a single registry, paired with a callback
+ * that receives the results of exactly this group, in the same order.
+ *
+ * Unlike {@link DelegatedMulticall}, which maps one call to one result, a batch
+ * 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 {
+  /** Contract calls of this batch. */
+  contracts: ContractFunctionParameters[];
+  /** Callback invoked with the results of this batch's calls, in order. */
+  onResults: (resps: MulticallResponse[]) => void;
+}
+/**
+ * Options for {@link executeMulticallBatches}.
+ **/
+interface ExecuteMulticallBatchesOptions {
+  /** Block to read at, defaults to the latest block. */
+  blockNumber?: bigint;
+}
+/**
+ * Executes the calls of several {@link MulticallBatch}es as a single multicall
+ * aggregate and dispatches each batch its own slice of the results.
+ *
+ * Failures are allowed per call: loaders in a batch decide themselves how to
+ * treat a reverted call (e.g. `contractType()` reverting on a plain ERC-20 is
+ * expected). Use {@link executeDelegatedMulticalls} instead when the calls need
+ * price updates applied first.
+ *
+ * @param client - Viem public client.
+ * @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 };

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

@@ -0,0 +1,15 @@
+import { RawTx } from "../../types/transactions.js";
+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"> & {
+  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"> & {
+  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 };