@gearbox-protocol/sdk 11.9.0-next.1 → 11.9.0

package/dist/esm/sdk/router/AbstractRouterContract.js

@@ -1,18 +1,18 @@
 import { BaseContract } from "../base/index.js";
-import { AddressMap, isDust } from "../utils/index.js";
+import { PERCENTAGE_FACTOR } from "../constants/math.js";
+import { AddressMap, AddressSet, formatBN, isDust } from "../utils/index.js";
 import { Hooks } from "../utils/internal/index.js";
 import { limitLeftover } from "./helpers.js";
 class AbstractRouterContract extends BaseContract {
   hooks = new Hooks();
   addHook = this.hooks.addHook.bind(this.hooks);
   removeHook = this.hooks.removeHook.bind(this.hooks);
-  sdk;
-  constructor(sdk, args) {
-    super(sdk, args);
-    this.sdk = sdk;
-  }
-  getExpectedAndLeftover(ca, cm, balances, keepAssets) {
-    const b = balances || this.getDefaultExpectedAndLeftover(ca, keepAssets);
+  getExpectedAndLeftover(ca, cm, options = {}) {
+    const b = options.balances ? options.balances : this.getDefaultExpectedAndLeftover(
+      ca,
+      options.keepAssets,
+      options.debtOnly
+    );
     const { leftoverBalances, expectedBalances, tokensToClaim } = b;
     const expected = new AddressMap();
     const leftover = new AddressMap();
@@ -30,15 +30,22 @@ class AbstractRouterContract extends BaseContract {
       tokensToClaim
     };
   }
-  getDefaultExpectedAndLeftover(ca, keepAssets) {
+  getDefaultExpectedAndLeftover(ca, keepAssets, debtOnly) {
     const expectedBalances = new AddressMap();
     const leftoverBalances = new AddressMap();
-    const keepAssetsSet = new Set(keepAssets?.map((a) => a.toLowerCase()));
-    for (const { token: t, balance, mask } of ca.tokens) {
-      const token = t;
+    const keepAssetsSet = new AddressSet(keepAssets);
+    if (debtOnly) {
+      const result = this.getLeftoversAfterBuyingDebt(ca, keepAssetsSet);
+      if (result) {
+        return result;
+      } else {
+        this.logger?.warn("no token found to cover debt");
+      }
+    }
+    for (const { token, balance, mask } of ca.tokens) {
       const isEnabled = (mask & ca.enabledTokensMask) !== 0n;
       expectedBalances.upsert(token, { token, balance });
-      if (keepAssetsSet.has(token.toLowerCase()) || !isEnabled || isDust({
+      if (keepAssetsSet.has(token) || !isEnabled || isDust({
         sdk: this.sdk,
         token,
         balance,
@@ -56,6 +63,101 @@ class AbstractRouterContract extends BaseContract {
       tokensToClaim: new AddressMap()
     };
   }
+  /**
+   * Tries to sell just enought of most valuable token to cover debt
+   * @param ca
+   * @param keepAssets
+   * @returns
+   */
+  getLeftoversAfterBuyingDebt(ca, keepAssets) {
+    const { priceOracle } = this.sdk.marketRegister.findByCreditManager(
+      ca.creditManager
+    );
+    const expectedBalances = new AddressMap();
+    const leftoverBalances = new AddressMap();
+    const usdBalances = [];
+    for (const { token, balance, mask } of ca.tokens) {
+      const isEnabled = (mask & ca.enabledTokensMask) !== 0n;
+      expectedBalances.upsert(token, { token, balance });
+      leftoverBalances.upsert(token, {
+        token,
+        balance: limitLeftover(balance, token) ?? balance
+      });
+      if (isEnabled && !keepAssets.has(token)) {
+        usdBalances.push({
+          token,
+          balance: this.safeConvertToUSD(priceOracle, token, balance)
+        });
+      }
+    }
+    usdBalances.sort((a, b) => {
+      if (a.balance > b.balance) return -1;
+      if (a.balance < b.balance) return 1;
+      return 0;
+    });
+    if (usdBalances.length === 0) {
+      return void 0;
+    }
+    const highestToken = usdBalances[0];
+    const lt = this.sdk.marketRegister.findCreditManager(ca.creditManager).creditManager.liquidationThresholds.mustGet(highestToken.token);
+    const requiredDebtUSD = ca.totalDebtUSD * PERCENTAGE_FACTOR / BigInt(lt);
+    if (highestToken.balance < requiredDebtUSD) {
+      return void 0;
+    }
+    const tokenAmount = this.safeConvertFromUSD(
+      priceOracle,
+      highestToken.token,
+      requiredDebtUSD
+    );
+    if (tokenAmount === 0n) {
+      return void 0;
+    }
+    let leftoverBalance = leftoverBalances.get(highestToken.token)?.balance ?? 0n;
+    leftoverBalance -= tokenAmount;
+    if (leftoverBalance < 0n) {
+      return void 0;
+    }
+    leftoverBalances.upsert(highestToken.token, {
+      token: highestToken.token,
+      balance: leftoverBalance
+    });
+    const tokenAmountStr = this.sdk.tokensMeta.formatBN(
+      highestToken.token,
+      tokenAmount,
+      { symbol: true }
+    );
+    const totalDebtUSDStr = formatBN(ca.totalDebtUSD, 8);
+    this.logger?.debug(
+      `will sell ${tokenAmountStr} (LT=${lt}) to cover debt of ${totalDebtUSDStr} USD`
+    );
+    return {
+      expectedBalances,
+      leftoverBalances,
+      tokensToClaim: new AddressMap()
+    };
+  }
+  safeConvertToUSD(priceOracle, token, balance) {
+    try {
+      return priceOracle.convertToUSD(token, balance);
+    } catch {
+      try {
+        return priceOracle.convertToUSD(token, balance, true);
+      } catch {
+        return 0n;
+      }
+    }
+  }
+  safeConvertFromUSD(priceOracle, token, balance) {
+    try {
+      return priceOracle.convertFromUSD(token, balance);
+    } catch {
+      try {
+        return priceOracle.convertFromUSD(token, balance, true);
+      } catch {
+        return 0n;
+      }
+    }
+  }
 }
 export {
   AbstractRouterContract

package/dist/esm/sdk/router/RouterV300Contract.js

@@ -179,22 +179,22 @@ class RouterV300Contract extends AbstractRouterContract {
     creditAccount: ca,
     creditManager: cm,
     slippage,
-    balances
+    balances,
+    debtOnly
   }) {
     const {
       pathOptions,
       expected,
       leftover: leftoverUnsafe,
       connectors
-    } = this.getFindClosePathInput(
-      ca,
-      cm,
-      balances ? {
+    } = this.getFindClosePathInput(ca, cm, {
+      balances: balances ? {
         expectedBalances: assetsMap(balances.expectedBalances),
         leftoverBalances: assetsMap(balances.leftoverBalances),
         tokensToClaim: assetsMap(balances.tokensToClaim || [])
-      } : void 0
-    );
+      } : void 0,
+      debtOnly
+    });
     const leftover = leftoverUnsafe.map((a) => ({
       ...a,
       balance: limitLeftover(a.balance, a.token) ?? 0n
@@ -254,12 +254,11 @@ class RouterV300Contract extends AbstractRouterContract {
   /**
    * Implements {@link IRouterContract.getFindClosePathInput}
    */
-  getFindClosePathInput(ca, cm, balances, keepAssets) {
+  getFindClosePathInput(ca, cm, options) {
     const { expectedBalances, leftoverBalances } = this.getExpectedAndLeftover(
       ca,
       cm,
-      balances,
-      keepAssets
+      options
     );
     const leftover = leftoverBalances.values().map((a) => ({
       ...a,

package/dist/esm/sdk/router/RouterV310Contract.js

@@ -159,18 +159,18 @@ class RouterV310Contract extends AbstractRouterContract {
       creditManager: cm,
       slippage,
       balances,
-      keepAssets
+      keepAssets,
+      debtOnly
     } = props;
-    const { expectedBalances, leftoverBalances, tokensToClaim } = this.getExpectedAndLeftover(
-      ca,
-      cm,
-      balances ? {
+    const { expectedBalances, leftoverBalances, tokensToClaim } = this.getExpectedAndLeftover(ca, cm, {
+      balances: balances ? {
         expectedBalances: assetsMap(balances.expectedBalances),
         leftoverBalances: assetsMap(balances.leftoverBalances),
         tokensToClaim: assetsMap(balances.tokensToClaim || [])
       } : void 0,
-      keepAssets
-    );
+      keepAssets: balances ? void 0 : keepAssets,
+      debtOnly
+    });
     const getNumSplits = this.#numSplitsGetter(cm, expectedBalances.values());
     const tData = [];
     for (const token of cm.collateralTokens) {
@@ -276,15 +276,15 @@ class RouterV310Contract extends AbstractRouterContract {
    * @returns
    */
   #convertToUSDForSort(oracle, token, amount) {
-    const scale = 10n ** BigInt(this.tokensMeta.get(token)?.decimals ?? 0);
+    const scale = 10n ** BigInt(this.sdk.tokensMeta.get(token)?.decimals ?? 0);
     const price = oracle.mainPrices.get(token)?.price || oracle.reservePrices.get(token)?.price || scale;
     return amount * price / scale;
   }
   #debugTokenData(tData) {
     return tData.map((t) => ({
       token: this.labelAddress(t.token),
-      balance: `${this.tokensMeta.formatBN(t.token, t.balance)} (${t.balance})`,
-      leftoverBalance: this.tokensMeta.formatBN(t.token, t.leftoverBalance) + ` (${t.leftoverBalance})`,
+      balance: `${this.sdk.tokensMeta.formatBN(t.token, t.balance)} (${t.balance})`,
+      leftoverBalance: this.sdk.tokensMeta.formatBN(t.token, t.leftoverBalance) + ` (${t.leftoverBalance})`,
       numSplits: t.numSplits,
       claimRewards: t.claimRewards
     }));

package/dist/esm/sdk/router/createRouter.js

@@ -2,10 +2,6 @@ import { isV300, isV310 } from "../constants/index.js";
 import { RouterV300Contract } from "./RouterV300Contract.js";
 import { RouterV310Contract } from "./RouterV310Contract.js";
 function createRouter(sdk, address, version) {
-  const contract = sdk.getContract(address);
-  if (contract) {
-    return contract;
-  }
   if (isV300(version)) {
     return new RouterV300Contract(sdk, address, version);
   }

package/dist/esm/sdk/utils/index.js

@@ -1,6 +1,5 @@
 export * from "./AddressMap.js";
 export * from "./AddressSet.js";
-export * from "./abi-decode.js";
 export * from "./bytes32ToString.js";
 export * from "./childLogger.js";
 export * from "./createRawTx.js";

package/dist/types/dev/create2.d.ts

@@ -1,7 +1,7 @@
 import type { Abi } from "abitype";
 import type { Account, Address, Chain, Client, ContractConstructorArgs, GetChainParameter, Hash, Hex, SendTransactionParameters, SendTransactionReturnType, Transport, UnionEvaluate, UnionOmit, WalletClient } from "viem";
 import type { GearboxSDK } from "../sdk/index.js";
-import { Construct } from "../sdk/index.js";
+import { SDKConstruct } from "../sdk/index.js";
 export declare const PUBLIC_CREATE2_FACTORY: Address;
 export declare const DEFAULT_CREATE2_SALT = "GEARBOX";
 export type Create2Parameters<abi extends Abi | readonly unknown[] = Abi, chain extends Chain = Chain, account extends Account = Account, chainOverride extends Chain | undefined = Chain | undefined, allArgs = ContractConstructorArgs<abi>> = UnionOmit<SendTransactionParameters<chain, account, chainOverride>, "accessList" | "chain" | "to" | "data"> & GetChainParameter<chain, chainOverride> & UnionEvaluate<readonly [] extends allArgs ? {
@@ -24,7 +24,7 @@ export interface EnsureExistsUsingPublicCreate2ReturnType {
     address: Address;
     hash?: Hash;
 }
-export declare class Create2Deployer<transport extends Transport = Transport, chain extends Chain = Chain, account extends Account = Account> extends Construct {
+export declare class Create2Deployer<transport extends Transport = Transport, chain extends Chain = Chain, account extends Account = Account> extends SDKConstruct {
     #private;
     constructor(sdk: GearboxSDK, walletClient: WalletClient<transport, chain, account>);
     ensureExists<abi extends Abi | readonly unknown[], chainOverride extends Chain | undefined = Chain | undefined>(parameters: Create2Parameters<abi, chain, account, chainOverride>): Promise<EnsureExistsUsingPublicCreate2ReturnType>;

package/dist/types/dev/mint/AbstractMinter.d.ts

@@ -1,11 +1,12 @@
 import { type Address } from "viem";
-import { type GearboxSDK, SDKConstruct } from "../../sdk/index.js";
+import { type GearboxSDK, type ILogger, SDKConstruct } from "../../sdk/index.js";
 import type { AnvilClient } from "../createAnvilClient.js";
 import type { IMinter } from "./types.js";
 export default abstract class AbstractMinter extends SDKConstruct implements IMinter {
     protected readonly anvil: AnvilClient;
-    name: string;
-    constructor(sdk: GearboxSDK, anvil: AnvilClient);
+    protected readonly logger?: ILogger;
+    readonly name: string;
+    constructor(sdk: GearboxSDK, anvil: AnvilClient, name?: string);
     tryMint(token: Address, dest: Address, amount: bigint): Promise<bigint>;
     abstract mint(token: Address, dest: Address, amount: bigint): Promise<void>;
     protected getOwner(address: Address): Promise<Address>;

package/dist/types/dev/mint/DealMinter.d.ts

@@ -1,6 +1,9 @@
 import type { Address } from "viem";
+import type { GearboxSDK } from "../../sdk/index.js";
+import type { AnvilClient } from "../createAnvilClient.js";
 import AbstractMinter from "./AbstractMinter.js";
 import type { IMinter } from "./types.js";
 export declare class DealMinter extends AbstractMinter implements IMinter {
+    constructor(sdk: GearboxSDK, anvil: AnvilClient);
     mint(token: Address, dest: Address, amount: bigint): Promise<void>;
 }

package/dist/types/dev/mint/DirectMinter.d.ts

@@ -1,6 +1,9 @@
 import { type Address } from "viem";
+import type { GearboxSDK } from "../../sdk/index.js";
+import type { AnvilClient } from "../createAnvilClient.js";
 import AbstractMinter from "./AbstractMinter.js";
 import type { IMinter } from "./types.js";
 export declare class DirectMinter extends AbstractMinter implements IMinter {
+    constructor(sdk: GearboxSDK, anvil: AnvilClient);
     mint(token: Address, dest: Address, amount: bigint): Promise<void>;
 }

package/dist/types/dev/mint/TransferMinter.d.ts

@@ -1,6 +1,9 @@
 import { type Address } from "viem";
+import type { GearboxSDK } from "../../sdk/index.js";
+import type { AnvilClient } from "../createAnvilClient.js";
 import AbstractMinter from "./AbstractMinter.js";
 import type { IMinter } from "./types.js";
 export declare class TransferMinter extends AbstractMinter implements IMinter {
+    constructor(sdk: GearboxSDK, anvil: AnvilClient);
     mint(token: Address, dest: Address, amount: bigint): Promise<void>;
 }

package/dist/types/permissionless/bindings/address-provider.d.ts

@@ -1,8 +1,259 @@
-import { type Address, type Chain, type PublicClient, type Transport } from "viem";
-import { AddressProviderV310Contract } from "../../sdk/index.js";
-export declare class AddressProviderContract extends AddressProviderV310Contract {
-    constructor(addr: Address, client: PublicClient<Transport, Chain>);
+import { type Address, type PublicClient } from "viem";
+import { BaseContract } from "./base-contract.js";
+declare const abi: readonly [{
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "contractType";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "key";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "ver";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "getAddress";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "key";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "ver";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "getAddressOrRevert";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "getAllEntries";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "struct AddressProviderEntry[]";
+        readonly type: "tuple[]";
+        readonly components: readonly [{
+            readonly name: "key";
+            readonly internalType: "bytes32";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "ver";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }, {
+            readonly name: "value";
+            readonly internalType: "address";
+            readonly type: "address";
+        }];
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "getKeys";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "bytes32[]";
+        readonly type: "bytes32[]";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "key";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "majorVersion";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "getLatestMinorVersion";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "key";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "minorVersion";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "getLatestPatchVersion";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "key";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }];
+    readonly name: "getLatestVersion";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "key";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }];
+    readonly name: "getVersions";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256[]";
+        readonly type: "uint256[]";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "owner";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "key";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "value";
+        readonly internalType: "address";
+        readonly type: "address";
+    }, {
+        readonly name: "saveVersion";
+        readonly internalType: "bool";
+        readonly type: "bool";
+    }];
+    readonly name: "setAddress";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "version";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "event";
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly name: "key";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+        readonly indexed: true;
+    }, {
+        readonly name: "ver";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+        readonly indexed: true;
+    }, {
+        readonly name: "value";
+        readonly internalType: "address";
+        readonly type: "address";
+        readonly indexed: true;
+    }];
+    readonly name: "SetAddress";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [{
+        readonly name: "key";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "ver";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "AddressNotFoundException";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [{
+        readonly name: "caller";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly name: "CallerIsNotOwnerException";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [{
+        readonly name: "key";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "ver";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "InvalidVersionException";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [{
+        readonly name: "key";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }];
+    readonly name: "VersionNotFoundException";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [{
+        readonly name: "key";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }];
+    readonly name: "ZeroAddressException";
+}];
+export declare class AddressProviderContract extends BaseContract<typeof abi> {
+    constructor(address: Address, client: PublicClient);
     getAddressOrRevert(key: string, version?: bigint): Promise<Address>;
     getLatestVersionAddress(key: string): Promise<Address>;
     getLatestVersion(key: string): Promise<bigint>;
 }
+export {};

package/dist/types/permissionless/bindings/base-contract.d.ts

@@ -0,0 +1,23 @@
+import { type Abi, type Address, type Client, type ContractEventArgs, type ContractEventName, type ContractFunctionName, type DecodeFunctionDataReturnType, type EncodeFunctionDataParameters, type GetContractEventsReturnType, type GetContractReturnType, type Hex, type PublicClient } from "viem";
+import type { RawTx } from "../../sdk/types/index.js";
+import type { CrossChainCall, ParsedCall } from "../core/proposal.js";
+export declare class BaseContract<const abi extends Abi | readonly unknown[]> {
+    readonly abi: abi;
+    readonly address: Address;
+    readonly name: string;
+    protected static register: Record<Address, BaseContract<any>>;
+    protected contract: GetContractReturnType<abi, Client, Address>;
+    readonly client: PublicClient;
+    constructor(abi: abi, address: Address, client: PublicClient, name: string);
+    static parseCall(call: CrossChainCall): ParsedCall;
+    static parse(address: Address, calldata: Hex): ParsedCall;
+    parseFunctionData(calldata: Hex): ParsedCall;
+    protected wrapParseCall(params: DecodeFunctionDataReturnType<abi>, parsedParams: Record<string, string>): ParsedCall;
+    parseFunctionParams(_params: DecodeFunctionDataReturnType<abi>): ParsedCall | undefined;
+    createRawTx<functionName extends ContractFunctionName<abi> | undefined = undefined>(parameters: Omit<EncodeFunctionDataParameters<abi, functionName>, "abi"> & {
+        description?: string;
+    }): RawTx;
+    protected stringifyParsedCall(parsedCall: ParsedCall): string;
+    getEvents<EventName extends ContractEventName<abi>>(eventName: EventName, fromBlock: bigint, toBlock: bigint, args?: ContractEventArgs<abi, EventName extends ContractEventName<abi> ? EventName : ContractEventName<abi>> | undefined, chunkSize?: number): Promise<GetContractEventsReturnType<abi, EventName, undefined, bigint, bigint>>;
+    getContract(): GetContractReturnType<abi, Client, Address>;
+}

package/dist/types/permissionless/bindings/bytecode-repository.d.ts

@@ -1,8 +1,9 @@
-import { type Address, type Chain, type DecodeFunctionDataReturnType, type Hex, type Log, type PublicClient, type Transport, type WalletClient } from "viem";
-import type { RawTx } from "../../sdk/index.js";
-import { BaseContract, type ParsedCallArgs } from "../../sdk/index.js";
+import { type Address, type DecodeFunctionDataReturnType, type Hex, type Log, type PublicClient, type WalletClient } from "viem";
+import type { RawTx } from "../../sdk/types/index.js";
 import type { Auditor } from "../core/auditor.js";
 import type { AuditEvent, Bytecode, DeploymentExtended } from "../core/bytecode.js";
+import type { ParsedCall } from "../core/proposal.js";
+import { BaseContract } from "./base-contract.js";
 declare const abi: readonly [{
     readonly type: "function";
     readonly inputs: readonly [];
@@ -1150,7 +1151,7 @@ interface ComputeAddressArgs {
     owner: Address;
 }
 export declare class BytecodeRepositoryContract extends BaseContract<typeof abi> {
-    constructor(addr: Address, client: PublicClient<Transport, Chain>);
+    constructor(address: Address, client: PublicClient);
     getBytecodeByHash(hash: `0x${string}`): Promise<{
         contractType: `0x${string}`;
         version: bigint;
@@ -1190,7 +1191,7 @@ export declare class BytecodeRepositoryContract extends BaseContract<typeof abi>
         blockNumber: number;
     }>>;
     getUploadUpdates(fromBlock: bigint, toBlock: bigint): Promise<Omit<Bytecode, "uploadedAt">[]>;
-    protected parseFunctionParams(params: DecodeFunctionDataReturnType<typeof abi>): ParsedCallArgs;
+    parseFunctionParams(params: DecodeFunctionDataReturnType<typeof abi>): ParsedCall | undefined;
     signBytecodeHash(bytecodeHash: Hex, auditor: Address, reportUrl: string, signature: Hex, sponsor: WalletClient): Promise<`0x${string}`>;
     signBytecodeHashTx(bytecodeHash: Hex, auditor: Address, reportUrl: string, signature: Hex): RawTx;
     recoverAuditorSignature(bytecodeHash: Hex, auditor: Address, reportUrl: string, signature: Hex): Promise<Address>;

package/dist/types/permissionless/bindings/compressors/token-compressor.d.ts

@@ -1,5 +1,5 @@
-import { type Address, type Chain, type PublicClient, type Transport } from "viem";
-import { BaseContract } from "../../../sdk/index.js";
+import { type Address, type PublicClient } from "viem";
+import { BaseContract } from "../base-contract.js";
 declare const abi: readonly [{
     readonly type: "constructor";
     readonly inputs: readonly [{
@@ -102,7 +102,7 @@ declare const abi: readonly [{
     readonly stateMutability: "view";
 }];
 export declare class TokenCompressorContract extends BaseContract<typeof abi> {
-    constructor(addr: Address, client: PublicClient<Transport, Chain>);
+    constructor(address: Address, client: PublicClient);
     getTokenInfo(token: Address): Promise<{
         name: string;
         symbol: string;