@gearbox-protocol/sdk 9.14.0 → 9.15.0

package/dist/types/permissionless/core/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./auditor";
+export * from "./bytecode";
+export * from "./pricefeed";
+export * from "./pricefeed-builder";
+export * from "./proposal";
+export * from "./raw-tx";

package/dist/types/permissionless/core/pricefeed-builder.d.ts

@@ -0,0 +1,59 @@
+import type { Address, Hex, PublicClient } from "viem";
+export interface PriceFeedParams {
+    address: Address;
+    stalenessPeriod: number;
+}
+export type InputValueParams = string | number | boolean | string[] | PriceFeedParams[] | PriceFeedParams;
+export type PriceFeedParamType = {
+    type: "uint256";
+    decimals?: number;
+} | {
+    type: "int256";
+    decimals?: number;
+} | {
+    type: "uint32";
+} | {
+    type: "uint8";
+} | {
+    type: "bool";
+} | {
+    type: "address";
+} | {
+    type: "bytes32";
+    formatValue?: (value: string) => Hex;
+} | {
+    type: "string";
+    maxLen?: number;
+} | {
+    type: "lowerbound";
+    getter: (values: Record<string, InputValueParams>, publicClient: PublicClient) => Promise<bigint>;
+} | {
+    type: "owner";
+} | {
+    type: "pricefeedParamsFlattened";
+} | {
+    type: "pricefeedParamsFixed";
+    qty: number;
+    minNonZero?: number;
+} | {
+    type: "pricefeedParamsVariable";
+    qty: number;
+    minNonZero?: number;
+} | {
+    type: "addressArrayFixed";
+    qty: number;
+    minNonZero?: number;
+    minNonZeroRefLabel?: string;
+};
+export interface PriceFeedConstructorParam {
+    label: string;
+    type: PriceFeedParamType;
+    defaultValue?: InputValueParams;
+    displayOrder?: number;
+}
+export interface PriceFeedSetupParams {
+    contractType: string;
+    version: number;
+    constructorParams: PriceFeedConstructorParam[];
+    stalenessPeriod: boolean;
+}

package/dist/types/permissionless/core/pricefeed.d.ts

@@ -0,0 +1,10 @@
+import type { Address } from "viem";
+export interface PriceFeed {
+    address: Address;
+    contractType: string;
+    version: number;
+    deployedBy: Address;
+    isInStore: boolean;
+    stalenessPeriod: number;
+    name: string;
+}

package/dist/types/permissionless/core/proposal.d.ts

@@ -0,0 +1,33 @@
+import type { Address, Hex } from "viem";
+export interface Signature {
+    signer: Address;
+    signature: Hex;
+}
+export interface CrossChainCall {
+    chainId: number;
+    callData: Hex;
+    target: Address;
+}
+export interface ParsedCall {
+    chainId: number;
+    target: Address;
+    label: string;
+    functionName: string;
+    args: Record<string, string>;
+}
+export interface Batch {
+    name: string;
+    prevHash: Hex;
+    calls: CrossChainCall[];
+    parsedCalls: ParsedCall[];
+    hash: Hex;
+    signatures: Signature[];
+    timestamp?: number;
+    transactionHash?: Hex;
+    blockNumber?: number;
+}
+export interface RecoveryMessage {
+    chainId: number;
+    startingBatchHash: Hex;
+    signatures: Signature[];
+}

package/dist/types/permissionless/core/raw-tx.d.ts

@@ -0,0 +1,4 @@
+import type { Abi, ContractFunctionName, EncodeFunctionDataParameters, Hex } from "viem";
+export declare function createCallData<abi extends Abi | readonly unknown[], functionName extends ContractFunctionName<abi> | undefined = undefined>(_abi: abi, parameters: Omit<EncodeFunctionDataParameters<abi, functionName>, "abi"> & {
+    description?: string;
+}): Hex;

package/dist/types/permissionless/deployment/addresses.d.ts

@@ -0,0 +1,7 @@
+export declare enum Addresses {
+    ADDRESS_PROVIDER = "0xF7f0a609BfAb9a0A98786951ef10e5FE26cC1E38",
+    ZERO_PRICE_FEED = "0x5dC92eC92cd5423EF95aEbe8Ac96619BCc9ffC88",
+    PRICE_FEED_STORE = "0x74A868AC479EE145029bB80827BB77F7B7c441cB",
+    IO_PROXY = "0xBcD875f0D62B9AA22481c81975F9AE1753Fc559A",
+    INSTANCE_MANAGER = "0x77777777144339Bdc3aCceE992D8d4D31734CB2e"
+}

package/dist/types/permissionless/deployment/mainnet.d.ts

@@ -0,0 +1,10 @@
+import type { Address } from "viem";
+export interface CCMConstructorParams {
+    signers: Address[];
+    threshold: number;
+    dao: Address;
+}
+export declare const MAINNET_CCM_CONSTRUCTOR_PARAMS: CCMConstructorParams;
+export declare const MAINNET_DEPLOYMENT_CCM_SALT = "0x5e732654dc26892d02b6ae236f4a14577a726514abee949c570d011bcbcbcaac";
+export declare const MAINNET_DEPLOYMENT_IM_SALT = "0x528da0da2d7789d36e2cbb0bd2bebf3f7d136e9c6c4e036fd56f7fd71ec5eb87";
+export declare const MAINNET_DEPLOYMENT_BLOCK = 22358827;

package/dist/types/permissionless/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./bindings";
+export * from "./chains/archive-transport";
+export * from "./core";
+export * from "./deployment/addresses";
+export * from "./deployment/mainnet";
+export * from "./utils";

package/dist/types/permissionless/plugins/index.d.ts

@@ -0,0 +1,3 @@
+export { getIrmDeployParamsAbi, type InterestRateModelType, parseIrmDeployParams, } from "./irm/constructor-params-abi";
+export { getLossPolicyDeployParamsAbi, type LossPolicyType, parseLossPolicyDeployParams, } from "./loss-policies/constructor-params-abi";
+export { getRateKeeperDeployParamsAbi, parseRateKeeperDeployParams, type RateKeeperType, } from "./rate-keepers/constructor-params-abi";

package/dist/types/permissionless/plugins/irm/constructor-params-abi.d.ts

@@ -0,0 +1,63 @@
+import { type Hex } from "viem";
+export type InterestRateModelType = "LINEAR";
+type AbiParameter = {
+    type: string;
+    name: string;
+    components?: readonly AbiParameter[];
+};
+export declare const LINEAR_IRM_ABI: readonly [{
+    readonly type: "uint256";
+    readonly name: "U_1";
+}, {
+    readonly type: "uint256";
+    readonly name: "U_2";
+}, {
+    readonly type: "uint256";
+    readonly name: "R_base";
+}, {
+    readonly type: "uint256";
+    readonly name: "R_slope1";
+}, {
+    readonly type: "uint256";
+    readonly name: "R_slope2";
+}, {
+    readonly type: "uint256";
+    readonly name: "R_slope3";
+}, {
+    readonly type: "bool";
+    readonly name: "isBorrowingMoreU2Forbidden";
+}];
+type VersionedAbi = Record<string, readonly AbiParameter[]>;
+/**
+ * Mapping from IRM type to ABI for decoding deploy params
+ * These ABIs correspond to the constructor parameters used in each IRM's getDeployParams method
+ * Based on the actual encodeAbiParameters calls in the IRM implementations
+ */
+export declare const irmDeployParamsAbiMapping: Record<InterestRateModelType, VersionedAbi>;
+/**
+ * Get the ABI for decoding deploy params for a specific IRM type
+ * @param irmType The IRM type
+ * @param version The version number (defaults to 310)
+ * @returns The ABI array for decoding deploy params or null if not found
+ */
+export declare function getIrmDeployParamsAbi(irmType: InterestRateModelType, version?: number): readonly AbiParameter[] | null;
+/**
+ * Parse IRM deploy parameters from encoded hex data
+ * @param irmType The IRM type
+ * @param version The version number
+ * @param data The encoded hex data
+ * @returns Parsed parameters as key-value pairs or null if parsing fails
+ */
+export declare function parseIrmDeployParams(irmPostfix: string, version: number, data: Hex): Record<string, string> | null;
+/**
+ * Check if an IRM type has a deploy params ABI defined
+ * @param irmType The IRM type to check
+ * @returns True if the IRM type has an ABI defined
+ */
+export declare function hasIrmDeployParamsAbi(irmType: string): irmType is InterestRateModelType;
+/**
+ * Get all supported IRM types
+ * @returns Array of supported IRM types
+ */
+export declare function getSupportedIrmTypes(): InterestRateModelType[];
+export {};

package/dist/types/permissionless/plugins/loss-policies/constructor-params-abi.d.ts

@@ -0,0 +1,48 @@
+import { type Hex } from "viem";
+export type LossPolicyType = "ALIASED";
+type AbiParameter = {
+    type: string;
+    name: string;
+    components?: readonly AbiParameter[];
+};
+export declare const ALIAS_LOSS_POLICY_ABI: readonly [{
+    readonly type: "address";
+    readonly name: "pool";
+}, {
+    readonly type: "address";
+    readonly name: "addressProvider";
+}];
+type VersionedAbi = Record<string, readonly AbiParameter[]>;
+/**
+ * Mapping from loss policy type to ABI for decoding deploy params
+ * These ABIs correspond to the constructor parameters used in each loss policy's getDeployParams method
+ * Based on the actual encodeAbiParameters calls in the loss policy implementations
+ */
+export declare const lossPolicyDeployParamsAbiMapping: Record<LossPolicyType, VersionedAbi>;
+/**
+ * Get the ABI for decoding deploy params for a specific loss policy type
+ * @param lossPolicyType The loss policy type
+ * @param version The version number (defaults to 310)
+ * @returns The ABI array for decoding deploy params or null if not found
+ */
+export declare function getLossPolicyDeployParamsAbi(lossPolicyType: LossPolicyType, version?: number): readonly AbiParameter[] | null;
+/**
+ * Parse loss policy deploy parameters from encoded hex data
+ * @param lossPolicyType The loss policy type
+ * @param version The version number
+ * @param data The encoded hex data
+ * @returns Parsed parameters as key-value pairs or null if parsing fails
+ */
+export declare function parseLossPolicyDeployParams(lossPolicyPostfix: string, version: number, data: Hex): Record<string, string> | null;
+/**
+ * Check if a loss policy type has a deploy params ABI defined
+ * @param lossPolicyType The loss policy type to check
+ * @returns True if the loss policy type has an ABI defined
+ */
+export declare function hasLossPolicyDeployParamsAbi(lossPolicyType: string): lossPolicyType is LossPolicyType;
+/**
+ * Get all supported loss policy types
+ * @returns Array of supported loss policy types
+ */
+export declare function getSupportedLossPolicyTypes(): LossPolicyType[];
+export {};

package/dist/types/permissionless/plugins/rate-keepers/constructor-params-abi.d.ts

@@ -0,0 +1,55 @@
+import { type Hex } from "viem";
+export type RateKeeperType = "TUMBLER" | "GAUGE";
+type AbiParameter = {
+    type: string;
+    name: string;
+    components?: readonly AbiParameter[];
+};
+export declare const TUMBLER_RATE_KEEPER_ABI: readonly [{
+    readonly type: "address";
+    readonly name: "pool";
+}, {
+    readonly type: "uint256";
+    readonly name: "epochSeconds";
+}];
+export declare const GAUGE_RATE_KEEPER_ABI: readonly [{
+    readonly type: "address";
+    readonly name: "pool";
+}, {
+    readonly type: "address";
+    readonly name: "gearStakingAddress";
+}];
+type VersionedAbi = Record<string, readonly AbiParameter[]>;
+/**
+ * Mapping from rate keeper type to ABI for decoding deploy params
+ * These ABIs correspond to the constructor parameters used in each rate keeper's getDeployParams method
+ * Based on the actual encodeAbiParameters calls in the rate keeper implementations
+ */
+export declare const rateKeeperDeployParamsAbiMapping: Record<RateKeeperType, VersionedAbi>;
+/**
+ * Get the ABI for decoding deploy params for a specific rate keeper type
+ * @param rateKeeperType The rate keeper type
+ * @param version The version number (defaults to 310)
+ * @returns The ABI array for decoding deploy params or null if not found
+ */
+export declare function getRateKeeperDeployParamsAbi(rateKeeperType: RateKeeperType, version?: number): readonly AbiParameter[] | null;
+/**
+ * Parse rate keeper deploy parameters from encoded hex data
+ * @param rateKeeperType The rate keeper type
+ * @param version The version number
+ * @param data The encoded hex data
+ * @returns Parsed parameters as key-value pairs or null if parsing fails
+ */
+export declare function parseRateKeeperDeployParams(rateKeeperPostfix: string, version: number, data: Hex): Record<string, string> | null;
+/**
+ * Check if a rate keeper type has a deploy params ABI defined
+ * @param rateKeeperType The rate keeper type to check
+ * @returns True if the rate keeper type has an ABI defined
+ */
+export declare function hasRateKeeperDeployParamsAbi(rateKeeperType: string): rateKeeperType is RateKeeperType;
+/**
+ * Get all supported rate keeper types
+ * @returns Array of supported rate keeper types
+ */
+export declare function getSupportedRateKeeperTypes(): RateKeeperType[];
+export {};

package/dist/types/permissionless/utils/abi-decoder.d.ts

@@ -0,0 +1,13 @@
+import { type Abi, type DecodeFunctionDataReturnType, type Hex } from "viem";
+export interface DecodedFunctionCall<T extends Abi | readonly unknown[] = Abi> {
+    functionName: string;
+    args: Record<string, string>;
+    originalDecoded: DecodeFunctionDataReturnType<T>;
+}
+/**
+ * Decodes function calldata and maps arguments to their parameter names from the ABI
+ * @param abi - The contract ABI
+ * @param calldata - The encoded function call data
+ * @returns Decoded function with named arguments and original decoded data, or null if decoding fails
+ */
+export declare function decodeFunctionWithNamedArgs<T extends Abi | readonly unknown[]>(abi: T, calldata: Hex): DecodedFunctionCall<T> | null;

package/dist/types/permissionless/utils/abi-encoder.d.ts

@@ -0,0 +1,7 @@
+import { type Address, type Hex } from "viem";
+export type ValueParams = string | Address | Hex | number | bigint | boolean | string[] | Address[] | Hex[] | number[] | bigint[] | boolean[];
+export type FunctionParams = {
+    type: string;
+    value: ValueParams;
+};
+export declare function encodeFunctionParams(params: FunctionParams[]): Hex;

package/dist/types/permissionless/utils/block-utils.d.ts

@@ -0,0 +1,8 @@
+import type { PublicClient } from "viem";
+/**
+ * Finds the block number closest to a given timestamp using binary search
+ * @param client - The PublicClient instance for blockchain interaction
+ * @param targetTimestamp - The timestamp to find the closest block for
+ * @returns Promise<number> - The block number closest to the target timestamp
+ */
+export declare function getBlockNumberByTimestamp(client: PublicClient, targetTimestamp: number): Promise<number>;

package/dist/types/permissionless/utils/create2.d.ts

@@ -0,0 +1,17 @@
+import { type Address, type Hex, type PublicClient, type WalletClient } from "viem";
+import type { RawTx } from "../../sdk/types/index.js";
+export declare const PUBLIC_CREATE2_FACTORY: "0x4e59b44847b379578588920ca78fbf26c0b4956c";
+export declare function handleSalt(salt: string | Hex): Hex;
+/**
+ * Deploys a contract using the public CREATE2 factory
+ * @param sponsor - Wallet client for sending transactions
+ * @param bytecode - The contract bytecode to deploy
+ * @param salt - Salt for the CREATE2 deployment (will be padded to 32 bytes)
+ * @returns Transaction hash of the deployment
+ */
+export declare function deployUsingPublicCreate2(sponsor: WalletClient, bytecode: Hex, salt: string | Hex): Promise<Hex>;
+export declare function getCreate2AddressPublicFactory(salt: string | Hex, bytecode: Hex): Promise<Address>;
+export declare function createCreate2DeployRawTx(bytecode: Hex, salt: string | Hex): RawTx;
+export declare function getCreate2DeploymentAddress(bytecode: Hex, salt: string | Hex): Address;
+export declare function checkCreate2Deployment(client: PublicClient, bytecode: Hex, salt: string | Hex): Promise<boolean>;
+export declare function checkCreate2DeploymentAddress(client: PublicClient, bytecode: Hex, salt: string | Hex): Promise<[boolean, Address]>;

package/dist/types/permissionless/utils/format.d.ts

@@ -0,0 +1,7 @@
+export declare function formatBytecodeSize(size: number): string;
+export declare function formatBytecodeVersion(version: number): string;
+export declare function formatTimestamp(timestamp: number): string;
+export declare function shortenHash(hash: string, chars?: number): string;
+export declare function convertPercent(percent: number): number;
+export declare function significantTrunc(x: number): string;
+export declare function deepJsonParse(value: unknown): unknown;

package/dist/types/permissionless/utils/governance/batch.d.ts

@@ -0,0 +1,17 @@
+import { type Address } from "viem";
+import type { RawTx } from "../../../sdk/types/index.js";
+import type { SafeBatch, SafeTx } from "../../bindings";
+export declare function convertRawTxToSafeMultisigTx(tx: RawTx): SafeTx;
+export declare function calculateChecksum(multisigBatch: SafeBatch): string | undefined;
+export declare function getSafeBatch(args: {
+    chainId: number;
+    safeAddress: Address;
+    name: string;
+    txs: SafeTx[];
+}): SafeBatch;
+export declare function getSafeBatches(args: {
+    chainId: number;
+    safeAddress: Address;
+    name: string;
+    batches: SafeTx[][];
+}): SafeBatch[];

package/dist/types/permissionless/utils/governance/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./batch";
+export * from "./timelock-txs";
+export * from "./types";

package/dist/types/permissionless/utils/governance/timelock-txs.d.ts

@@ -0,0 +1,2 @@
+import type { SafeTx } from "../../bindings";
+export declare function convertQueueBatchToExecuteTx(queueBatch: SafeTx[]): SafeTx;

package/dist/types/permissionless/utils/governance/types.d.ts

@@ -0,0 +1,16 @@
+import type { Address } from "viem";
+import type { SafeTx } from "../../bindings";
+export interface TimelockTxs {
+    chainId: number;
+    eta: number;
+    author: Address;
+    marketConfigurator: Address;
+    createdAtBlock: number;
+    queueBatches: SafeTx[][];
+}
+export interface InstanceTxs {
+    chainId: number;
+    author: Address;
+    instanceManager: Address;
+    batches: SafeTx[][];
+}

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

@@ -0,0 +1,9 @@
+export * from "./abi-decoder";
+export * from "./abi-encoder";
+export * from "./block-utils";
+export * from "./create2";
+export * from "./format";
+export * from "./governance";
+export * from "./literals";
+export * from "./price-update";
+export * from "./signature";

package/dist/types/permissionless/utils/literals.d.ts

@@ -0,0 +1,7 @@
+export declare const CROSS_CHAIN_GOVERNANCE = "CROSS_CHAIN_GOVERNANCE";
+export declare const BYTECODE_REPOSITORY = "BYTECODE_REPOSITORY";
+export declare const INSTANCE_MANAGER = "INSTANCE_MANAGER";
+export declare const TOKEN_COMPRESSOR = "GLOBAL::TOKEN_COMPRESSOR";
+export declare const CROSS_CHAIN_MULTISIG = "CROSS_CHAIN_MULTISIG";
+export declare const PRICE_FEED_STORE = "PRICE_FEED_STORE";
+export declare const MARKET_CONFIGURATOR_FACTORY = "MARKET_CONFIGURATOR_FACTORY";

package/dist/types/permissionless/utils/price-update/get-price-feeds.d.ts

@@ -0,0 +1,8 @@
+import type { Address, PublicClient } from "viem";
+import type { ParsedCall } from "../../core";
+export declare function getCallTouchedPriceFeeds(parsedCall: ParsedCall): Address[];
+export declare function getCallsTouchedPriceFeeds(parsedCalls: ParsedCall[]): Address[];
+export declare function getCallsTouchedUpdatablePriceFeeds({ parsedCalls, client, }: {
+    client: PublicClient;
+    parsedCalls: ParsedCall[];
+}): Promise<Address[]>;

package/dist/types/permissionless/utils/price-update/get-price-update-tx.d.ts

@@ -0,0 +1,9 @@
+import { type Address, type PublicClient } from "viem";
+import { type IPriceUpdateTx, type RawTx } from "../../../sdk/index.js";
+import { type PriceUpdate } from "../../bindings";
+export declare function getUpdateCalldata(tx: IPriceUpdateTx): PriceUpdate;
+export declare function getPriceUpdateTx({ client, priceFeeds, useMulticall3, }: {
+    client: PublicClient;
+    priceFeeds: Address[];
+    useMulticall3?: boolean;
+}): Promise<RawTx | undefined>;

package/dist/types/permissionless/utils/price-update/get-prices.d.ts

@@ -0,0 +1,6 @@
+import { type Address, type PublicClient } from "viem";
+export declare function getPrices({ client, priceFeeds, chunkSize, }: {
+    client: PublicClient;
+    priceFeeds: Address[];
+    chunkSize?: number;
+}): Promise<Record<Address, bigint | null>>;

package/dist/types/permissionless/utils/price-update/get-updatable-feeds.d.ts

@@ -0,0 +1,8 @@
+import { type Address, type PublicClient } from "viem";
+import { type GearboxSDK, type IPriceFeedContract } from "../../../sdk/index.js";
+export declare function getUpdatablePriceFeeds(args: {
+    sdk: GearboxSDK;
+    client: PublicClient;
+    pfCompressor: Address;
+    priceFeeds: Address[];
+}): Promise<IPriceFeedContract[]>;

package/dist/types/permissionless/utils/price-update/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./get-price-feeds";
+export * from "./get-price-update-tx";
+export * from "./get-prices";
+export * from "./get-updatable-feeds";

package/dist/types/permissionless/utils/signature.d.ts

@@ -0,0 +1,2 @@
+import type { Hex } from "viem";
+export declare function normalizeSignature(signature: Hex): Hex;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "9.14.0",
+  "version": "9.15.0",
   "description": "Gearbox SDK",
   "license": "MIT",
   "main": "./dist/cjs/sdk/index.js",
@@ -34,6 +34,16 @@
       "types": "./dist/types/abi/*.d.ts",
       "import": "./dist/esm/abi/*.js",
       "default": "./dist/cjs/abi/*.js"
+    },
+    "./permissionless": {
+      "types": "./dist/types/permissionless/index.d.ts",
+      "import": "./dist/esm/permissionless/index.js",
+      "default": "./dist/cjs/permissionless/index.js"
+    },
+    "./permissionless/*": {
+      "types": "./dist/types/permissionless/*.d.ts",
+      "import": "./dist/esm/permissionless/*.js",
+      "default": "./dist/cjs/permissionless/*.js"
     }
   },
   "files": [