@bgd-labs/toolbox 0.0.2 → 0.0.4

package/dist/index.js

@@ -30,14 +30,17 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  EVENT_DB: () => EVENT_DB,
   HALF_RAY: () => HALF_RAY,
   HALF_WAD: () => HALF_WAD,
   HUMAN_READABLE_PAYLOAD_STATE: () => HUMAN_READABLE_PAYLOAD_STATE,
   HUMAN_READABLE_PROPOSAL_STATE: () => HUMAN_READABLE_PROPOSAL_STATE,
   LTV_PRECISION: () => LTV_PRECISION,
   PayloadState: () => PayloadState,
+  ProposalState: () => ProposalState,
   RAY: () => RAY,
   SECONDS_PER_YEAR: () => SECONDS_PER_YEAR,
+  SelfdestuctCheckState: () => SelfdestuctCheckState,
   WAD: () => WAD,
   WAD_RAY_RATIO: () => WAD_RAY_RATIO,
   bitmapToIndexes: () => bitmapToIndexes,
@@ -45,12 +48,16 @@ __export(index_exports, {
   calculateCompoundedInterest: () => calculateCompoundedInterest,
   calculateHealthFactorFromBalances: () => calculateHealthFactorFromBalances,
   calculateLinearInterest: () => calculateLinearInterest,
+  checkForSelfdestruct: () => checkForSelfdestruct,
   decodeReserveConfiguration: () => decodeReserveConfiguration,
   decodeReserveConfigurationV2: () => decodeReserveConfigurationV2,
   decodeUserConfiguration: () => decodeUserConfiguration,
   diffCode: () => diffCode,
+  diffFoundryStorageLayout: () => diffFoundryStorageLayout,
   erc1967_AdminSlot: () => erc1967_AdminSlot,
   erc1967_ImplementationSlot: () => erc1967_ImplementationSlot,
+  foundry_getStandardJsonInput: () => foundry_getStandardJsonInput,
+  foundry_getStorageLayout: () => foundry_getStorageLayout,
   getBits: () => getBits,
   getCurrentDebtBalance: () => getCurrentDebtBalance,
   getCurrentLiquidityBalance: () => getCurrentLiquidityBalance,
@@ -58,18 +65,26 @@ __export(index_exports, {
   getGovernance: () => getGovernance,
   getMarketReferenceCurrencyAndUsdBalance: () => getMarketReferenceCurrencyAndUsdBalance,
   getNonFinalizedPayloads: () => getNonFinalizedPayloads,
+  getNonFinalizedProposals: () => getNonFinalizedProposals,
   getNormalizedDebt: () => getNormalizedDebt,
   getNormalizedIncome: () => getNormalizedIncome,
   getPayloadsController: () => getPayloadsController,
   getSourceCode: () => getSourceCode,
+  isPayloadFinal: () => isPayloadFinal,
+  isProposalFinal: () => isProposalFinal,
   makePayloadExecutableOnTestClient: () => makePayloadExecutableOnTestClient,
   makeProposalExecutableOnTestClient: () => makeProposalExecutableOnTestClient,
-  parseApiSourceCode: () => parseApiSourceCode,
+  parseEtherscanStyleSourceCode: () => parseEtherscanStyleSourceCode,
+  parseLogs: () => parseLogs,
   rayDiv: () => rayDiv,
   rayMul: () => rayMul,
   rayToWad: () => rayToWad,
+  renderTenderlyReport: () => renderTenderlyReport,
   setBits: () => setBits,
   tenderly_createVnet: () => tenderly_createVnet,
+  tenderly_deleteVnet: () => tenderly_deleteVnet,
+  tenderly_getVnet: () => tenderly_getVnet,
+  tenderly_simVnet: () => tenderly_simVnet,
   wadDiv: () => wadDiv,
   wadToRay: () => wadToRay
 });
@@ -1954,15 +1969,17 @@ async function makePayloadExecutableOnTestClient(client, payloadsController, pay
     )
   });
 }
+function isPayloadFinal(state) {
+  return ![2 /* Queued */, 1 /* Created */].includes(state);
+}
 async function getNonFinalizedPayloads(client, payloadsController) {
   const controllerContract = getPayloadsController(client, payloadsController);
   const payloadsCount = await controllerContract.read.getPayloadsCount();
   const nonFinalPayloads = [];
-  for (const payloadId of [...Array(Number(payloadsCount)).keys()].reverse()) {
+  for (let payloadId = payloadsCount - 1; payloadId != 0; payloadId--) {
     const maxRange = (35 + 10 + 7) * 24 * 60 * 60;
     const payload = await controllerContract.read.getPayloadById([payloadId]);
-    if ([2 /* Queued */, 1 /* Created */].includes(payload.state))
-      nonFinalPayloads.push(payloadId);
+    if (!isPayloadFinal(payload.state)) nonFinalPayloads.push(payloadId);
     if (payload.createdAt < Date.now() / 1e3 - maxRange) break;
   }
   return nonFinalPayloads;
@@ -1971,15 +1988,26 @@ async function getNonFinalizedPayloads(client, payloadsController) {
 // src/aave/governance/governance.ts
 var import_viem3 = require("viem");
 var import_actions2 = require("viem/actions");
+var ProposalState = /* @__PURE__ */ ((ProposalState2) => {
+  ProposalState2[ProposalState2["Null"] = 0] = "Null";
+  ProposalState2[ProposalState2["Created"] = 1] = "Created";
+  ProposalState2[ProposalState2["Active"] = 2] = "Active";
+  ProposalState2[ProposalState2["Queued"] = 3] = "Queued";
+  ProposalState2[ProposalState2["Executed"] = 4] = "Executed";
+  ProposalState2[ProposalState2["Failed"] = 5] = "Failed";
+  ProposalState2[ProposalState2["Cancelled"] = 6] = "Cancelled";
+  ProposalState2[ProposalState2["Expired"] = 7] = "Expired";
+  return ProposalState2;
+})(ProposalState || {});
 var HUMAN_READABLE_PROPOSAL_STATE = {
-  [ProposalState.Null]: "Null",
-  [ProposalState.Created]: "Created",
-  [ProposalState.Active]: "Active",
-  [ProposalState.Queued]: "Queued",
-  [ProposalState.Executed]: "Executed",
-  [ProposalState.Failed]: "Failed",
-  [ProposalState.Cancelled]: "Cancelled",
-  [ProposalState.Expired]: "Expired"
+  [0 /* Null */]: "Null",
+  [1 /* Created */]: "Created",
+  [2 /* Active */]: "Active",
+  [3 /* Queued */]: "Queued",
+  [4 /* Executed */]: "Executed",
+  [5 /* Failed */]: "Failed",
+  [6 /* Cancelled */]: "Cancelled",
+  [7 /* Expired */]: "Expired"
 };
 function getGovernance(client, address) {
   return (0, import_viem3.getContract)({
@@ -2000,7 +2028,7 @@ async function makeProposalExecutableOnTestClient(client, governance, proposalId
     manipulatedStorage,
     0n,
     8n,
-    ProposalState.Queued
+    3 /* Queued */
   );
   manipulatedStorage = setBits(
     manipulatedStorage,
@@ -2016,6 +2044,24 @@ async function makeProposalExecutableOnTestClient(client, governance, proposalId
     value: (0, import_viem3.toHex)(manipulatedStorage, { size: 32 })
   });
 }
+function isProposalFinal(state) {
+  return ![
+    3 /* Queued */,
+    1 /* Created */,
+    2 /* Active */
+  ].includes(state);
+}
+async function getNonFinalizedProposals(client, governanceAddress) {
+  const goverannceContract = getGovernance(client, governanceAddress);
+  const proposalsCount = await goverannceContract.read.getProposalsCount();
+  const nonFinalProposals = [];
+  for (let proposalId = proposalsCount - 1n; proposalId != 0n; proposalId--) {
+    const proposal = await goverannceContract.read.getProposal([proposalId]);
+    if (isProposalFinal(proposal.state)) nonFinalProposals.push(proposalId);
+    if (proposal.creationTime < Date.now() / 1e3 - 2592e3) break;
+  }
+  return nonFinalProposals;
+}
 
 // src/ecosystem/generated/etherscanExplorers.ts
 var etherscanExplorers = {
@@ -2910,7 +2956,7 @@ async function getSourceCode(params) {
   }
   return result[0];
 }
-function parseApiSourceCode(sourceCode) {
+function parseEtherscanStyleSourceCode(sourceCode) {
   if (sourceCode.startsWith("{{") && sourceCode.endsWith("}}")) {
     sourceCode = sourceCode.substring(1, sourceCode.length - 1);
   }
@@ -2920,12 +2966,51 @@ function parseApiSourceCode(sourceCode) {
 // src/ecosystem/tenderly.ts
 var import_viem4 = require("viem");
 var TENDERLY_BASE_URL = "https://api.tenderly.co/api/v1";
+async function tenderly_deleteVnet(vnetId, { accountSlug, projectSlug, accessToken }) {
+  return fetch(
+    `${TENDERLY_BASE_URL}/account/${accountSlug}/project/${projectSlug}/vnets/${vnetId}`,
+    {
+      method: "DELETE",
+      headers: new Headers({
+        "Content-Type": "application/json",
+        "X-Access-Key": accessToken
+      })
+    }
+  );
+}
+async function tenderly_simVnet(vnetId, { accountSlug, projectSlug, accessToken }, body) {
+  return (await fetch(
+    // Note: this is subject to change and currently uses the internal api of tenderly
+    `${TENDERLY_BASE_URL}/account/${accountSlug}/project/${projectSlug}/testnet/${vnetId}/simulate`,
+    {
+      method: "POST",
+      body: JSON.stringify(body),
+      headers: new Headers({
+        "Content-Type": "application/json",
+        "X-Access-Key": accessToken
+      })
+    }
+  )).json();
+}
+async function tenderly_getVnet(slug, { accountSlug, projectSlug, accessToken }) {
+  return (await fetch(
+    `${TENDERLY_BASE_URL}/account/${accountSlug}/project/${projectSlug}/vnets?match_field=slug&match_type=prefix&keywords=${slug}`,
+    {
+      method: "GET",
+      headers: new Headers({
+        "Content-Type": "application/json",
+        "X-Access-Key": accessToken
+      })
+    }
+  )).json();
+}
 async function tenderly_createVnet({
   slug,
   displayName,
   baseChainId,
   forkChainId,
-  blockNumber
+  blockNumber,
+  force
 }, { accessToken, accountSlug, projectSlug }) {
   if (!accessToken) throw new Error("Tenderly access token not provided");
   if (!accountSlug) throw new Error("Tenderly account slug not provided");
@@ -2950,79 +3035,137 @@ async function tenderly_createVnet({
       verification_visibility: "bytecode"
     }
   };
-  const response = await fetch(
-    `${TENDERLY_BASE_URL}/account/${accountSlug}/project/${projectSlug}/vnets`,
-    {
-      method: "POST",
-      body: JSON.stringify(body),
-      headers: new Headers({
-        "Content-Type": "application/json",
-        "X-Access-Key": accessToken
-      })
-    }
-  );
-  const json = await response.json();
-  if (json.error) {
-    console.info(json.error);
+  async function createVnet() {
+    return (await fetch(
+      `${TENDERLY_BASE_URL}/account/${accountSlug}/project/${projectSlug}/vnets`,
+      {
+        method: "POST",
+        body: JSON.stringify(body),
+        headers: new Headers({
+          "Content-Type": "application/json",
+          "X-Access-Key": accessToken
+        })
+      }
+    )).json();
+  }
+  let response = await createVnet();
+  if (response.error?.slug === "vnet_duplicate_key" && force) {
+    const staleVnet = await tenderly_getVnet(slug, {
+      accessToken,
+      accountSlug,
+      projectSlug
+    });
+    await tenderly_deleteVnet(staleVnet[0].id, {
+      accessToken,
+      accountSlug,
+      projectSlug
+    });
+    response = await createVnet();
+  }
+  if (response.error) {
+    console.info(response.error);
     throw new Error("Tenderly vnet could not be created");
   }
   return {
-    vnet: json,
+    vnet: response,
     testClient: (0, import_viem4.createTestClient)({
       mode: "tenderly",
-      transport: (0, import_viem4.http)(json.rpcs[0].url)
+      transport: (0, import_viem4.http)(response.rpcs[0].url)
     }),
     walletClient: (0, import_viem4.createWalletClient)({
       chain: { id: forkChainId },
       account: "0x7fc66500c84a76ad7e9c93437bfc5ac33e2ddae9",
-      transport: (0, import_viem4.http)(json.rpcs[0].url)
+      transport: (0, import_viem4.http)(response.rpcs[0].url)
     }),
-    simulate: (body2) => {
-      return fetch(
-        // Note: this is subject to change and currently uses the internal api of tenderly
-        `${TENDERLY_BASE_URL}/account/${accountSlug}/project/${projectSlug}/testnet/${json.id}/simulate`,
-        {
-          method: "POST",
-          body: JSON.stringify(body2),
-          headers: new Headers({
-            "Content-Type": "application/json",
-            "X-Access-Key": accessToken
-          })
-        }
-      );
-    },
-    delete: () => {
-      return fetch(
-        `${TENDERLY_BASE_URL}/account/${accountSlug}/project/${projectSlug}/vnets/${json.id}`,
-        {
-          method: "DELETE",
-          headers: new Headers({
-            "Content-Type": "application/json",
-            "X-Access-Key": accessToken
-          })
-        }
-      );
-    }
+    simulate: (body2) => tenderly_simVnet(
+      response.id,
+      {
+        accessToken,
+        accountSlug,
+        projectSlug
+      },
+      body2
+    ),
+    delete: () => tenderly_deleteVnet(response.id, {
+      accessToken,
+      accountSlug,
+      projectSlug
+    })
   };
 }
 
+// src/ecosystem/foundry.ts
+var import_node_child_process = require("child_process");
+var import_diff = require("diff");
+function foundry_getStandardJsonInput(input) {
+  const output = JSON.parse(
+    (0, import_node_child_process.execSync)(
+      `forge verify-contract --show-standard-json-input --verifier etherscan 0x0000000000000000000000000000000000000000 ${input}`
+    ).toString()
+  );
+  return output;
+}
+function foundry_getStorageLayout(input) {
+  const output = JSON.parse(
+    (0, import_node_child_process.execSync)(`forge inspect ${input} storage --json`).toString()
+  );
+  return output;
+}
+function cleanupFoundryStorageForDiffing(layout) {
+  const cleanTypes = { ...layout.types };
+  for (const key of Object.keys(cleanTypes)) {
+    if (cleanTypes[key].members)
+      cleanTypes[key].members = cleanTypes[key].members.map((member) => ({
+        label: member.label,
+        contract: member.contract.split(":")[1],
+        offset: member.offset,
+        slot: member.slot,
+        type: member.type
+      }));
+    if (cleanTypes[key].value)
+      cleanTypes[key].value = cleanTypes[cleanTypes[key].value];
+  }
+  const cleanStorage = layout.storage.map((storage) => ({
+    label: storage.label,
+    slot: storage.slot,
+    offset: storage.offset,
+    type: cleanTypes[storage.type],
+    contract: storage.contract.split(":")[1]
+  }));
+  return cleanStorage;
+}
+function diffFoundryStorageLayout(layoutBefore, layoutAfter) {
+  const beforeString = JSON.stringify(
+    cleanupFoundryStorageForDiffing(layoutBefore),
+    null,
+    2
+  );
+  const afterString = JSON.stringify(
+    cleanupFoundryStorageForDiffing(layoutAfter),
+    null,
+    2
+  );
+  return (0, import_diff.createPatch)("storage", beforeString, afterString);
+}
+
+// src/ecosystem/event-db.ts
+var EVENT_DB = [];
+
 // src/ecosystem/constants.ts
 var erc1967_ImplementationSlot = "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc";
 var erc1967_AdminSlot = "0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103";
 
 // src/operations/diffCode.ts
-var import_diff = require("diff");
+var import_diff2 = require("diff");
 var import_standalone = require("prettier/standalone");
 var import_standalone2 = __toESM(require("prettier-plugin-solidity/standalone"));
 var prettierOptions = { parser: "solidity-parse", plugins: [import_standalone2.default] };
-async function diffCode(codeBefore, codeAfter) {
-  const before = parseApiSourceCode(codeBefore);
-  const after = parseApiSourceCode(codeAfter);
+async function diffCode(before, after) {
   const changes = {};
   const settingsBefore = JSON.stringify(before.settings, null, 2);
   const settingsAfter = JSON.stringify(after.settings, null, 2);
   if (settingsBefore !== settingsAfter)
-    changes.settings = (0, import_diff.createPatch)("settings", settingsBefore, settingsAfter);
+    changes.settings = (0, import_diff2.createPatch)("settings", settingsBefore, settingsAfter);
   const contractsBefore = await Promise.all(
     Object.entries(before.sources).map(async ([path, source]) => [
       path.replace(/^.*[\\/]/, ""),
@@ -3040,10 +3183,10 @@ async function diffCode(codeBefore, codeAfter) {
   for (const [name, path, source] of contractsBefore) {
     const indexAfter = contractsAfter.findIndex(([_name]) => _name === name);
     if (indexAfter === -1) {
-      changes[name] = (0, import_diff.createPatch)(path, source, "");
+      changes[name] = (0, import_diff2.createPatch)(path, source, "");
     } else {
       if (source !== contractsAfter[indexAfter][2])
-        changes[name] = (0, import_diff.createTwoFilesPatch)(
+        changes[name] = (0, import_diff2.createTwoFilesPatch)(
           path,
           contractsAfter[indexAfter][1],
           source,
@@ -3054,21 +3197,167 @@ async function diffCode(codeBefore, codeAfter) {
   for (const [name, path, source] of contractsAfter) {
     const indexAfter = contractsBefore.findIndex(([_name]) => _name === name);
     if (indexAfter === -1) {
-      changes[name] = (0, import_diff.createPatch)(path, "", source);
+      changes[name] = (0, import_diff2.createPatch)(path, "", source);
     }
   }
   return changes;
 }
+
+// src/seatbelt/logs.ts
+var import_viem5 = require("viem");
+function parseLogs({ logs, eventDb }) {
+  const parsedLogs = logs.map((log) => {
+    try {
+      const decoded = (0, import_viem5.decodeEventLog)({
+        data: log.data,
+        topics: log.topics,
+        abi: eventDb
+      });
+      return { ...log, ...decoded };
+    } catch (e) {
+      return log;
+    }
+  });
+  return parsedLogs;
+}
+
+// src/seatbelt/selfdestruct.ts
+var import_actions3 = require("viem/actions");
+var STOP = 0;
+var JUMPDEST = 91;
+var PUSH1 = 96;
+var PUSH32 = 127;
+var RETURN = 243;
+var REVERT = 253;
+var INVALID = 254;
+var SELFDESTRUCT = 255;
+var DELEGATECALL = 244;
+var isHalting = (opcode) => [STOP, RETURN, REVERT, INVALID, SELFDESTRUCT].includes(opcode);
+var isPUSH = (opcode) => opcode >= PUSH1 && opcode <= PUSH32;
+var SelfdestuctCheckState = /* @__PURE__ */ ((SelfdestuctCheckState2) => {
+  SelfdestuctCheckState2[SelfdestuctCheckState2["TRUSTED"] = 0] = "TRUSTED";
+  SelfdestuctCheckState2[SelfdestuctCheckState2["EOA"] = 1] = "EOA";
+  SelfdestuctCheckState2[SelfdestuctCheckState2["EMPTY"] = 2] = "EMPTY";
+  SelfdestuctCheckState2[SelfdestuctCheckState2["DELEGATECALL"] = 3] = "DELEGATECALL";
+  SelfdestuctCheckState2[SelfdestuctCheckState2["SAFE"] = 4] = "SAFE";
+  SelfdestuctCheckState2[SelfdestuctCheckState2["SELF_DESTRUCT"] = 5] = "SELF_DESTRUCT";
+  return SelfdestuctCheckState2;
+})(SelfdestuctCheckState || {});
+async function checkForSelfdestruct(client, addresses, trustedAddresses) {
+  const result = [];
+  for (const address of addresses) {
+    if (trustedAddresses.includes(address)) {
+      result.push({ address, state: 0 /* TRUSTED */ });
+      continue;
+    }
+    const code = await (0, import_actions3.getBytecode)(client, { address });
+    if (!code) {
+      const nonce = await (0, import_actions3.getTransactionCount)(client, { address });
+      if (nonce > 0) result.push({ address, state: 1 /* EOA */ });
+      else result.push({ address, state: 2 /* EMPTY */ });
+      continue;
+    }
+    const bytecode = Buffer.from(code.substring(2), "hex");
+    const { delegatecall, selfDestruct } = checkCode(bytecode);
+    if (selfDestruct) {
+      result.push({ address, state: 5 /* SELF_DESTRUCT */ });
+    } else if (delegatecall) {
+      result.push({ address, state: 3 /* DELEGATECALL */ });
+    } else {
+      result.push({ address, state: 4 /* SAFE */ });
+    }
+  }
+  return result;
+}
+function checkCode(bytecode) {
+  let halted = false;
+  let delegatecall = false;
+  for (let index = 0; index < bytecode.length; index++) {
+    const opcode = bytecode[index];
+    if (opcode === SELFDESTRUCT && !halted) {
+      return { halted, delegatecall, selfDestruct: true };
+    }
+    if (opcode === DELEGATECALL && !halted) {
+      delegatecall = true;
+    } else if (opcode === JUMPDEST) {
+      halted = false;
+    } else if (isHalting(opcode)) {
+      halted = true;
+    } else if (isPUSH(opcode)) {
+      index += opcode - PUSH1 + 1;
+    }
+  }
+  return { halted, delegatecall, selfDestruct: false };
+}
+
+// src/seatbelt/verified.ts
+function getVerificationStatus({
+  chainId,
+  addresses,
+  contractDb,
+  apiKey,
+  apiUrl
+}) {
+  return Promise.all(
+    addresses.map(async (address) => {
+      if (contractDb[address])
+        return {
+          address,
+          name: contractDb[address],
+          status: 0 /* CACHE */
+        };
+      try {
+        const code = await getSourceCode({ chainId, address, apiKey, apiUrl });
+        return {
+          address,
+          name: code.ContractName,
+          status: 1 /* NEW */
+        };
+      } catch (e) {
+        return {
+          address,
+          status: 2 /* ERROR */
+        };
+      }
+    })
+  );
+}
+
+// src/seatbelt/tenderly-report.ts
+async function renderTenderlyReport({
+  client,
+  sim
+}) {
+  const logs = parseLogs({
+    logs: (sim.transaction.transaction_info.logs || []).map((l) => l.raw),
+    eventDb: EVENT_DB
+  });
+  const selfDestruct = checkForSelfdestruct(
+    client,
+    sim.transaction.addresses,
+    []
+    // trusted addresses
+  );
+  const verified = getVerificationStatus({
+    chainId: client.chain.id,
+    addresses: sim.transaction.addresses,
+    contractDb: {}
+  });
+  return logs;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  EVENT_DB,
   HALF_RAY,
   HALF_WAD,
   HUMAN_READABLE_PAYLOAD_STATE,
   HUMAN_READABLE_PROPOSAL_STATE,
   LTV_PRECISION,
   PayloadState,
+  ProposalState,
   RAY,
   SECONDS_PER_YEAR,
+  SelfdestuctCheckState,
   WAD,
   WAD_RAY_RATIO,
   bitmapToIndexes,
@@ -3076,12 +3365,16 @@ async function diffCode(codeBefore, codeAfter) {
   calculateCompoundedInterest,
   calculateHealthFactorFromBalances,
   calculateLinearInterest,
+  checkForSelfdestruct,
   decodeReserveConfiguration,
   decodeReserveConfigurationV2,
   decodeUserConfiguration,
   diffCode,
+  diffFoundryStorageLayout,
   erc1967_AdminSlot,
   erc1967_ImplementationSlot,
+  foundry_getStandardJsonInput,
+  foundry_getStorageLayout,
   getBits,
   getCurrentDebtBalance,
   getCurrentLiquidityBalance,
@@ -3089,18 +3382,26 @@ async function diffCode(codeBefore, codeAfter) {
   getGovernance,
   getMarketReferenceCurrencyAndUsdBalance,
   getNonFinalizedPayloads,
+  getNonFinalizedProposals,
   getNormalizedDebt,
   getNormalizedIncome,
   getPayloadsController,
   getSourceCode,
+  isPayloadFinal,
+  isProposalFinal,
   makePayloadExecutableOnTestClient,
   makeProposalExecutableOnTestClient,
-  parseApiSourceCode,
+  parseEtherscanStyleSourceCode,
+  parseLogs,
   rayDiv,
   rayMul,
   rayToWad,
+  renderTenderlyReport,
   setBits,
   tenderly_createVnet,
+  tenderly_deleteVnet,
+  tenderly_getVnet,
+  tenderly_simVnet,
   wadDiv,
   wadToRay
 });