@gearbox-protocol/sdk 14.10.10 → 14.11.0-next.10

package/dist/esm/{history → preview/trace}/errors.js

@@ -22,28 +22,6 @@ class WithdrawCollateralAlignmentError extends Error {
     this.name = "WithdrawCollateralAlignmentError";
   }
 }
-class ProtocolCallNotFoundError extends Error {
-  targetContract;
-  executeIndex;
-  constructor(targetContract, executeIndex) {
-    super(
-      `protocol call to ${targetContract} not found in trace for Execute #${executeIndex}`
-    );
-    this.name = "ProtocolCallNotFoundError";
-    this.targetContract = targetContract;
-    this.executeIndex = executeIndex;
-  }
-}
-class AdapterTraceAlignmentError extends Error {
-  constructor(expected, actual) {
-    super(`found ${actual} adapter traces for ${expected} execute events`);
-    this.expected = expected;
-    this.actual = actual;
-    this.name = "AdapterTracesAlignmentError";
-  }
-  expected;
-  actual;
-}
 class UnexpectedFacadeEventOrderError extends Error {
   constructor(e) {
     super(
@@ -63,8 +41,6 @@ class UnknownFacadeCallError extends Error {
   }
 }
 export {
-  AdapterTraceAlignmentError,
-  ProtocolCallNotFoundError,
   TransferAlignmentError,
   UnexpectedFacadeEventOrderError,
   UnknownAdapterError,

package/dist/esm/preview/trace/extractAdapterCallTraces.js

@@ -0,0 +1,40 @@
+import {
+  decodeAbiParameters,
+  isAddressEqual,
+  toFunctionSelector
+} from "viem";
+import {
+  resolveProtocolCall
+} from "../../common-utils/utils/trace.js";
+const WITHDRAW_PHANTOM_TOKEN_SELECTOR = toFunctionSelector(
+  "withdrawPhantomToken(address,uint256)"
+);
+const GET_PHANTOM_TOKEN_INFO_SELECTOR = toFunctionSelector(
+  "getPhantomTokenInfo()"
+);
+function isSynthesizedPhantomWithdrawal(siblings, index) {
+  const node = siblings[index];
+  if (node.type !== "CALL" || node.input.slice(0, 10).toLowerCase() !== WITHDRAW_PHANTOM_TOKEN_SELECTOR) {
+    return false;
+  }
+  const [token] = decodeAbiParameters(
+    [{ type: "address" }, { type: "uint256" }],
+    `0x${node.input.slice(10)}`
+  );
+  for (let i = 0; i < index; i++) {
+    const sib = siblings[i];
+    if (sib.type === "STATICCALL" && sib.input.slice(0, 10).toLowerCase() === GET_PHANTOM_TOKEN_INFO_SELECTOR && isAddressEqual(sib.to, token)) {
+      return true;
+    }
+  }
+  return false;
+}
+function extractAdapterCallTraces(facadeTrace) {
+  const subtraces = facadeTrace.calls ?? [];
+  return subtraces.filter(
+    (sub, index) => resolveProtocolCall(sub) !== void 0 && !isSynthesizedPhantomWithdrawal(subtraces, index)
+  );
+}
+export {
+  extractAdapterCallTraces
+};

package/dist/esm/{history → preview/trace}/extractTransfers.js

@@ -3,14 +3,14 @@ import {
   isAddressEqual,
   parseEventLogs
 } from "viem";
-import { iCreditFacadeV310Abi } from "../abi/310/generated.js";
-import { ierc20Abi } from "../abi/iERC20.js";
-import { AddressMap } from "../sdk/index.js";
+import { iCreditFacadeV310Abi } from "../../abi/310/generated.js";
+import { ierc20Abi } from "../../abi/iERC20.js";
+import { AddressMap } from "../../sdk/index.js";
 import { UnexpectedFacadeEventOrderError } from "./errors.js";
 function extractTransfers(logs, creditAccount, pool, creditFacade) {
   const ranges = buildOperationRanges(logs, creditFacade, creditAccount);
   let currentEntries = [];
-  const executeResults = [];
+  const executeTransfers = [];
   const directTransfers = [];
   const phantomTokens = new AddressMap();
   const withdrawCollateralEvents = [];
@@ -19,20 +19,17 @@ function extractTransfers(logs, creditAccount, pool, creditFacade) {
     const facadeEvent = tryDecodeFacadeEvent(log, creditFacade);
     if (facadeEvent) {
       if (isExecute(facadeEvent, creditAccount)) {
-        executeResults.push({
-          transfers: currentEntries,
-          targetContract: facadeEvent.args.targetContract
-        });
+        executeTransfers.push(currentEntries);
       } else if (isLiquidation(facadeEvent, creditAccount)) {
         liquidationRemainingFunds = facadeEvent.args.remainingFunds;
       } else if (isWithdrawPhantomToken(facadeEvent, creditAccount)) {
-        const phantomExec = executeResults.pop();
-        if (!phantomExec) {
+        const phantomTransfers = executeTransfers.pop();
+        if (!phantomTransfers) {
           throw new Error(
             `WithdrawPhantomToken without preceding Execute at logIndex ${facadeEvent.logIndex}`
           );
         }
-        const rawDeposit = phantomExec.transfers.find(
+        const rawDeposit = phantomTransfers.find(
           (t) => isAddressEqual(t.to, creditAccount)
         );
         if (!rawDeposit) {
@@ -67,11 +64,11 @@ function extractTransfers(logs, creditAccount, pool, creditFacade) {
       currentEntries.push({ token, amount: value, from, to });
     }
     if (isAddressEqual(to, creditAccount) && !isInRange(log.logIndex, ranges)) {
-      directTransfers.push({ token, from, amount: value });
+      directTransfers.push({ token, amount: value, from, to });
     }
   }
   return {
-    executeResults,
+    executeTransfers,
     directTransfers,
     liquidationRemainingFunds,
     phantomTokens,

package/dist/esm/{history → preview/trace}/findFacadeCalls.js

@@ -2,9 +2,11 @@ import {
   decodeFunctionResult,
   isAddressEqual
 } from "viem";
-import { iCreditFacadeV310Abi } from "../abi/310/generated.js";
+import { iCreditFacadeV310Abi } from "../../abi/310/generated.js";
+import {
+  collectTraces
+} from "../../common-utils/utils/trace.js";
 import { UnknownFacadeCallError } from "./errors.js";
-import { collectTraces } from "./trace-utils.js";
 const FACADE_CALL_TYPES = {
   multicall: "MultiCall",
   botMulticall: "BotMulticall",

package/dist/esm/preview/trace/index.js

@@ -0,0 +1,5 @@
+export * from "./errors.js";
+export * from "./extractAdapterCallTraces.js";
+export * from "./extractTransfers.js";
+export * from "./findFacadeCalls.js";
+export * from "./types.js";

package/dist/esm/sdk/accounts/CreditAccountsServiceV310.js

@@ -1547,6 +1547,160 @@ class CreditAccountsServiceV310 extends SDKConstruct {
       callsWithPrices
     );
   }
+  /**
+   * {@inheritDoc ICreditAccountsService.prependPriceUpdates}
+   */
+  async prependPriceUpdates(creditManager, calls, creditAccount, options) {
+    return this.#prependPriceUpdates(
+      creditManager,
+      calls,
+      creditAccount,
+      options
+    );
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.assembleCaUpdateCalls}
+   */
+  assembleCaUpdateCalls({
+    operations,
+    routerCallGroups,
+    creditFacade,
+    withdrawTo,
+    creditAccount,
+    underlyingToken
+  }) {
+    const calls = [];
+    let swapGroupIndex = 0;
+    let routerGroupsConsumed = 0;
+    for (const op of operations) {
+      switch (op.type) {
+        case "increaseDebt":
+          calls.push(this.#prepareIncreaseDebt(creditFacade, op.amount));
+          break;
+        case "decreaseDebt":
+          calls.push(this.#prepareChangeDebt(creditFacade, op.amount, true));
+          break;
+        case "addCollateral":
+          calls.push(
+            ...this.#prepareAddCollateral(
+              creditFacade,
+              [{ token: op.token, balance: op.amount }],
+              {}
+            )
+          );
+          break;
+        case "withdrawCollateral":
+          calls.push(
+            this.#prepareWithdrawToken(
+              creditFacade,
+              op.token,
+              op.amount,
+              withdrawTo
+            )
+          );
+          break;
+        case "swap": {
+          const routerCalls = routerCallGroups[swapGroupIndex];
+          if (!routerCalls) {
+            throw new Error(
+              `assembleCaUpdateCalls: missing router calls for swap leg ${swapGroupIndex}`
+            );
+          }
+          calls.push(...routerCalls);
+          swapGroupIndex += 1;
+          routerGroupsConsumed += 1;
+          break;
+        }
+        case "changeQuota": {
+          const quotaAssets = [...op.quotaIncrease, ...op.quotaDecrease];
+          if (quotaAssets.length === 0) {
+            break;
+          }
+          calls.push(
+            ...this.#prepareUpdateQuotas(creditFacade, {
+              averageQuota: quotaAssets,
+              minQuota: quotaAssets
+            })
+          );
+          break;
+        }
+        case "closeCreditAccount": {
+          for (const group of routerCallGroups) {
+            calls.push(...group);
+            routerGroupsConsumed += 1;
+          }
+          calls.push(
+            ...this.#prepareDisableQuotas({
+              creditFacade,
+              tokens: Object.entries(creditAccount.initialQuotas).map(
+                ([token, { quota }]) => ({
+                  token,
+                  quota
+                })
+              )
+            })
+          );
+          if (creditAccount.debt > 0n) {
+            calls.push(
+              ...this.#prepareDecreaseDebt({
+                creditFacade,
+                debt: creditAccount.debt
+              })
+            );
+          }
+          const hasAssets = creditAccount.assets.some(
+            (asset) => asset.balance > 0n
+          );
+          if (hasAssets) {
+            calls.push(
+              this.#prepareWithdrawToken(
+                creditFacade,
+                underlyingToken,
+                MAX_UINT256,
+                withdrawTo
+              )
+            );
+          }
+          break;
+        }
+        default: {
+          const _exhaustive = op;
+          throw new Error(
+            `assembleCaUpdateCalls: unsupported operation ${_exhaustive}`
+          );
+        }
+      }
+    }
+    if (routerGroupsConsumed !== routerCallGroups.length) {
+      throw new Error(
+        `assembleCaUpdateCalls: router call group mismatch (consumed ${routerGroupsConsumed}, got ${routerCallGroups.length})`
+      );
+    }
+    return calls;
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.executeCaUpdate}
+   */
+  async executeCaUpdate(creditAccount, calls, options) {
+    const cm = this.sdk.marketRegister.findCreditManager(
+      creditAccount.creditManager
+    );
+    const callsWithPrices = await this.#prependPriceUpdates(
+      creditAccount.creditManager,
+      calls,
+      creditAccount,
+      { ignoreReservePrices: options?.ignoreReservePrices }
+    );
+    const tx = await this.#multicallTx(
+      cm,
+      creditAccount.creditAccount,
+      callsWithPrices
+    );
+    if (options?.ethAmount && options.ethAmount > 0n) {
+      tx.value = options.ethAmount.toString(10);
+    }
+    return { tx, calls: callsWithPrices };
+  }
   #prepareDisableQuotas(ca) {
     const calls = [];
     for (const { token, quota } of ca.tokens) {

package/dist/types/common-utils/utils/index.d.ts

@@ -5,4 +5,5 @@ export * from "./constants.js";
 export * from "./creditAccount/index.js";
 export * from "./price-math.js";
 export * from "./strategies/index.js";
+export * from "./trace.js";
 export * from "./validation/index.js";

package/dist/types/common-utils/utils/trace.d.ts

@@ -0,0 +1,73 @@
+import { type Address, type Hex } from "viem";
+/**
+ * A single frame from Ethereum's `debug_traceTransaction` callTracer output.
+ * Recursive: each frame may contain nested sub-calls.
+ */
+export interface CallTrace {
+    from: Address;
+    to: Address;
+    input: Hex;
+    output: Hex;
+    value: Hex;
+    /** "CALL", "DELEGATECALL", "STATICCALL", "CREATE", etc. */
+    type: string;
+    /** Present when the call reverted (e.g. "execution reverted"). */
+    error?: string;
+    /** ABI-encoded revert data, if available. */
+    revertReason?: Hex;
+    calls?: CallTrace[];
+}
+/**
+ * Selector of `CreditManagerV3.execute(bytes)` (`0x09c5eabe`).
+ *
+ * This is the authoritative marker of an adapter performing an external
+ * protocol call: the adapter calls the credit manager's `execute(bytes)`, which
+ * forwards the calldata to the credit account, which in turn CALLs the target
+ * (protocol) contract. Adapter approvals use a different selector
+ * (`execute(address,bytes)` on the credit account), so matching on this
+ * selector isolates the real protocol call.
+ */
+export declare const EXECUTE_BYTES_SELECTOR: "0x09c5eabe";
+/**
+ * Finds the shallowest non-reverted `CreditManager.execute(bytes)` call in a
+ * trace subtree (breadth-first), or `undefined` if none exists.
+ *
+ * "Shallowest" matters for account migration: a migrate adapter nests the
+ * entire target `openCreditAccount` multicall - including that account's own
+ * `execute(bytes)` calls - inside its subtree. The shallowest match is the
+ * adapter's own protocol call, not a nested one.
+ */
+export declare function findExecuteBytes(node: CallTrace): CallTrace | undefined;
+/**
+ * Finds the first non-reverted CALL in a subtree whose `input` exactly matches
+ * `input` (case-insensitive). Used to locate the leaf CALL to the target
+ * contract: `execute(bytes)` forwards the calldata unchanged through the credit
+ * account proxy DELEGATECALL down to the final CALL to the protocol contract.
+ */
+export declare function findCallWithInput(node: CallTrace, input: Hex): CallTrace | undefined;
+/**
+ * Resolves the external protocol call performed by an adapter-level call trace.
+ *
+ * Locates the shallowest `CreditManager.execute(bytes)`, decodes the forwarded
+ * calldata, then finds the leaf CALL whose input matches that calldata to
+ * recover the target (protocol) contract address. Returns `undefined` when the
+ * subtree does not actually reach an external protocol CALL (e.g. the
+ * facade-internal `depositPhantomToken` / `withdrawPhantomToken` accounting
+ * calls, which forward calldata but make no external CALL).
+ *
+ * @param node - direct child node of the upper-level facade call trace
+ */
+export declare function resolveProtocolCall(node: CallTrace): {
+    contract: Address;
+    calldata: Hex;
+} | undefined;
+/**
+ * Finds the first non-reverted CALL to `target` anywhere in a trace subtree.
+ */
+export declare function findCallTo(node: CallTrace, target: Address): CallTrace | undefined;
+/**
+ * DFS walk of the call trace tree, collecting non-reverted CALL entries
+ * to the given address.
+ * Does not recurse into children of matched nodes
+ */
+export declare function collectTraces(node: CallTrace, target: Address): CallTrace[];

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

@@ -19,3 +19,4 @@ export * from "./replaceStorage.js";
 export * from "./resilientTransport.js";
 export * from "./transports.js";
 export * from "./types.js";
+export * from "./verifyTestnet.js";

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

@@ -0,0 +1,82 @@
+import type { Address, PublicClient } from "viem";
+/**
+ * Address is stable, contract deployed via create2
+ */
+export declare const ONCHAIN_EXECUTION_ID_ADDRESS: Address;
+/**
+ * This contract is deployed on every Gearbox testnet and contains
+ * execution id and alias of the testnet
+ */
+export declare const iOnchainExecutionIdAbi: readonly [{
+    readonly type: "function";
+    readonly name: "deployer";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+        readonly internalType: "string";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "executionId";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+        readonly internalType: "string";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "forkAlias";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+        readonly internalType: "string";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "info";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "tuple";
+        readonly internalType: "struct ExecutionId.Info";
+        readonly components: readonly [{
+            readonly name: "deployer";
+            readonly type: "string";
+            readonly internalType: "string";
+        }, {
+            readonly name: "executionId";
+            readonly type: "string";
+            readonly internalType: "string";
+        }, {
+            readonly name: "forkAlias";
+            readonly type: "string";
+            readonly internalType: "string";
+        }];
+    }];
+    readonly stateMutability: "view";
+}];
+export type VerifyTestnetParams = {
+    executionId: string;
+} | {
+    alias: string;
+} | {
+    executionId: string;
+    alias: string;
+};
+/**
+ * Tries to read the contract that is deployed on every Gearbox testnet
+ * and verify that we're on expected testnet.
+ *
+ * Used to check that wallet is using correct RPC for the testnet.
+ *
+ * @param client - Public client
+ * @param expected - Expected tesnet alias or execution id
+ * @returns True if we're on expected testnet
+ */
+export declare function verifyTestnet(client: PublicClient, expected: VerifyTestnetParams): Promise<boolean>;

package/dist/types/history/assembleOperations.d.ts

@@ -1,11 +1,16 @@
 import type { Address } from "viem";
+import type { TokenTransfer } from "../preview/parse/index.js";
+import { type FacadeParsedCall, type WithdrawCollateralEventInfo } from "../preview/trace/index.js";
 import type { AddressMap, ChainContractsRegister } from "../sdk/index.js";
-import type { WithdrawCollateralEventInfo } from "./extractTransfers.js";
-import type { ExecuteResult, FacadeParsedCall } from "./internal-types.js";
-import type { FacadeOperationMetadata, OuterFacadeOperation } from "./types.js";
+import type { HistoryFacadeMetadata, OuterFacadeOperation } from "./types.js";
 export interface AssembleOperationsInput {
     facadeCalls: FacadeParsedCall[];
-    executeResults: ExecuteResult[];
+    /**
+     * ERC-20 transfers grouped per facade `Execute` event, one inner array per
+     * Execute event across the whole transaction, in emission order. Sliced per
+     * facade call and consumed one inner array per adapter/unknown inner call.
+     */
+    executeTransfers: TokenTransfer[][];
     register: ChainContractsRegister;
     underlying: Address;
     liquidationRemainingFunds?: bigint;
@@ -17,8 +22,8 @@ export interface AssembleOperationsInput {
  * Combines parsed facade calls with per-Execute transfer data into
  * fully classified {@link OuterFacadeOperation} entries.
  *
- * The flat `executeResults` array (one entry per Execute event across
+ * The flat `executeTransfers` array (one inner array per Execute event across
  * the entire transaction) is sliced per facade call based on how many
  * adapter/unknown inner calls each one contains.
  */
-export declare function assembleOperations(input: AssembleOperationsInput): Omit<OuterFacadeOperation, keyof FacadeOperationMetadata>[];
+export declare function assembleOperations(input: AssembleOperationsInput): Omit<OuterFacadeOperation, keyof HistoryFacadeMetadata>[];

package/dist/types/history/classifyMulticallOperations.d.ts

@@ -1,12 +1,23 @@
-import { type Address, type Hex } from "viem";
+import { type Address } from "viem";
+import type { CallTrace } from "../common-utils/utils/trace.js";
+import type { TokenTransfer } from "../preview/parse/index.js";
+import { type WithdrawCollateralEventInfo } from "../preview/trace/index.js";
 import type { AddressMap, ChainContractsRegister, ParsedCallV2 } from "../sdk/index.js";
-import type { WithdrawCollateralEventInfo } from "./extractTransfers.js";
-import type { InnerOperation } from "./inner-operations.js";
-import type { ExecuteResult } from "./internal-types.js";
+import type { InnerOperation } from "./types.js";
 export interface ClassifyMulticallOperationsInput {
     innerCalls: ParsedCallV2[];
-    executeResults: ExecuteResult[];
-    protocolCalldatas: Hex[];
+    /**
+     * ERC-20 transfers grouped per facade `Execute` event for this facade call,
+     * one inner array per Execute event, in order. One inner array is consumed
+     * per adapter/unknown inner call.
+     */
+    executeTransfers: TokenTransfer[][];
+    /**
+     * Adapter-level call traces (one per Execute event, in order) used to recover
+     * the protocol-level call for adapter inner calls. See
+     * `extractAdapterCallTraces`.
+     */
+    adapterTraces: CallTrace[];
     register: ChainContractsRegister;
     creditAccount: Address;
     underlying: Address;
@@ -17,9 +28,10 @@ export interface ClassifyMulticallOperationsInput {
 /**
  * Classifies each multicall inner call into a {@link InnerOperation}:
  *
- * - **Adapter calls** (target registered as an adapter): delegates to
- *   `adapter.parseAdapterOperation()` and consumes the next entry from
- *   `executeTransfers` (one Execute event per adapter call).
+ * - **Adapter calls** (target registered as an adapter): decodes the
+ *   protocol-level call via `adapter.parseProtocolCall()`, classifies the
+ *   legacy operation via `adapter.classifyLegacyOperation()`, and consumes the
+ *   next entry from `executeTransfers` (one Execute event per adapter call).
  *
  * - **Facade self-calls** (`increaseDebt`, `updateQuota`, etc.): mapped
  *   directly from `functionName` / `rawArgs`. No transfer consumed.

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

@@ -1,4 +1,3 @@
-export * from "./inner-operations.js";
 export * from "./mapOperations.js";
 export { parseCreditAccountTransaction } from "./parseCreditAccountTransaction.js";
 export * from "./populateContractsRegister.js";

package/dist/types/history/mapOperations.d.ts

@@ -1,18 +1,16 @@
-import type { AdapterOperation } from "../plugins/adapters/index.js";
-import type { AddCollateralOp, DecreaseDebtOp, IncreaseDebtOp, UpdateQuotaOp, WithdrawCollateralOp } from "./inner-operations.js";
-import type { CloseCreditAccountOperation, CreditAccountOperation, DirectTokenTransferOperation, FacadeOperationMetadata, LiquidateCreditAccountOperation, MulticallOperation, OpenCreditAccountOperation, PartialLiquidationOperation } from "./types.js";
+import type { AdapterOperation, AddCollateralOp, CloseCreditAccountOperation, CreditAccountOperation, DecreaseDebtOp, DirectTokenTransferOperation, HistoryFacadeMetadata, IncreaseDebtOp, LiquidateCreditAccountOperation, MulticallOperation, OpenCreditAccountOperation, PartialLiquidationOperation, UpdateQuotaOp, WithdrawCollateralOp } from "./types.js";
 /**
  * Visitor that maps each operation node in a {@link CreditAccountOperation}
  * tree to a new representation.
  *
  */
 export interface OperationVisitor<TInner, TOuter> {
-    Execute(op: AdapterOperation, ctx: FacadeOperationMetadata): TInner;
-    IncreaseBorrowedAmount(op: IncreaseDebtOp, ctx: FacadeOperationMetadata): TInner;
-    DecreaseBorrowedAmount(op: DecreaseDebtOp, ctx: FacadeOperationMetadata): TInner;
-    AddCollateral(op: AddCollateralOp, ctx: FacadeOperationMetadata): TInner;
-    WithdrawCollateral(op: WithdrawCollateralOp, ctx: FacadeOperationMetadata): TInner;
-    UpdateQuota(op: UpdateQuotaOp, ctx: FacadeOperationMetadata): TInner;
+    Execute(op: AdapterOperation, ctx: HistoryFacadeMetadata): TInner;
+    IncreaseBorrowedAmount(op: IncreaseDebtOp, ctx: HistoryFacadeMetadata): TInner;
+    DecreaseBorrowedAmount(op: DecreaseDebtOp, ctx: HistoryFacadeMetadata): TInner;
+    AddCollateral(op: AddCollateralOp, ctx: HistoryFacadeMetadata): TInner;
+    WithdrawCollateral(op: WithdrawCollateralOp, ctx: HistoryFacadeMetadata): TInner;
+    UpdateQuota(op: UpdateQuotaOp, ctx: HistoryFacadeMetadata): TInner;
     DirectTokenTransfer(op: DirectTokenTransferOperation): TOuter;
     MultiCall(op: MulticallOperation, multicall: TInner[]): TOuter;
     OpenCreditAccount(op: OpenCreditAccountOperation, multicall: TInner[]): TOuter;