@gearbox-protocol/sdk 11.11.0-next.2 → 11.11.0

package/dist/esm/permissionless/bindings/bytecode-repository.js

@@ -6,13 +6,13 @@ import {
   stringToHex
 } from "viem";
 import { iBytecodeRepositoryAbi } from "../../abi/310/iBytecodeRepository.js";
-import { BaseContract } from "../../sdk/index.js";
 import { normalizeSignature } from "../utils/index.js";
 import { BYTECODE_REPOSITORY } from "../utils/literals.js";
+import { BaseContract } from "./base-contract.js";
 const abi = iBytecodeRepositoryAbi;
 class BytecodeRepositoryContract extends BaseContract {
-  constructor(addr, client) {
-    super({ client }, { abi, addr, name: "BytecodeRepository" });
+  constructor(address, client) {
+    super(abi, address, client, "BytecodeRepository");
   }
   async getBytecodeByHash(hash) {
     return await this.contract.read.getBytecode([hash]);
@@ -189,67 +189,69 @@ class BytecodeRepositoryContract extends BaseContract {
   }
   parseFunctionParams(params) {
     switch (params.functionName) {
-      // TODO: simple array -> map can be removed, since this is what super.parseFunctionParams does
       case "allowSystemContract": {
         const [bytecodeHash] = params.args;
-        return {
+        return this.wrapParseCall(params, {
           bytecodeHash
-        };
+        });
       }
       case "addAuditor": {
         const [auditor, name] = params.args;
-        return { auditor, name };
+        return this.wrapParseCall(params, {
+          auditor,
+          name
+        });
       }
       case "removeAuditor": {
         const [auditor] = params.args;
-        return {
+        return this.wrapParseCall(params, {
           auditor
-        };
+        });
       }
       case "addPublicDomain": {
         const [domain] = params.args;
-        return {
+        return this.wrapParseCall(params, {
           domain: hexToString(domain, { size: 32 })
-        };
+        });
       }
       case "removePublicContractType": {
         const [contractType] = params.args;
-        return {
+        return this.wrapParseCall(params, {
           contractType: hexToString(contractType, { size: 32 })
-        };
+        });
       }
       case "forbidInitCode": {
         const [bytecodeHash] = params.args;
-        return {
+        return this.wrapParseCall(params, {
           bytecodeHash
-        };
+        });
       }
       case "setTokenSpecificPostfix": {
         const [token, postfix] = params.args;
-        return {
+        return this.wrapParseCall(params, {
           token,
           postfix: hexToString(postfix, { size: 32 })
-        };
+        });
       }
       case "uploadBytecode": {
         const [uploadData] = params.args;
-        return {
+        return this.wrapParseCall(params, {
           contractType: hexToString(uploadData.contractType, { size: 32 }),
           version: uploadData.version.toString(),
           initCode: uploadData.initCode,
           author: uploadData.author,
           source: uploadData.source,
           authorSignature: uploadData.authorSignature
-        };
+        });
       }
       case "submitAuditReport": {
         const [bytecodeHash, { auditor, reportUrl, signature }] = params.args;
-        return {
+        return this.wrapParseCall(params, {
           bytecodeHash,
           auditor,
           reportUrl,
           signature
-        };
+        });
       }
       // TODO: add all functions here!
       // case "deployContract": {
@@ -270,7 +272,7 @@ class BytecodeRepositoryContract extends BaseContract {
       //   });
       // }
       default:
-        return super.parseFunctionParams(params);
+        return void 0;
     }
   }
   async signBytecodeHash(bytecodeHash, auditor, reportUrl, signature, sponsor) {

package/dist/esm/permissionless/bindings/compressors/token-compressor.js

@@ -3,11 +3,11 @@ import {
   parseAbi
 } from "viem";
 import { tokenCompressorAbi } from "../../../abi/compressors/tokenCompressor.js";
-import { BaseContract } from "../../../sdk/index.js";
+import { BaseContract } from "../base-contract.js";
 const abi = tokenCompressorAbi;
 class TokenCompressorContract extends BaseContract {
-  constructor(addr, client) {
-    super({ client }, { abi, addr, name: "TokenCompressor" });
+  constructor(address, client) {
+    super(abi, address, client, "TokenCompressor");
   }
   async getTokenInfo(token) {
     const result = await this.contract.read.getTokenInfo([token]);

package/dist/esm/permissionless/bindings/compressors/withdrawal-compressor.js

@@ -2,11 +2,11 @@ import {
   hexToString
 } from "viem";
 import { withdrawalCompressorAbi } from "../../../abi/compressors/withdrawalCompressor.js";
-import { BaseContract } from "../../../sdk/index.js";
+import { BaseContract } from "../base-contract.js";
 const abi = withdrawalCompressorAbi;
 class WithdrawalCompressorContract extends BaseContract {
-  constructor(addr, client) {
-    super({ client }, { abi, addr, name: "WithdrawalCompressor" });
+  constructor(address, client) {
+    super(abi, address, client, "RoutingManager");
   }
   parseFunctionParams(params) {
     const { functionName, args } = params;
@@ -14,16 +14,22 @@ class WithdrawalCompressorContract extends BaseContract {
       case "setWithdrawableTypeToCompressorType": {
         const [withdrawableType, compressorType] = args;
         return {
-          withdrawableType: hexToString(withdrawableType, {
-            size: 32
-          }),
-          compressorType: hexToString(compressorType, {
-            size: 32
-          })
+          chainId: 0,
+          target: this.address,
+          label: this.name,
+          functionName,
+          args: {
+            withdrawableType: hexToString(withdrawableType, {
+              size: 32
+            }),
+            compressorType: hexToString(compressorType, {
+              size: 32
+            })
+          }
         };
       }
       default:
-        return super.parseFunctionParams(params);
+        return void 0;
     }
   }
 }

package/dist/esm/permissionless/bindings/cross-chain-multisig.js

@@ -5,19 +5,17 @@ import {
   zeroAddress
 } from "viem";
 import { crossChainMultisigAbi } from "../../abi/310/crossChainMultisig.js";
-import {
-  BaseContract,
-  json_stringify
-} from "../../sdk/index.js";
+import { json_stringify } from "../../sdk/utils/index.js";
 import { Addresses } from "../deployment/addresses.js";
 import { normalizeSignature } from "../utils/index.js";
 import { CROSS_CHAIN_MULTISIG } from "../utils/literals.js";
+import { BaseContract } from "./base-contract.js";
 import { InstanceManagerContract } from "./instance-manager.js";
 import { MarketConfiguratorFactoryContract } from "./market-configurator-factory.js";
 const abi = crossChainMultisigAbi;
 class CrossChainMultisigContract extends BaseContract {
-  constructor(addr, client) {
-    super({ client }, { abi, addr, name: "CrossChainMultisig" });
+  constructor(address, client) {
+    super(abi, address, client, "CrossChainMultisig");
   }
   async getExecutedBatches(fromBlock, toBlock) {
     const events = await this.getEvents("ExecuteBatch", fromBlock, toBlock);
@@ -68,9 +66,7 @@ class CrossChainMultisigContract extends BaseContract {
       transactionHash,
       blockNumber,
       hash: proposalHash,
-      parsedCalls: calls.map(
-        (c) => this.register.parseFunctionData(c.target, c.callData)
-      ),
+      parsedCalls: calls.map((c) => BaseContract.parseCall(c)),
       signatures
     };
   }
@@ -162,7 +158,7 @@ class CrossChainMultisigContract extends BaseContract {
   async getSigners() {
     return [...await this.contract.read.getSigners()];
   }
-  #decodeFunctionData(target, calldata) {
+  decodeFunctionData(target, calldata) {
     switch (target.toLowerCase()) {
       case this.address.toLowerCase(): {
         return this.parseFunctionData(calldata);
@@ -192,38 +188,38 @@ class CrossChainMultisigContract extends BaseContract {
     switch (params.functionName) {
       case "addSigner": {
         const [signer] = params.args;
-        return {
+        return this.wrapParseCall(params, {
           signer
-        };
+        });
       }
       case "removeSigner": {
         const [signer] = params.args;
-        return {
+        return this.wrapParseCall(params, {
           signer
-        };
+        });
       }
       case "setConfirmationThreshold": {
         const [threshold] = params.args;
-        return {
+        return this.wrapParseCall(params, {
           threshold: threshold.toString()
-        };
+        });
       }
       case "submitBatch": {
         const [name, calls, prevHash] = params.args;
-        return {
+        return this.wrapParseCall(params, {
           name,
           calls: json_stringify(
             calls.map(({ chainId, target, callData }) => ({
-              ...this.#decodeFunctionData(target, callData),
+              ...this.decodeFunctionData(target, callData),
               chainId: Number(chainId),
               target
             }))
           ),
           prevHash
-        };
+        });
       }
       default:
-        return super.parseFunctionParams(params);
+        return void 0;
     }
   }
   async validateProposalSignature(proposalHash, signature) {

package/dist/esm/permissionless/bindings/factory/abstract-factory.js

@@ -1,8 +1,5 @@
-import {
-  decodeFunctionData
-} from "viem";
-import { functionArgsToMap } from "../../../sdk/index.js";
 import { createCallData } from "../../core/raw-tx.js";
+import { decodeFunctionWithNamedArgs } from "../../utils/abi-decoder.js";
 class AbstractFactory {
   abi;
   constructor(abi) {
@@ -18,13 +15,11 @@ class AbstractFactory {
    * @returns Decoded function name and arguments, or null if decoding fails
    */
   decodeConfig(calldata) {
-    const decoded = decodeFunctionData({
-      abi: this.abi,
-      data: calldata
-    });
+    const decoded = decodeFunctionWithNamedArgs(this.abi, calldata);
+    if (!decoded) return null;
     return {
       functionName: decoded.functionName,
-      args: functionArgsToMap(this.abi, decoded.functionName, decoded.args)
+      args: decoded.args
     };
   }
 }

package/dist/esm/permissionless/bindings/governance/batches-chain.js

@@ -1,9 +1,9 @@
 import { batchesChainAbi } from "../../../abi/governance/batchesChain.js";
-import { BaseContract } from "../../../sdk/index.js";
+import { BaseContract } from "../base-contract.js";
 const abi = batchesChainAbi;
 class BatchesChainContract extends BaseContract {
-  constructor(addr, client) {
-    super({ client }, { abi, addr, name: "BatchesChain" });
+  constructor(address, client) {
+    super(abi, address, client, "BatchesChain");
   }
   createBatchOrderingTx(prevHash) {
     return this.createRawTx({

package/dist/esm/permissionless/bindings/governance/governor.js

@@ -6,16 +6,17 @@ import {
 } from "viem";
 import { formatAbiItem } from "viem/utils";
 import { governorAbi } from "../../../abi/governance/governor.js";
-import { BaseContract, json_stringify } from "../../../sdk/index.js";
+import { json_stringify } from "../../../sdk/utils/index.js";
 import { formatTimestamp } from "../../utils/index.js";
+import { BaseContract } from "../base-contract.js";
 import { MarketConfiguratorContract } from "../market-configurator.js";
 import { TreasurySplitterContract } from "../treasury-splitter.js";
 import { BatchesChainContract } from "./batches-chain.js";
 const abi = governorAbi;
 class GovernorContract extends BaseContract {
   batchesChainContract;
-  constructor(addr, client) {
-    super({ client }, { abi, addr, name: "Governor" });
+  constructor(address, client) {
+    super(abi, address, client, "Governor");
     this.batchesChainContract = new BatchesChainContract(
       "0x59b2fd348e4Ade84ffEfDaf5fcdDa7276c8C5041",
       client
@@ -120,7 +121,7 @@ class GovernorContract extends BaseContract {
       ).join("\n")})`
     });
   }
-  #decodeFunctionData(target, calldata) {
+  decodeFunctionData(target, calldata) {
     switch (target.toLowerCase()) {
       case this.address.toLowerCase(): {
         return this.parseFunctionData(calldata);
@@ -159,44 +160,62 @@ class GovernorContract extends BaseContract {
       case "startBatch": {
         const [eta] = args;
         return {
-          eta: formatTimestamp(Number(eta))
+          chainId: 0,
+          target: this.address,
+          label: this.name,
+          functionName,
+          args: {
+            eta: formatTimestamp(Number(eta))
+          }
         };
       }
       case "queueTransaction": {
         const [target, value, signature, data, eta] = args;
         const calldata = keccak256(toBytes(signature)).slice(0, 10) + data.slice(2);
         return {
-          target,
-          value: formatEther(value),
-          signature,
-          data: json_stringify(
-            this.#decodeFunctionData(target, calldata)?.args ?? calldata
-          ),
-          eta: formatTimestamp(Number(eta))
+          chainId: 0,
+          target: this.address,
+          label: this.name,
+          functionName,
+          args: {
+            target,
+            value: formatEther(value),
+            signature,
+            data: json_stringify(
+              this.decodeFunctionData(target, calldata)?.args ?? calldata
+            ),
+            eta: formatTimestamp(Number(eta))
+          }
         };
       }
       case "executeBatch": {
         const [txs] = args;
         return {
-          txs: json_stringify(
-            txs.map((tx) => {
-              const { target, value, signature, data, eta } = tx;
-              const calldata = keccak256(toBytes(signature)).slice(0, 10) + data.slice(2);
-              return {
-                target,
-                value: formatEther(value),
-                signature,
-                data: json_stringify(
-                  this.#decodeFunctionData(target, calldata)?.args ?? calldata
-                ),
-                eta: formatTimestamp(Number(eta))
-              };
-            })
-          )
+          chainId: 0,
+          target: this.address,
+          label: this.name,
+          functionName,
+          args: {
+            txs: json_stringify(
+              txs.map((tx) => {
+                const { target, value, signature, data, eta } = tx;
+                const calldata = keccak256(toBytes(signature)).slice(0, 10) + data.slice(2);
+                return {
+                  target,
+                  value: formatEther(value),
+                  signature,
+                  data: json_stringify(
+                    this.decodeFunctionData(target, calldata)?.args ?? calldata
+                  ),
+                  eta: formatTimestamp(Number(eta))
+                };
+              })
+            )
+          }
         };
       }
       default:
-        return super.parseFunctionParams(params);
+        return void 0;
     }
   }
 }

package/dist/esm/permissionless/bindings/governance/timelock.js

@@ -1,8 +1,8 @@
 import { iTimeLockAbi } from "../../../abi/governance/iTimeLock.js";
-import { BaseContract } from "../../../sdk/index.js";
+import { BaseContract } from "../base-contract.js";
 class TimeLockContract extends BaseContract {
-  constructor(addr, client) {
-    super({ client }, { abi: iTimeLockAbi, addr, name: "TimeLock" });
+  constructor(address, client) {
+    super(iTimeLockAbi, address, client, "TimeLock");
   }
   async admin() {
     const admin = await this.client.readContract({

package/dist/esm/permissionless/bindings/index.js

@@ -1,4 +1,5 @@
 export * from "./address-provider.js";
+export * from "./base-contract.js";
 export * from "./bytecode-repository.js";
 export * from "./compressors/index.js";
 export * from "./cross-chain-multisig.js";

package/dist/esm/permissionless/bindings/instance-manager.js

@@ -10,22 +10,20 @@ import { mellow4626WorkerAbi } from "../../abi/router/mellow4626Worker.js";
 import { pendleRouterWorkerAbi } from "../../abi/router/pendleRouterWorker.js";
 import { uniswapV3WorkerAbi } from "../../abi/router/uniswapV3Worker.js";
 import { uniswapV4WorkerAbi } from "../../abi/router/uniswapV4Worker.js";
-import {
-  BaseContract,
-  json_stringify
-} from "../../sdk/index.js";
+import { json_stringify } from "../../sdk/utils/index.js";
 import { Addresses } from "../deployment/addresses.js";
+import { BaseContract } from "./base-contract.js";
 import { WithdrawalCompressorContract } from "./compressors/index.js";
 import { PriceFeedStoreContract } from "./price-feed-store.js";
 import { RoutingManagerContract } from "./router/index.js";
 import { TreasurySplitterContract } from "./treasury-splitter.js";
 const abi = instanceManagerAbi;
 class InstanceManagerContract extends BaseContract {
-  constructor(addr, client) {
-    super({ client }, { abi, addr, name: "InstanceManager" });
+  constructor(address, client) {
+    super(abi, address, client, "InstanceManager");
   }
   // TODO:
-  #decodeFunctionData(target, calldata) {
+  decodeFunctionData(target, calldata) {
     switch (target.toLowerCase()) {
       case this.address.toLowerCase(): {
         return this.parseFunctionData(calldata);
@@ -38,8 +36,10 @@ class InstanceManagerContract extends BaseContract {
         try {
           let parsedData;
           const router = new BaseContract(
-            { client: this.client },
-            { abi: gearboxRouterAbi, addr: target, name: "GearboxRouter" }
+            gearboxRouterAbi,
+            target,
+            this.client,
+            "GearboxRouter"
           );
           parsedData = router.parseFunctionData(calldata);
           if (!parsedData.functionName.startsWith("Unknown function")) {
@@ -54,56 +54,60 @@ class InstanceManagerContract extends BaseContract {
             return parsedData;
           }
           const camelotV3Worker = new BaseContract(
-            { client: this.client },
-            { abi: camelotV3WorkerAbi, addr: target, name: "CamelotV3Worker" }
+            camelotV3WorkerAbi,
+            target,
+            this.client,
+            "CamelotV3Worker"
           );
           parsedData = camelotV3Worker.parseFunctionData(calldata);
           if (!parsedData.functionName.startsWith("Unknown function")) {
             return parsedData;
           }
           const erc4626Worker = new BaseContract(
-            { client: this.client },
-            { abi: erc4626WorkerAbi, addr: target, name: "ERC4626Worker" }
+            erc4626WorkerAbi,
+            target,
+            this.client,
+            "ERC4626Worker"
           );
           parsedData = erc4626Worker.parseFunctionData(calldata);
           if (!parsedData.functionName.startsWith("Unknown function")) {
             return parsedData;
           }
           const mellow4626Worker = new BaseContract(
-            { client: this.client },
-            {
-              abi: mellow4626WorkerAbi,
-              addr: target,
-              name: "Mellow4626Worker"
-            }
+            mellow4626WorkerAbi,
+            target,
+            this.client,
+            "Mellow4626Worker"
           );
           parsedData = mellow4626Worker.parseFunctionData(calldata);
           if (!parsedData.functionName.startsWith("Unknown function")) {
             return parsedData;
           }
           const pendleRouterWorker = new BaseContract(
-            { client: this.client },
-            {
-              abi: pendleRouterWorkerAbi,
-              addr: target,
-              name: "PendleRouterWorker"
-            }
+            pendleRouterWorkerAbi,
+            target,
+            this.client,
+            "PendleRouterWorker"
           );
           parsedData = pendleRouterWorker.parseFunctionData(calldata);
           if (!parsedData.functionName.startsWith("Unknown function")) {
             return parsedData;
           }
           const uniswapV3Worker = new BaseContract(
-            { client: this.client },
-            { abi: uniswapV3WorkerAbi, addr: target, name: "UniswapV3Worker" }
+            uniswapV3WorkerAbi,
+            target,
+            this.client,
+            "UniswapV3Worker"
           );
           parsedData = uniswapV3Worker.parseFunctionData(calldata);
           if (!parsedData.functionName.startsWith("Unknown function")) {
             return parsedData;
           }
           const uniswapV4Worker = new BaseContract(
-            { client: this.client },
-            { abi: uniswapV4WorkerAbi, addr: target, name: "UniswapV4Worker" }
+            uniswapV4WorkerAbi,
+            target,
+            this.client,
+            "UniswapV4Worker"
           );
           parsedData = uniswapV4Worker.parseFunctionData(calldata);
           if (!parsedData.functionName.startsWith("Unknown function")) {
@@ -128,23 +132,29 @@ class InstanceManagerContract extends BaseContract {
     switch (params.functionName) {
       case "configureGlobal": {
         const [target, data] = params.args;
-        const nestedCall = this.register.parseFunctionData(target, data);
+        const nestedCall = BaseContract.parse(target, data);
         return {
-          ...nestedCall.args,
+          ...nestedCall,
           label: `${nestedCall.label} via instanceManager`,
           target: this.address
         };
       }
       case "configureLocal": {
         const [target, data] = params.args;
-        const decoded = this.#decodeFunctionData(target, data);
-        return decoded ? {
-          target,
-          functionName: decoded.functionName,
-          data: json_stringify(decoded.args)
-        } : {
-          target,
-          data
+        const decoded = this.decodeFunctionData(target, data);
+        return {
+          chainId: 0,
+          target: this.address,
+          label: this.name,
+          functionName: params.functionName,
+          args: decoded ? {
+            target,
+            functionName: decoded.functionName,
+            data: json_stringify(decoded.args)
+          } : {
+            target,
+            data
+          }
         };
       }
       case "configureTreasury": {
@@ -162,42 +172,48 @@ class InstanceManagerContract extends BaseContract {
         } catch {
           decoded = void 0;
         }
-        return decoded ? {
-          target,
-          functionName: decoded.functionName,
-          data: json_stringify(decoded.args)
-        } : {
-          target,
-          data
+        return {
+          chainId: 0,
+          target: this.address,
+          label: this.name,
+          functionName: params.functionName,
+          args: decoded ? {
+            target,
+            functionName: decoded.functionName,
+            data: json_stringify(decoded.args)
+          } : {
+            target,
+            data
+          }
         };
       }
       case "activate": {
         const [instanceOwner, treasury, weth, gear] = params.args;
-        return {
+        return this.wrapParseCall(params, {
           instanceOwner,
           treasury,
           weth,
           gear
-        };
+        });
       }
       case "deploySystemContract": {
         const [contractType, version, saveVersion] = params.args;
-        return {
+        return this.wrapParseCall(params, {
           contractType: hexToString(contractType, { size: 32 }),
           version: version.toString(),
           saveVersion: saveVersion ? "true" : "false"
-        };
+        });
       }
       case "setGlobalAddress": {
         const [key, address, saveVersion] = params.args;
-        return {
+        return this.wrapParseCall(params, {
           key,
           address,
           saveVersion: saveVersion ? "true" : "false"
-        };
+        });
       }
       default:
-        return super.parseFunctionParams(params);
+        return void 0;
     }
   }
   async isActivated() {