@puppet.fund/operator 0.1.0

package/dist/core-DC0-qJhv.d.ts

@@ -0,0 +1,2986 @@
+import { Address, Hex, PublicClient } from "viem";
+import { IStream } from "aelea/stream";
+import { Client } from "graphql-ws";
+//#region ../contracts/dist/types/types/index.d.ts
+interface IAccount__CreatePuppetAccountIntent {
+  params: IAccountLib__AccountInitParams;
+  blockNumber: bigint;
+  deadline: bigint;
+  acceptableRelayFee: bigint;
+  nonce: bigint;
+  chainId: bigint;
+  tokenId: Hex;
+  initialDepositAmount: bigint;
+}
+interface IAccountGate__BridgeIntent {
+  params: IAccountLib__AccountInitParams;
+  blockNumber: bigint;
+  deadline: bigint;
+  acceptableRelayFee: bigint;
+  nonce: bigint;
+  chainId: bigint;
+  tokenId: Hex;
+  provider: Address;
+  providerCallData: Hex;
+  inputAmount: bigint;
+  outputAmount: bigint;
+  destinationChainId: bigint;
+  expires: number;
+  fillDeadline: number;
+}
+interface IAccountGate__RecognizeIntent {
+  params: IAccountLib__AccountInitParams;
+  blockNumber: bigint;
+  deadline: bigint;
+  acceptableRelayFee: bigint;
+  nonce: bigint;
+  chainId: bigint;
+  tokenId: Hex;
+  amount: bigint;
+}
+interface IAccountLib__AccountInitParams {
+  user: Address;
+  signer: Address;
+}
+interface IAllocate__AllocateIntent {
+  params: IAccountLib__AccountInitParams;
+  blockNumber: bigint;
+  deadline: bigint;
+  acceptableRelayFee: bigint;
+  nonce: bigint;
+  chainId: bigint;
+  share: IShareLib__ShareInitParams;
+  acceptableNetAssetValue: bigint;
+  totalShareSupply: bigint;
+  masterAmount: bigint;
+  puppetList: Address[];
+  matchedAmountList: bigint[];
+}
+interface IHubGate__WithdrawToBridgeIntent {
+  params: IAccountLib__AccountInitParams;
+  blockNumber: bigint;
+  deadline: bigint;
+  acceptableRelayFee: bigint;
+  nonce: bigint;
+  chainId: bigint;
+  tokenId: Hex;
+  inputToken: Address;
+  outputToken: Address;
+  inputAmount: bigint;
+  outputAmount: bigint;
+  destinationChainId: bigint;
+  provider: Address;
+  providerCallData: Hex;
+  expires: number;
+  fillDeadline: number;
+}
+interface IHubGate__WithdrawToWalletIntent {
+  params: IAccountLib__AccountInitParams;
+  blockNumber: bigint;
+  deadline: bigint;
+  acceptableRelayFee: bigint;
+  nonce: bigint;
+  chainId: bigint;
+  tokenId: Hex;
+  amount: bigint;
+}
+interface IIAccount__Call {
+  target: Address;
+  value: bigint;
+  gasLimit: bigint;
+  callData: Hex;
+}
+interface IIAccount__SignTransfer {
+  tokenId: Hex;
+  token: Address;
+  amountIn: bigint;
+  amountOut: bigint;
+}
+interface IMasterGate__CreateFundAccountIntent {
+  params: IAccountLib__AccountInitParams;
+  blockNumber: bigint;
+  deadline: bigint;
+  acceptableRelayFee: bigint;
+  nonce: bigint;
+  chainId: bigint;
+  tokenId: Hex;
+  sweepAmount: bigint;
+}
+interface IMasterGate__OperateIntent {
+  params: IAccountLib__AccountInitParams;
+  blockNumber: bigint;
+  deadline: bigint;
+  acceptableRelayFee: bigint;
+  nonce: bigint;
+  chainId: bigint;
+  callList: IIAccount__Call[];
+  transferList: IIAccount__SignTransfer[];
+}
+interface IRedeem__ClaimIntent {
+  params: IAccountLib__AccountInitParams;
+  blockNumber: bigint;
+  deadline: bigint;
+  acceptableRelayFee: bigint;
+  nonce: bigint;
+  chainId: bigint;
+  share: IShareLib__ShareInitParams;
+  amount: bigint;
+}
+interface IRedeem__LiquidateIntent {
+  params: IAccountLib__AccountInitParams;
+  blockNumber: bigint;
+  deadline: bigint;
+  acceptableRelayFee: bigint;
+  nonce: bigint;
+  chainId: bigint;
+  share: IShareLib__ShareInitParams;
+  acceptableNetAssetValue: bigint;
+}
+interface IRedeem__RedeemIntent {
+  params: IAccountLib__AccountInitParams;
+  blockNumber: bigint;
+  deadline: bigint;
+  acceptableRelayFee: bigint;
+  nonce: bigint;
+  chainId: bigint;
+  share: IShareLib__ShareInitParams;
+  sharesOut: bigint;
+  assetsOut: bigint;
+  acceptableNetAssetValue: bigint;
+}
+interface IRedeem__SellIntent {
+  params: IAccountLib__AccountInitParams;
+  blockNumber: bigint;
+  deadline: bigint;
+  acceptableRelayFee: bigint;
+  nonce: bigint;
+  chainId: bigint;
+  share: IShareLib__ShareInitParams;
+  sharesOut: bigint;
+}
+interface IRuleLib__Rule {
+  fund: Address;
+  body: Hex;
+  mandate: Hex;
+}
+interface IShareLib__ShareInitParams {
+  master: Address;
+  baseTokenId: Hex;
+  name: Hex;
+}
+interface ISubscribe__SubscribeIntent {
+  params: IAccountLib__AccountInitParams;
+  blockNumber: bigint;
+  deadline: bigint;
+  acceptableRelayFee: bigint;
+  nonce: bigint;
+  chainId: bigint;
+  baseTokenId: Hex;
+  rules: IRuleLib__Rule[];
+}
+//#endregion
+//#region ../contracts/dist/types/const/index.d.ts
+declare const TOKEN_ID: {
+  readonly USDC: '0xd6aca1be9729c13d677335161321649cccae6a591554772516700f986f942eaa';
+  readonly WETH: '0x0f8a193ff464434486c0daf7db2a895884365d2bc84ba47a68fcf89c1b14b5b8';
+};
+//#endregion
+//#region ../sdk/dist/types/state/shared.d.ts
+interface IIndexerClient {
+  httpEndpoint: string;
+  wsClient: Client;
+}
+//#endregion
+//#region ../sdk/dist/types/attestation/shared.d.ts
+interface IIntentByKind {
+  subscribe: ISubscribe__SubscribeIntent;
+  allocate: IAllocate__AllocateIntent;
+  sell: IRedeem__SellIntent;
+  claim: IRedeem__ClaimIntent;
+  redeem: IRedeem__RedeemIntent;
+  liquidate: IRedeem__LiquidateIntent;
+  createPuppetAccount: IAccount__CreatePuppetAccountIntent;
+  createFundAccount: IMasterGate__CreateFundAccountIntent;
+  operate: IMasterGate__OperateIntent;
+  recognize: IAccountGate__RecognizeIntent;
+  withdrawToWallet: IHubGate__WithdrawToWalletIntent;
+  bridge: IAccountGate__BridgeIntent;
+  withdrawToBridge: IHubGate__WithdrawToBridgeIntent;
+}
+type IActionKind = keyof IIntentByKind;
+//#endregion
+//#region ../sdk/dist/types/attestation/allocate.d.ts
+interface IAllocateInput {
+  params: IAccountLib__AccountInitParams;
+  share: IShareLib__ShareInitParams;
+  blockNumber: bigint;
+  deadline: bigint;
+  acceptableRelayFee: bigint;
+  nonce: bigint;
+  acceptableNetAssetValue: bigint;
+  totalShareSupply: bigint;
+  masterAmount: bigint;
+  puppetList: Address[];
+  matchedAmountList: bigint[];
+}
+//#endregion
+//#region ../sdk/dist/types/attestation/bridge.d.ts
+type IBridgeRoute = {
+  kind: 'across';
+  exclusiveRelayer: Address;
+  quoteTimestamp: number;
+  exclusivityParameter: number;
+} | {
+  kind: 'swap';
+  provider: Address;
+  providerCallData: Hex;
+};
+interface IBridgeInput {
+  params: IAccountLib__AccountInitParams;
+  tokenId: Hex;
+  blockNumber: bigint;
+  deadline: bigint;
+  acceptableRelayFee: bigint;
+  nonce: bigint;
+  chainId: bigint;
+  inputAmount: bigint;
+  destinationChainId: bigint;
+  route: IBridgeRoute;
+  outputAmount: bigint;
+  expires: number;
+  fillDeadline: number;
+}
+//#endregion
+//#region ../sdk/dist/types/attestation/claim.d.ts
+interface IClaimInput {
+  params: IAccountLib__AccountInitParams;
+  blockNumber: bigint;
+  deadline: bigint;
+  acceptableRelayFee: bigint;
+  nonce: bigint;
+  share: IShareLib__ShareInitParams;
+  amount: bigint;
+}
+//#endregion
+//#region ../sdk/dist/types/attestation/createAccount.d.ts
+interface ICreatePuppetAccountInput {
+  params: IAccountLib__AccountInitParams;
+  tokenId: Hex;
+  blockNumber: bigint;
+  deadline: bigint;
+  acceptableRelayFee: bigint;
+  nonce: bigint;
+  chainId: bigint;
+  initialDepositAmount: bigint;
+  userDeploySig: Hex;
+  userSignerProof: Hex;
+}
+//#endregion
+//#region ../sdk/dist/types/attestation/createFundAccount.d.ts
+interface ICreateFundAccountInput {
+  params: IAccountLib__AccountInitParams;
+  tokenId: Hex;
+  blockNumber: bigint;
+  deadline: bigint;
+  acceptableRelayFee: bigint;
+  nonce: bigint;
+  chainId: bigint;
+  sweepAmount: bigint;
+}
+//#endregion
+//#region ../sdk/dist/types/attestation/depositRoute.d.ts
+type IDepositMode = 'erc20Gate' | 'native' | 'erc20Transfer';
+interface IDepositRoute {
+  chainId: number;
+  params: IAccountLib__AccountInitParams;
+  tokenId: Hex;
+  mode: IDepositMode;
+  token: Address;
+  amount: bigint;
+  walletBalance: bigint;
+  spender?: Address;
+  walletAllowance?: bigint;
+}
+//#endregion
+//#region ../sdk/dist/types/attestation/liquidate.d.ts
+interface ILiquidateInput {
+  params: IAccountLib__AccountInitParams;
+  blockNumber: bigint;
+  deadline: bigint;
+  acceptableRelayFee: bigint;
+  nonce: bigint;
+  share: IShareLib__ShareInitParams;
+  acceptableNetAssetValue: bigint;
+}
+//#endregion
+//#region ../sdk/dist/types/attestation/operate.d.ts
+interface IOperateInput {
+  params: IAccountLib__AccountInitParams;
+  blockNumber: bigint;
+  deadline: bigint;
+  acceptableRelayFee: bigint;
+  nonce: bigint;
+  chainId: bigint;
+  callList: IIAccount__Call[];
+  transferList: IIAccount__SignTransfer[];
+}
+//#endregion
+//#region ../sdk/dist/types/attestation/recognizeBalance.d.ts
+interface IRecognizeBalanceInput {
+  params: IAccountLib__AccountInitParams;
+  tokenId: Hex;
+  blockNumber: bigint;
+  deadline: bigint;
+  acceptableRelayFee: bigint;
+  nonce: bigint;
+  chainId: bigint;
+  amount: bigint;
+}
+//#endregion
+//#region ../sdk/dist/types/attestation/redeem.d.ts
+interface IRedeemInput {
+  params: IAccountLib__AccountInitParams;
+  blockNumber: bigint;
+  deadline: bigint;
+  acceptableRelayFee: bigint;
+  nonce: bigint;
+  share: IShareLib__ShareInitParams;
+  sharesOut: bigint;
+  assetsOut: bigint;
+  acceptableNetAssetValue: bigint;
+}
+//#endregion
+//#region ../sdk/dist/types/attestation/sell.d.ts
+interface ISellInput {
+  params: IAccountLib__AccountInitParams;
+  blockNumber: bigint;
+  deadline: bigint;
+  acceptableRelayFee: bigint;
+  nonce: bigint;
+  share: IShareLib__ShareInitParams;
+  sharesOut: bigint;
+}
+//#endregion
+//#region ../sdk/dist/types/attestation/subscribe.d.ts
+interface ISubscribeRule {
+  master: Address;
+  body: Hex;
+  mandate: Hex;
+}
+interface ISubscribeInput {
+  params: IAccountLib__AccountInitParams;
+  baseTokenId: Hex;
+  blockNumber: bigint;
+  deadline: bigint;
+  acceptableRelayFee: bigint;
+  nonce: bigint;
+  rules: readonly ISubscribeRule[];
+}
+//#endregion
+//#region ../sdk/dist/types/attestation/withdrawToBridge.d.ts
+interface IWithdrawToBridgeInput {
+  params: IAccountLib__AccountInitParams;
+  tokenId: Hex;
+  blockNumber: bigint;
+  deadline: bigint;
+  acceptableRelayFee: bigint;
+  nonce: bigint;
+  inputAmount: bigint;
+  destinationChainId: bigint;
+  exclusiveRelayer: Address;
+  quoteTimestamp: number;
+  exclusivityParameter: number;
+  outputAmount: bigint;
+  expires: number;
+  fillDeadline: number;
+}
+//#endregion
+//#region ../sdk/dist/types/attestation/withdrawToWallet.d.ts
+interface IWithdrawToWalletInput {
+  params: IAccountLib__AccountInitParams;
+  tokenId: Hex;
+  blockNumber: bigint;
+  deadline: bigint;
+  acceptableRelayFee: bigint;
+  nonce: bigint;
+  chainId: bigint;
+  amount: bigint;
+}
+//#endregion
+//#region ../sdk/dist/types/attestation/index.d.ts
+type IInputByKind = {
+  subscribe: ISubscribeInput;
+  createPuppetAccount: ICreatePuppetAccountInput;
+  createFundAccount: ICreateFundAccountInput;
+  allocate: IAllocateInput;
+  operate: IOperateInput;
+  sell: ISellInput;
+  claim: IClaimInput;
+  redeem: IRedeemInput;
+  liquidate: ILiquidateInput;
+  recognize: IRecognizeBalanceInput;
+  withdrawToWallet: IWithdrawToWalletInput;
+  bridge: IBridgeInput;
+  withdrawToBridge: IWithdrawToBridgeInput;
+  walletDeposit: IDepositRoute;
+  walletDepositWnt: IDepositRoute;
+};
+//#endregion
+//#region ../sdk/dist/types/compact/compact.d.ts
+type IRelayRequest<K extends IActionKind = IActionKind> = K extends IActionKind ? {
+  kind: K;
+  input: IInputByKind[K];
+  intent: IIntentByKind[K];
+  signature: Hex;
+} : never;
+interface IAttestResult {
+  txHash: Hex;
+  actualRelayFee: bigint;
+}
+type IMatchmakerStatus = 'open' | 'connecting' | 'closed';
+interface ICompactOpts {
+  matchmakerUrl: string;
+  sql: IIndexerClient;
+  defaultTimeoutMs?: number;
+  settlementTimeoutMs?: number;
+}
+interface ICompact {
+  attest(request: IRelayRequest, timeoutMs?: number): Promise<IAttestResult>;
+  status: IStream<IMatchmakerStatus>;
+  isOpen(): boolean;
+  close(): void;
+}
+declare function createCompact(opts: ICompactOpts): ICompact;
+//#endregion
+//#region ../contracts/dist/types/errors/index.d.ts
+declare const puppetErrorAbi: readonly [{
+  readonly type: "error";
+  readonly name: "Account__UnauthorizedCaller";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Account__ForbiddenTarget";
+  readonly inputs: readonly [{
+    readonly name: "target";
+    readonly internalType: "address";
+    readonly type: "address";
+  }];
+}, {
+  readonly type: "error";
+  readonly name: "Account__NotDeployed";
+  readonly inputs: readonly [{
+    readonly name: "predicted";
+    readonly internalType: "address";
+    readonly type: "address";
+  }];
+}, {
+  readonly type: "error";
+  readonly name: "Share__InvalidImpl";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Account__InvalidUser";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Account__InvalidBaseTokenId";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Account__InvalidSignature";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Account__Shortfall";
+  readonly inputs: readonly [{
+    readonly name: "token";
+    readonly internalType: "address";
+    readonly type: "address";
+  }, {
+    readonly name: "actual";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }, {
+    readonly name: "expected";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }];
+}, {
+  readonly type: "error";
+  readonly name: "Account__OutflowExceedsSigned";
+  readonly inputs: readonly [{
+    readonly name: "amountOut";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }, {
+    readonly name: "signedSum";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }];
+}, {
+  readonly type: "error";
+  readonly name: "Account__UnauthorizedDeploy";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Route__Unauthorized";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Deposit__ZeroAmount";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Module__InvalidAuthority";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Module__CallerNotAuthority";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Module__Reentrant";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Access__Unauthorized";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Permission__Unauthorized";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Dictate__ContractNotRegistered";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Dictate__InvalidOwner";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Dictate__Unauthorized";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Register__InvalidImpl";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Register__InvalidHubToken";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Register__SelfHubTokenOnSpoke";
+  readonly inputs: readonly [{
+    readonly name: "chainId";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }, {
+    readonly name: "token";
+    readonly internalType: "address";
+    readonly type: "address";
+  }];
+}, {
+  readonly type: "error";
+  readonly name: "Register__TokenSwapForbidden";
+  readonly inputs: readonly [{
+    readonly name: "tokenId";
+    readonly internalType: "bytes32";
+    readonly type: "bytes32";
+  }, {
+    readonly name: "registered";
+    readonly internalType: "address";
+    readonly type: "address";
+  }, {
+    readonly name: "attempted";
+    readonly internalType: "address";
+    readonly type: "address";
+  }];
+}, {
+  readonly type: "error";
+  readonly name: "Register__UnknownBaseTokenId";
+  readonly inputs: readonly [{
+    readonly name: "baseTokenId";
+    readonly internalType: "bytes32";
+    readonly type: "bytes32";
+  }];
+}, {
+  readonly type: "error";
+  readonly name: "Register__WntNotSet";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Gate__InvalidModule";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Intent__InvalidChainId";
+  readonly inputs: readonly [{
+    readonly name: "signed";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }, {
+    readonly name: "expected";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }];
+}, {
+  readonly type: "error";
+  readonly name: "Intent__StaleSignature";
+  readonly inputs: readonly [{
+    readonly name: "signedBlock";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }, {
+    readonly name: "currentBlock";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }, {
+    readonly name: "maxBlockDelay";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }];
+}, {
+  readonly type: "error";
+  readonly name: "Intent__ExpiredDeadline";
+  readonly inputs: readonly [{
+    readonly name: "deadline";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }, {
+    readonly name: "currentTimestamp";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }];
+}, {
+  readonly type: "error";
+  readonly name: "Intent__TokenNotRegistered";
+  readonly inputs: readonly [{
+    readonly name: "baseTokenId";
+    readonly internalType: "bytes32";
+    readonly type: "bytes32";
+  }];
+}, {
+  readonly type: "error";
+  readonly name: "Intent__TokenMismatch";
+  readonly inputs: readonly [{
+    readonly name: "baseTokenId";
+    readonly internalType: "bytes32";
+    readonly type: "bytes32";
+  }, {
+    readonly name: "expected";
+    readonly internalType: "address";
+    readonly type: "address";
+  }, {
+    readonly name: "actual";
+    readonly internalType: "address";
+    readonly type: "address";
+  }];
+}, {
+  readonly type: "error";
+  readonly name: "Intent__AmountExceedsCap";
+  readonly inputs: readonly [{
+    readonly name: "amount";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }, {
+    readonly name: "cap";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }];
+}, {
+  readonly type: "error";
+  readonly name: "Intent__RelayFeeExceedsCap";
+  readonly inputs: readonly [{
+    readonly name: "actual";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }, {
+    readonly name: "cap";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }];
+}, {
+  readonly type: "error";
+  readonly name: "Intent__RelayFeeRatioExceeded";
+  readonly inputs: readonly [{
+    readonly name: "actual";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }, {
+    readonly name: "amount";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }, {
+    readonly name: "maxBps";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }];
+}, {
+  readonly type: "error";
+  readonly name: "Allocate__ZeroAmount";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Allocate__ZeroAcceptableNav";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Allocate__PreMintSupplyMismatch";
+  readonly inputs: readonly [{
+    readonly name: "current";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }, {
+    readonly name: "expected";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }];
+}, {
+  readonly type: "error";
+  readonly name: "Allocate__PuppetListNotSorted";
+  readonly inputs: readonly [{
+    readonly name: "prev";
+    readonly internalType: "address";
+    readonly type: "address";
+  }, {
+    readonly name: "curr";
+    readonly internalType: "address";
+    readonly type: "address";
+  }];
+}, {
+  readonly type: "error";
+  readonly name: "Allocate__ListLengthMismatch";
+  readonly inputs: readonly [{
+    readonly name: "puppetsLen";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }, {
+    readonly name: "bodiesLen";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }, {
+    readonly name: "sigsLen";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }];
+}, {
+  readonly type: "error";
+  readonly name: "Subscribe__EmptyRules";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Subscribe__FundListNotSorted";
+  readonly inputs: readonly [{
+    readonly name: "prev";
+    readonly internalType: "address";
+    readonly type: "address";
+  }, {
+    readonly name: "curr";
+    readonly internalType: "address";
+    readonly type: "address";
+  }];
+}, {
+  readonly type: "error";
+  readonly name: "Subscribe__SelfSubscribe";
+  readonly inputs: readonly [{
+    readonly name: "user";
+    readonly internalType: "address";
+    readonly type: "address";
+  }];
+}, {
+  readonly type: "error";
+  readonly name: "Share__ZeroShares";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Share__ZeroStakeAdded";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Share__MasterCannotSell";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Share__Empty";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Share__InsufficientClaimable";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Share__RelayFeeTooHigh";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Share__NoStakeToCredit";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Share__CreditTooSmall";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Share__PoolDegraded";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Share__FundClosed";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Share__NotCreated";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Share__MasterMismatch";
+  readonly inputs: readonly [{
+    readonly name: "derived";
+    readonly internalType: "address";
+    readonly type: "address";
+  }, {
+    readonly name: "declared";
+    readonly internalType: "address";
+    readonly type: "address";
+  }];
+}, {
+  readonly type: "error";
+  readonly name: "Redeem__ZeroAcceptableNav";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Redeem__NothingToRetire";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Redeem__RelayFeeTooHigh";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Redeem__MasterFractionDecreased";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Redeem__DrainExceedsQueue";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "ShareToken__NotIssuer";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "ShareToken__NotHubChain";
+  readonly inputs: readonly [{
+    readonly name: "expected";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }, {
+    readonly name: "current";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }];
+}, {
+  readonly type: "error";
+  readonly name: "Deposit__NothingToWithdraw";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Deposit__NothingToRecord";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Deposit__NothingToBridge";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Deposit__InsufficientBalance";
+  readonly inputs: readonly [{
+    readonly name: "balance";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }, {
+    readonly name: "required";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }];
+}, {
+  readonly type: "error";
+  readonly name: "Deposit__RelayFeeTooHigh";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Deposit__ZeroBridgeOutput";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "Deposit__SameChainBridge";
+  readonly inputs: readonly [{
+    readonly name: "destinationChainId";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }];
+}, {
+  readonly type: "error";
+  readonly name: "Deposit__InvalidDestinationChain";
+  readonly inputs: readonly [{
+    readonly name: "expected";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }, {
+    readonly name: "provided";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }];
+}, {
+  readonly type: "error";
+  readonly name: "TransferUtils__TokenTransferError";
+  readonly inputs: readonly [{
+    readonly name: "token";
+    readonly internalType: "contract IERC20";
+    readonly type: "address";
+  }, {
+    readonly name: "receiver";
+    readonly internalType: "address";
+    readonly type: "address";
+  }, {
+    readonly name: "amount";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }];
+}, {
+  readonly type: "error";
+  readonly name: "TransferUtils__TokenTransferFromError";
+  readonly inputs: readonly [{
+    readonly name: "token";
+    readonly internalType: "contract IERC20";
+    readonly type: "address";
+  }, {
+    readonly name: "from";
+    readonly internalType: "address";
+    readonly type: "address";
+  }, {
+    readonly name: "to";
+    readonly internalType: "address";
+    readonly type: "address";
+  }, {
+    readonly name: "amount";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }];
+}, {
+  readonly type: "error";
+  readonly name: "TransferUtils__InvalidReceiver";
+  readonly inputs: readonly [];
+}, {
+  readonly type: "error";
+  readonly name: "TransferUtils__EmptyTokenTransferGasLimit";
+  readonly inputs: readonly [{
+    readonly name: "token";
+    readonly internalType: "contract IERC20";
+    readonly type: "address";
+  }];
+}, {
+  readonly type: "error";
+  readonly name: "NonceLib__InvalidNonceForAccount";
+  readonly inputs: readonly [{
+    readonly name: "account";
+    readonly internalType: "address";
+    readonly type: "address";
+  }, {
+    readonly name: "nonce";
+    readonly internalType: "uint256";
+    readonly type: "uint256";
+  }];
+}];
+//#endregion
+//#region ../../node_modules/.bun/abitype@1.2.4+e016764623ac6761/node_modules/abitype/dist/types/register.d.ts
+interface Register {}
+type ResolvedRegister = {
+  /**
+   * TypeScript type to use for `address` values
+   * @default `0x${string}`
+   */
+  addressType: Register extends {
+    addressType: infer type;
+  } ? type : Register extends {
+    AddressType: infer type;
+  } ? type : DefaultRegister['addressType'];
+  /**
+   * TypeScript type to use for `int<M>` and `uint<M>` values, where `M > 48`
+   * @default bigint
+   */
+  bigIntType: Register extends {
+    bigIntType: infer type;
+  } ? type : Register extends {
+    BigIntType: infer type;
+  } ? type : DefaultRegister['bigIntType'];
+  /**
+   * TypeScript type to use for `bytes` values
+   * @default { inputs: `0x${string}`; outputs: `0x${string}`; }
+   */
+  bytesType: Register extends {
+    bytesType: infer type extends {
+      inputs: unknown;
+      outputs: unknown;
+    };
+  } ? type : Register extends {
+    BytesType: infer type extends {
+      inputs: unknown;
+      outputs: unknown;
+    };
+  } ? type : DefaultRegister['bytesType'];
+  /**
+   * TypeScript type to use for `int<M>` and `uint<M>` values, where `M <= 48`
+   * @default number
+   */
+  intType: Register extends {
+    intType: infer type;
+  } ? type : Register extends {
+    IntType: infer type;
+  } ? type : DefaultRegister['intType'];
+  /**
+   * Maximum depth for nested array types (e.g. string[][])
+   *
+   * Note: You probably only want to set this to a specific number if parsed types are returning as `unknown`
+   * and you want to figure out why. If you set this, you should probably also reduce `FixedArrayMaxLength`.
+   *
+   * @default false
+   */
+  arrayMaxDepth: Register extends {
+    arrayMaxDepth: infer type extends number | false;
+  } ? type : Register extends {
+    ArrayMaxDepth: infer type extends number | false;
+  } ? type : DefaultRegister['arrayMaxDepth'];
+  /**
+   * Lower bound for fixed array length
+   * @default 1
+   */
+  fixedArrayMinLength: Register extends {
+    fixedArrayMinLength: infer type extends number;
+  } ? type : Register extends {
+    FixedArrayMinLength: infer type extends number;
+  } ? type : DefaultRegister['fixedArrayMinLength'];
+  /**
+   * Upper bound for fixed array length
+   * @default 99
+   */
+  fixedArrayMaxLength: Register extends {
+    fixedArrayMaxLength: infer type extends number;
+  } ? type : Register extends {
+    FixedArrayMaxLength: infer type extends number;
+  } ? type : DefaultRegister['fixedArrayMaxLength'];
+  /**
+   * Enables named tuple generation in {@link AbiParametersToPrimitiveTypes} for common ABI parameter names.
+   *
+   * @default false
+   */
+  experimental_namedTuples: Register extends {
+    experimental_namedTuples: infer type extends boolean;
+  } ? type : DefaultRegister['experimental_namedTuples'];
+  /**
+   * When set, validates {@link AbiParameter}'s `type` against {@link AbiType}
+   *
+   * Note: You probably only want to set this to `true` if parsed types are returning as `unknown`
+   * and you want to figure out why.
+   *
+   * @default false
+   */
+  strictAbiType: Register extends {
+    strictAbiType: infer type extends boolean;
+  } ? type : Register extends {
+    StrictAbiType: infer type extends boolean;
+  } ? type : DefaultRegister['strictAbiType']; /** @deprecated Use `addressType` instead */
+  AddressType: ResolvedRegister['addressType']; /** @deprecated Use `addressType` instead */
+  BigIntType: ResolvedRegister['bigIntType']; /** @deprecated Use `bytesType` instead */
+  BytesType: ResolvedRegister['bytesType']; /** @deprecated Use `intType` instead */
+  IntType: ResolvedRegister['intType']; /** @deprecated Use `arrayMaxDepth` instead */
+  ArrayMaxDepth: ResolvedRegister['arrayMaxDepth']; /** @deprecated Use `fixedArrayMinLength` instead */
+  FixedArrayMinLength: ResolvedRegister['fixedArrayMinLength']; /** @deprecated Use `fixedArrayMaxLength` instead */
+  FixedArrayMaxLength: ResolvedRegister['fixedArrayMaxLength']; /** @deprecated Use `strictAbiType` instead */
+  StrictAbiType: ResolvedRegister['strictAbiType'];
+};
+type DefaultRegister = {
+  /** Maximum depth for nested array types (e.g. string[][]) */arrayMaxDepth: false; /** Lower bound for fixed array length */
+  fixedArrayMinLength: 1; /** Upper bound for fixed array length */
+  fixedArrayMaxLength: 99; /** TypeScript type to use for `address` values */
+  addressType: `0x${string}`; /** TypeScript type to use for `bytes` values */
+  bytesType: {
+    /** TypeScript type to use for `bytes` input values */inputs: `0x${string}`; /** TypeScript type to use for `bytes` output values */
+    outputs: `0x${string}`;
+  }; /** TypeScript type to use for `int<M>` and `uint<M>` values, where `M > 48` */
+  bigIntType: bigint; /** TypeScript type to use for `int<M>` and `uint<M>` values, where `M <= 48` */
+  intType: number; /** Enables named tuple generation in {@link AbiParametersToPrimitiveTypes} for common ABI parameter names */
+  experimental_namedTuples: false; /** When set, validates {@link AbiParameter}'s `type` against {@link AbiType} */
+  strictAbiType: false; /** @deprecated Use `arrayMaxDepth` instead */
+  ArrayMaxDepth: DefaultRegister['arrayMaxDepth']; /** @deprecated Use `fixedArrayMinLength` instead */
+  FixedArrayMinLength: DefaultRegister['fixedArrayMinLength']; /** @deprecated Use `fixedArrayMaxLength` instead */
+  FixedArrayMaxLength: DefaultRegister['fixedArrayMaxLength']; /** @deprecated Use `addressType` instead */
+  AddressType: DefaultRegister['addressType']; /** @deprecated Use `bytesType` instead */
+  BytesType: {
+    inputs: DefaultRegister['bytesType']['inputs'];
+    outputs: DefaultRegister['bytesType']['outputs'];
+  }; /** @deprecated Use `bigIntType` instead */
+  BigIntType: DefaultRegister['bigIntType']; /** @deprecated Use `intType` instead */
+  IntType: DefaultRegister['intType']; /** @deprecated Use `strictAbiType` instead */
+  StrictAbiType: DefaultRegister['strictAbiType'];
+};
+//#endregion
+//#region ../../node_modules/.bun/abitype@1.2.4+e016764623ac6761/node_modules/abitype/dist/types/types.d.ts
+/**
+ * Prints custom error message
+ *
+ * @param messages - Error message
+ * @returns Custom error message
+ *
+ * @example
+ * type Result = Error<'Custom error message'>
+ * //   ^? type Result = ['Error: Custom error message']
+ */
+type Error$1<messages extends string | string[]> = messages extends string ? [`Error: ${messages}`] : { [key in keyof messages]: messages[key] extends infer message extends string ? `Error: ${message}` : never };
+/**
+ * Merges two object types into new type
+ *
+ * @param object1 - Object to merge into
+ * @param object2 - Object to merge and override keys from {@link object1}
+ * @returns New object type with keys from {@link object1} and {@link object2}. If a key exists in both {@link object1} and {@link object2}, the key from {@link object2} will be used.
+ *
+ * @example
+ * type Result = Merge<{ foo: string }, { foo: number; bar: string }>
+ * //   ^? type Result = { foo: number; bar: string }
+ */
+type Merge<object1, object2> = Omit<object1, keyof object2> & object2;
+/**
+ * Combines members of an intersection into a readable type.
+ *
+ * @link https://twitter.com/mattpocockuk/status/1622730173446557697?s=20&t=NdpAcmEFXY01xkqU3KO0Mg
+ * @example
+ * type Result = Pretty<{ a: string } | { b: string } | { c: number, d: bigint }>
+ * //   ^? type Result = { a: string; b: string; c: number; d: bigint }
+ */
+type Pretty<type> = { [key in keyof type]: type[key] } & unknown;
+/**
+ * Creates range between two positive numbers using [tail recursion](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-5.html#tail-recursion-elimination-on-conditional-types).
+ *
+ * @param start - Number to start range
+ * @param stop - Number to end range
+ * @returns Array with inclusive range from {@link start} to {@link stop}
+ *
+ * @example
+ * type Result = Range<1, 3>
+ * //   ^? type Result = [1, 2, 3]
+ */
+type Range<start extends number, stop extends number, result extends number[] = [], padding extends 0[] = [], current extends number = [...padding, ...result]['length'] & number> = current extends stop ? current extends start ? [current] : result extends [] ? [] : [...result, current] : current extends start ? Range<start, stop, [current], padding> : result extends [] ? Range<start, stop, [], [...padding, 0]> : Range<start, stop, [...result, current], padding>;
+/**
+ * Create tuple of {@link type} type with {@link size} size
+ *
+ * @param Type - Type of tuple
+ * @param Size - Size of tuple
+ * @returns Tuple of {@link type} type with {@link size} size
+ *
+ * @example
+ * type Result = Tuple<string, 2>
+ * //   ^? type Result = [string, string]
+ */
+type Tuple<type, size extends number> = size extends size ? number extends size ? type[] : _TupleOf<type, size, []> : never;
+type _TupleOf<length, size extends number, acc extends readonly unknown[]> = acc['length'] extends size ? acc : _TupleOf<length, size, readonly [length, ...acc]>;
+//#endregion
+//#region ../../node_modules/.bun/abitype@1.2.4+e016764623ac6761/node_modules/abitype/dist/types/abi.d.ts
+type MBytes = '' | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32;
+type MBits = '' | 8 | 16 | 24 | 32 | 40 | 48 | 56 | 64 | 72 | 80 | 88 | 96 | 104 | 112 | 120 | 128 | 136 | 144 | 152 | 160 | 168 | 176 | 184 | 192 | 200 | 208 | 216 | 224 | 232 | 240 | 248 | 256;
+type SolidityAddress = 'address';
+type SolidityBool = 'bool';
+type SolidityBytes = `bytes${MBytes}`;
+type SolidityFunction = 'function';
+type SolidityString = 'string';
+type SolidityTuple = 'tuple';
+type SolidityInt = `${'u' | ''}int${MBits}`;
+type SolidityFixedArrayRange = Range<ResolvedRegister['fixedArrayMinLength'], ResolvedRegister['fixedArrayMaxLength']>[number];
+type SolidityFixedArraySizeLookup = { [Prop in SolidityFixedArrayRange as `${Prop}`]: Prop };
+/**
+ * Recursively build arrays up to maximum depth
+ * or use a more broad type when maximum depth is switched "off"
+ */
+type _BuildArrayTypes<T extends string, Depth extends readonly number[] = []> = ResolvedRegister['arrayMaxDepth'] extends false ? `${T}[${string}]` : Depth['length'] extends ResolvedRegister['arrayMaxDepth'] ? T : T extends `${any}[${SolidityFixedArrayRange | ''}]` ? _BuildArrayTypes<T | `${T}[${SolidityFixedArrayRange | ''}]`, [...Depth, 1]> : _BuildArrayTypes<`${T}[${SolidityFixedArrayRange | ''}]`, [...Depth, 1]>;
+type SolidityArrayWithoutTuple = _BuildArrayTypes<SolidityAddress | SolidityBool | SolidityBytes | SolidityFunction | SolidityInt | SolidityString>;
+type SolidityArrayWithTuple = _BuildArrayTypes<SolidityTuple>;
+type SolidityArray = SolidityArrayWithoutTuple | SolidityArrayWithTuple;
+type AbiType = SolidityArray | SolidityAddress | SolidityBool | SolidityBytes | SolidityFunction | SolidityInt | SolidityString | SolidityTuple;
+type ResolvedAbiType = ResolvedRegister['strictAbiType'] extends true ? AbiType : string;
+type AbiInternalType = ResolvedAbiType | `address ${string}` | `contract ${string}` | `enum ${string}` | `struct ${string}`;
+type AbiParameter = Pretty<{
+  type: ResolvedAbiType;
+  name?: string | undefined; /** Representation used by Solidity compiler */
+  internalType?: AbiInternalType | undefined;
+} & ({
+  type: Exclude<ResolvedAbiType, SolidityTuple | SolidityArrayWithTuple>;
+} | {
+  type: SolidityTuple | SolidityArrayWithTuple;
+  components: readonly AbiParameter[];
+})>;
+type AbiEventParameter = AbiParameter & {
+  indexed?: boolean | undefined;
+};
+/**
+ * State mutability for {@link AbiFunction}
+ *
+ * @see https://docs.soliditylang.org/en/latest/contracts.html#state-mutability
+ */
+type AbiStateMutability = 'pure' | 'view' | 'nonpayable' | 'payable';
+/** Kind of {@link AbiParameter} */
+type AbiParameterKind = 'inputs' | 'outputs';
+/** ABI ["function"](https://docs.soliditylang.org/en/latest/abi-spec.html#json) type */
+type AbiFunction = {
+  type: 'function';
+  /**
+   * @deprecated use `pure` or `view` from {@link AbiStateMutability} instead
+   * @see https://github.com/ethereum/solidity/issues/992
+   */
+  constant?: boolean | undefined;
+  /**
+   * @deprecated Vyper used to provide gas estimates
+   * @see https://github.com/vyperlang/vyper/issues/2151
+   */
+  gas?: number | undefined;
+  inputs: readonly AbiParameter[];
+  name: string;
+  outputs: readonly AbiParameter[];
+  /**
+   * @deprecated use `payable` or `nonpayable` from {@link AbiStateMutability} instead
+   * @see https://github.com/ethereum/solidity/issues/992
+   */
+  payable?: boolean | undefined;
+  stateMutability: AbiStateMutability;
+};
+/** ABI ["constructor"](https://docs.soliditylang.org/en/latest/abi-spec.html#json) type */
+type AbiConstructor = {
+  type: 'constructor';
+  inputs: readonly AbiParameter[];
+  /**
+   * @deprecated use `payable` or `nonpayable` from {@link AbiStateMutability} instead
+   * @see https://github.com/ethereum/solidity/issues/992
+   */
+  payable?: boolean | undefined;
+  stateMutability: Extract<AbiStateMutability, 'payable' | 'nonpayable'>;
+};
+/** ABI ["fallback"](https://docs.soliditylang.org/en/latest/abi-spec.html#json) type */
+type AbiFallback = {
+  type: 'fallback';
+  /**
+   * @deprecated use `payable` or `nonpayable` from {@link AbiStateMutability} instead
+   * @see https://github.com/ethereum/solidity/issues/992
+   */
+  payable?: boolean | undefined;
+  stateMutability: Extract<AbiStateMutability, 'payable' | 'nonpayable'>;
+};
+/** ABI ["receive"](https://docs.soliditylang.org/en/latest/contracts.html#receive-ether-function) type */
+type AbiReceive = {
+  type: 'receive';
+  stateMutability: Extract<AbiStateMutability, 'payable'>;
+};
+/** ABI ["event"](https://docs.soliditylang.org/en/latest/abi-spec.html#events) type */
+type AbiEvent = {
+  type: 'event';
+  anonymous?: boolean | undefined;
+  inputs: readonly AbiEventParameter[];
+  name: string;
+};
+/** ABI ["error"](https://docs.soliditylang.org/en/latest/abi-spec.html#errors) type */
+type AbiError = {
+  type: 'error';
+  inputs: readonly AbiParameter[];
+  name: string;
+};
+/**
+ * Contract [ABI Specification](https://docs.soliditylang.org/en/latest/abi-spec.html#json)
+ */
+type Abi = readonly (AbiConstructor | AbiError | AbiEvent | AbiFallback | AbiFunction | AbiReceive)[];
+//#endregion
+//#region ../../node_modules/.bun/abitype@1.2.4+e016764623ac6761/node_modules/abitype/dist/types/generated.d.ts
+interface AbiParameterTupleNameLookup<type> extends Record<string, [type]> {
+  _a: [_a: type];
+  _acceptablePrice: [_acceptablePrice: type];
+  _account: [_account: type];
+  _accounts: [_accounts: type];
+  _action: [_action: type];
+  _actionId: [_actionId: type];
+  _active: [_active: type];
+  _adapter: [_adapter: type];
+  _adapterParams: [_adapterParams: type];
+  _add: [_add: type];
+  _addr: [_addr: type];
+  _address: [_address: type];
+  _addresses: [_addresses: type];
+  _admin: [_admin: type];
+  _agent: [_agent: type];
+  _aggregator: [_aggregator: type];
+  _allocPoint: [_allocPoint: type];
+  _allow: [_allow: type];
+  _allowed: [_allowed: type];
+  _amm: [_amm: type];
+  _amount: [_amount: type];
+  _amountIn: [_amountIn: type];
+  _amountOut: [_amountOut: type];
+  _amountOutMin: [_amountOutMin: type];
+  _amountSetToken: [_amountSetToken: type];
+  _amounts: [_amounts: type];
+  _amt: [_amt: type];
+  _app: [_app: type];
+  _approved: [_approved: type];
+  _args: [_args: type];
+  _asset: [_asset: type];
+  _assetAddr: [_assetAddr: type];
+  _assetId: [_assetId: type];
+  _assets: [_assets: type];
+  _attribute: [_attribute: type];
+  _auctionId: [_auctionId: type];
+  _avatar: [_avatar: type];
+  _b: [_b: type];
+  _balance: [_balance: type];
+  _balances: [_balances: type];
+  _base: [_base: type];
+  _baseToken: [_baseToken: type];
+  _baseURI: [_baseURI: type];
+  _batch: [_batch: type];
+  _batchId: [_batchId: type];
+  _beneficiary: [_beneficiary: type];
+  _bidId: [_bidId: type];
+  _block: [_block: type];
+  _blockNumber: [_blockNumber: type];
+  _bool: [_bool: type];
+  _borrowAmount: [_borrowAmount: type];
+  _borrower: [_borrower: type];
+  _bps: [_bps: type];
+  _bridge: [_bridge: type];
+  _bridgeData: [_bridgeData: type];
+  _burnFee: [_burnFee: type];
+  _burn_amount: [_burn_amount: type];
+  _buyFee: [_buyFee: type];
+  _buyInAmount: [_buyInAmount: type];
+  _buyer: [_buyer: type];
+  _c: [_c: type];
+  _cType: [_cType: type];
+  _callData: [_callData: type];
+  _calldata: [_calldata: type];
+  _caller: [_caller: type];
+  _campaignId: [_campaignId: type];
+  _cap: [_cap: type];
+  _category: [_category: type];
+  _categoryId: [_categoryId: type];
+  _ccy: [_ccy: type];
+  _cdpId: [_cdpId: type];
+  _chainId: [_chainId: type];
+  _cid: [_cid: type];
+  _claim: [_claim: type];
+  _claimId: [_claimId: type];
+  _claimer: [_claimer: type];
+  _clanId: [_clanId: type];
+  _code: [_code: type];
+  _collateral: [_collateral: type];
+  _collateralAddress: [_collateralAddress: type];
+  _collateralAmount: [_collateralAmount: type];
+  _collateralAsset: [_collateralAsset: type];
+  _collateralDelta: [_collateralDelta: type];
+  _collateralIndex: [_collateralIndex: type];
+  _collateralToken: [_collateralToken: type];
+  _collateralType: [_collateralType: type];
+  _collaterals: [_collaterals: type];
+  _collection: [_collection: type];
+  _collectionId: [_collectionId: type];
+  _component: [_component: type];
+  _compound: [_compound: type];
+  _comptrollerProxy: [_comptrollerProxy: type];
+  _config: [_config: type];
+  _contract: [_contract: type];
+  _contractAddress: [_contractAddress: type];
+  _contractName: [_contractName: type];
+  _contractURI: [_contractURI: type];
+  _contracts: [_contracts: type];
+  _contributor: [_contributor: type];
+  _controller: [_controller: type];
+  _cost: [_cost: type];
+  _count: [_count: type];
+  _creator: [_creator: type];
+  _currency: [_currency: type];
+  _dao: [_dao: type];
+  _data: [_data: type];
+  _date: [_date: type];
+  _day: [_day: type];
+  _days: [_days: type];
+  _deadline: [_deadline: type];
+  _debt: [_debt: type];
+  _decimals: [_decimals: type];
+  _defaultAdmin: [_defaultAdmin: type];
+  _delay: [_delay: type];
+  _delegate: [_delegate: type];
+  _delegatee: [_delegatee: type];
+  _delegator: [_delegator: type];
+  _delta: [_delta: type];
+  _denominator: [_denominator: type];
+  _deployer: [_deployer: type];
+  _deposit: [_deposit: type];
+  _depositAmount: [_depositAmount: type];
+  _depositId: [_depositId: type];
+  _depositToken: [_depositToken: type];
+  _depositor: [_depositor: type];
+  _description: [_description: type];
+  _destination: [_destination: type];
+  _dev: [_dev: type];
+  _devFee: [_devFee: type];
+  _dex: [_dex: type];
+  _discount: [_discount: type];
+  _disputeID: [_disputeID: type];
+  _distributor: [_distributor: type];
+  _domain: [_domain: type];
+  _dst: [_dst: type];
+  _dstChainId: [_dstChainId: type];
+  _dstEid: [_dstEid: type];
+  _dstPoolId: [_dstPoolId: type];
+  _duration: [_duration: type];
+  _editionId: [_editionId: type];
+  _editionNumber: [_editionNumber: type];
+  _editionSize: [_editionSize: type];
+  _eid: [_eid: type];
+  _enable: [_enable: type];
+  _enabled: [_enabled: type];
+  _end: [_end: type];
+  _endBlock: [_endBlock: type];
+  _endDate: [_endDate: type];
+  _endIndex: [_endIndex: type];
+  _endTime: [_endTime: type];
+  _endTimestamp: [_endTimestamp: type];
+  _entity: [_entity: type];
+  _entityAddress: [_entityAddress: type];
+  _epoch: [_epoch: type];
+  _epochId: [_epochId: type];
+  _erc20: [_erc20: type];
+  _eventId: [_eventId: type];
+  _evidence: [_evidence: type];
+  _exchange: [_exchange: type];
+  _executionFee: [_executionFee: type];
+  _executionFeeReceiver: [_executionFeeReceiver: type];
+  _executor: [_executor: type];
+  _expiration: [_expiration: type];
+  _expiry: [_expiry: type];
+  _extraData: [_extraData: type];
+  _factory: [_factory: type];
+  _fee: [_fee: type];
+  _feePercent: [_feePercent: type];
+  _feeRate: [_feeRate: type];
+  _feeReceiver: [_feeReceiver: type];
+  _feeRecipient: [_feeRecipient: type];
+  _feeToken: [_feeToken: type];
+  _fees: [_fees: type];
+  _flag: [_flag: type];
+  _for: [_for: type];
+  _from: [_from: type];
+  _fromToken: [_fromToken: type];
+  _futureId: [_futureId: type];
+  _game: [_game: type];
+  _gameId: [_gameId: type];
+  _gameIds: [_gameIds: type];
+  _gasLimit: [_gasLimit: type];
+  _gauge: [_gauge: type];
+  _gauges: [_gauges: type];
+  _generation: [_generation: type];
+  _governance: [_governance: type];
+  _group: [_group: type];
+  _groupId: [_groupId: type];
+  _guardian: [_guardian: type];
+  _handler: [_handler: type];
+  _hash: [_hash: type];
+  _hatId: [_hatId: type];
+  _holder: [_holder: type];
+  _hook: [_hook: type];
+  _hopData: [_hopData: type];
+  _iToken: [_iToken: type];
+  _id: [_id: type];
+  _idempotencyKey: [_idempotencyKey: type];
+  _ids: [_ids: type];
+  _idx: [_idx: type];
+  _implementation: [_implementation: type];
+  _index: [_index: type];
+  _indexToken: [_indexToken: type];
+  _indices: [_indices: type];
+  _info: [_info: type];
+  _initialOwner: [_initialOwner: type];
+  _input: [_input: type];
+  _inputToken: [_inputToken: type];
+  _inputs: [_inputs: type];
+  _integrator: [_integrator: type];
+  _interval: [_interval: type];
+  _isActive: [_isActive: type];
+  _isEnabled: [_isEnabled: type];
+  _isLong: [_isLong: type];
+  _isPaused: [_isPaused: type];
+  _issuer: [_issuer: type];
+  _itemId: [_itemId: type];
+  _itemIds: [_itemIds: type];
+  _keeper: [_keeper: type];
+  _key: [_key: type];
+  _keyHash: [_keyHash: type];
+  _l1Token: [_l1Token: type];
+  _label: [_label: type];
+  _legoId: [_legoId: type];
+  _lender: [_lender: type];
+  _lenderId: [_lenderId: type];
+  _length: [_length: type];
+  _level: [_level: type];
+  _leverage: [_leverage: type];
+  _limit: [_limit: type];
+  _linkId: [_linkId: type];
+  _liqUser: [_liqUser: type];
+  _liquidator: [_liquidator: type];
+  _liquidity: [_liquidity: type];
+  _liquidityFee: [_liquidityFee: type];
+  _listingId: [_listingId: type];
+  _loan: [_loan: type];
+  _loanId: [_loanId: type];
+  _location: [_location: type];
+  _lock: [_lock: type];
+  _lockDuration: [_lockDuration: type];
+  _lockId: [_lockId: type];
+  _long: [_long: type];
+  _lowerHint: [_lowerHint: type];
+  _lp: [_lp: type];
+  _lpAddress: [_lpAddress: type];
+  _lpAmount: [_lpAmount: type];
+  _lpToken: [_lpToken: type];
+  _manager: [_manager: type];
+  _marginDelta: [_marginDelta: type];
+  _market: [_market: type];
+  _marketId: [_marketId: type];
+  _marketIndex: [_marketIndex: type];
+  _marketKey: [_marketKey: type];
+  _marketing: [_marketing: type];
+  _marketingFee: [_marketingFee: type];
+  _maturity: [_maturity: type];
+  _max: [_max: type];
+  _maxAmount: [_maxAmount: type];
+  _maxFeePercentage: [_maxFeePercentage: type];
+  _maxPrice: [_maxPrice: type];
+  _maxSupply: [_maxSupply: type];
+  _member: [_member: type];
+  _memo: [_memo: type];
+  _merkleProof: [_merkleProof: type];
+  _merkleRoot: [_merkleRoot: type];
+  _message: [_message: type];
+  _messageId: [_messageId: type];
+  _metadata: [_metadata: type];
+  _min: [_min: type];
+  _minAmount: [_minAmount: type];
+  _minAmountOut: [_minAmountOut: type];
+  _minOut: [_minOut: type];
+  _minPrice: [_minPrice: type];
+  _minReturn: [_minReturn: type];
+  _mintAmount: [_mintAmount: type];
+  _mintPrice: [_mintPrice: type];
+  _minter: [_minter: type];
+  _mode: [_mode: type];
+  _module: [_module: type];
+  _multiplier: [_multiplier: type];
+  _n: [_n: type];
+  _name: [_name: type];
+  _names: [_names: type];
+  _new: [_new: type];
+  _newAddress: [_newAddress: type];
+  _newAmount: [_newAmount: type];
+  _newFee: [_newFee: type];
+  _newImpl: [_newImpl: type];
+  _newLimit: [_newLimit: type];
+  _newOwner: [_newOwner: type];
+  _newPrice: [_newPrice: type];
+  _newStatus: [_newStatus: type];
+  _newValue: [_newValue: type];
+  _nft: [_nft: type];
+  _nftAddress: [_nftAddress: type];
+  _nftContract: [_nftContract: type];
+  _nftContractAddress: [_nftContractAddress: type];
+  _nftID: [_nftID: type];
+  _nftId: [_nftId: type];
+  _nftIndex: [_nftIndex: type];
+  _nftTokenId: [_nftTokenId: type];
+  _nfts: [_nfts: type];
+  _node: [_node: type];
+  _nodeAddress: [_nodeAddress: type];
+  _nodeId: [_nodeId: type];
+  _nodeType: [_nodeType: type];
+  _nonce: [_nonce: type];
+  _num: [_num: type];
+  _number: [_number: type];
+  _of: [_of: type];
+  _offer: [_offer: type];
+  _offerId: [_offerId: type];
+  _offset: [_offset: type];
+  _open: [_open: type];
+  _operator: [_operator: type];
+  _option: [_option: type];
+  _optionId: [_optionId: type];
+  _options: [_options: type];
+  _oracle: [_oracle: type];
+  _order: [_order: type];
+  _orderId: [_orderId: type];
+  _orderIndex: [_orderIndex: type];
+  _orderType: [_orderType: type];
+  _origin: [_origin: type];
+  _outcome: [_outcome: type];
+  _outputToken: [_outputToken: type];
+  _owner: [_owner: type];
+  _ownerAddress: [_ownerAddress: type];
+  _owners: [_owners: type];
+  _pair: [_pair: type];
+  _pairId: [_pairId: type];
+  _pairIndex: [_pairIndex: type];
+  _pairs: [_pairs: type];
+  _param: [_param: type];
+  _parameters: [_parameters: type];
+  _params: [_params: type];
+  _participant: [_participant: type];
+  _path: [_path: type];
+  _pause: [_pause: type];
+  _paused: [_paused: type];
+  _payToken: [_payToken: type];
+  _payload: [_payload: type];
+  _paymentAmount: [_paymentAmount: type];
+  _paymentToken: [_paymentToken: type];
+  _percent: [_percent: type];
+  _percentage: [_percentage: type];
+  _period: [_period: type];
+  _permitData: [_permitData: type];
+  _phase: [_phase: type];
+  _pid: [_pid: type];
+  _pids: [_pids: type];
+  _platform: [_platform: type];
+  _player: [_player: type];
+  _playerId: [_playerId: type];
+  _plotID: [_plotID: type];
+  _point: [_point: type];
+  _pool: [_pool: type];
+  _poolAddress: [_poolAddress: type];
+  _poolID: [_poolID: type];
+  _poolId: [_poolId: type];
+  _poolManagerId: [_poolManagerId: type];
+  _poolToken: [_poolToken: type];
+  _poolTokenAddress: [_poolTokenAddress: type];
+  _pools: [_pools: type];
+  _posId: [_posId: type];
+  _position: [_position: type];
+  _positionId: [_positionId: type];
+  _positionManager: [_positionManager: type];
+  _price: [_price: type];
+  _priceData: [_priceData: type];
+  _priceFeed: [_priceFeed: type];
+  _priceInWei: [_priceInWei: type];
+  _priceUpdateData: [_priceUpdateData: type];
+  _prices: [_prices: type];
+  _productId: [_productId: type];
+  _profileId: [_profileId: type];
+  _projectId: [_projectId: type];
+  _proof: [_proof: type];
+  _proofs: [_proofs: type];
+  _prop: [_prop: type];
+  _property: [_property: type];
+  _proposal: [_proposal: type];
+  _proposalID: [_proposalID: type];
+  _proposalId: [_proposalId: type];
+  _protocolFee: [_protocolFee: type];
+  _protocolId: [_protocolId: type];
+  _provider: [_provider: type];
+  _proxy: [_proxy: type];
+  _qty: [_qty: type];
+  _quantities: [_quantities: type];
+  _quantity: [_quantity: type];
+  _questId: [_questId: type];
+  _quoteAsset: [_quoteAsset: type];
+  _r: [_r: type];
+  _raffleId: [_raffleId: type];
+  _rarity: [_rarity: type];
+  _rate: [_rate: type];
+  _ratio: [_ratio: type];
+  _realmId: [_realmId: type];
+  _reason: [_reason: type];
+  _receiver: [_receiver: type];
+  _receivers: [_receivers: type];
+  _recipient: [_recipient: type];
+  _recipients: [_recipients: type];
+  _refer: [_refer: type];
+  _referral: [_referral: type];
+  _referralCode: [_referralCode: type];
+  _referrer: [_referrer: type];
+  _refundAddress: [_refundAddress: type];
+  _registry: [_registry: type];
+  _reportId: [_reportId: type];
+  _request: [_request: type];
+  _requestId: [_requestId: type];
+  _reserve: [_reserve: type];
+  _reservePrice: [_reservePrice: type];
+  _reward: [_reward: type];
+  _rewardAmount: [_rewardAmount: type];
+  _rewardPerBlock: [_rewardPerBlock: type];
+  _rewardToken: [_rewardToken: type];
+  _rewardTokens: [_rewardTokens: type];
+  _rewarder: [_rewarder: type];
+  _rewards: [_rewards: type];
+  _rewardsToken: [_rewardsToken: type];
+  _role: [_role: type];
+  _root: [_root: type];
+  _round: [_round: type];
+  _roundID: [_roundID: type];
+  _roundId: [_roundId: type];
+  _route: [_route: type];
+  _router: [_router: type];
+  _s: [_s: type];
+  _safe: [_safe: type];
+  _saleId: [_saleId: type];
+  _salt: [_salt: type];
+  _season: [_season: type];
+  _seconds: [_seconds: type];
+  _selector: [_selector: type];
+  _sellFee: [_sellFee: type];
+  _seller: [_seller: type];
+  _sender: [_sender: type];
+  _seriesId: [_seriesId: type];
+  _set: [_set: type];
+  _setAmount: [_setAmount: type];
+  _setToken: [_setToken: type];
+  _settings: [_settings: type];
+  _share: [_share: type];
+  _shares: [_shares: type];
+  _sharesAmount: [_sharesAmount: type];
+  _side: [_side: type];
+  _sig: [_sig: type];
+  _signature: [_signature: type];
+  _signatures: [_signatures: type];
+  _signer: [_signer: type];
+  _sigs: [_sigs: type];
+  _silo: [_silo: type];
+  _size: [_size: type];
+  _sizeDelta: [_sizeDelta: type];
+  _slippage: [_slippage: type];
+  _slot: [_slot: type];
+  _source: [_source: type];
+  _spender: [_spender: type];
+  _srcAddress: [_srcAddress: type];
+  _srcChainId: [_srcChainId: type];
+  _stake: [_stake: type];
+  _stakeID: [_stakeID: type];
+  _stakeToken: [_stakeToken: type];
+  _staker: [_staker: type];
+  _stakerAddress: [_stakerAddress: type];
+  _staking: [_staking: type];
+  _stakingModuleId: [_stakingModuleId: type];
+  _stakingToken: [_stakingToken: type];
+  _start: [_start: type];
+  _startBlock: [_startBlock: type];
+  _startDate: [_startDate: type];
+  _startIndex: [_startIndex: type];
+  _startTime: [_startTime: type];
+  _startTimestamp: [_startTimestamp: type];
+  _state: [_state: type];
+  _status: [_status: type];
+  _strategies: [_strategies: type];
+  _strategist: [_strategist: type];
+  _strategy: [_strategy: type];
+  _subAccount: [_subAccount: type];
+  _subAccountId: [_subAccountId: type];
+  _subgraphDeploymentID: [_subgraphDeploymentID: type];
+  _subject: [_subject: type];
+  _subscriptionId: [_subscriptionId: type];
+  _supply: [_supply: type];
+  _swap: [_swap: type];
+  _swapData: [_swapData: type];
+  _swapRouter: [_swapRouter: type];
+  _symbol: [_symbol: type];
+  _t: [_t: type];
+  _target: [_target: type];
+  _targets: [_targets: type];
+  _taskId: [_taskId: type];
+  _team: [_team: type];
+  _teamId: [_teamId: type];
+  _threshold: [_threshold: type];
+  _tier: [_tier: type];
+  _tierId: [_tierId: type];
+  _tigAsset: [_tigAsset: type];
+  _time: [_time: type];
+  _timestamp: [_timestamp: type];
+  _to: [_to: type];
+  _toAddress: [_toAddress: type];
+  _toToken: [_toToken: type];
+  _token: [_token: type];
+  _token0: [_token0: type];
+  _token1: [_token1: type];
+  _tokenA: [_tokenA: type];
+  _tokenAddr: [_tokenAddr: type];
+  _tokenAddress: [_tokenAddress: type];
+  _tokenAddresses: [_tokenAddresses: type];
+  _tokenAmount: [_tokenAmount: type];
+  _tokenB: [_tokenB: type];
+  _tokenContract: [_tokenContract: type];
+  _tokenID: [_tokenID: type];
+  _tokenId: [_tokenId: type];
+  _tokenIds: [_tokenIds: type];
+  _tokenIn: [_tokenIn: type];
+  _tokenName: [_tokenName: type];
+  _tokenOut: [_tokenOut: type];
+  _tokenSymbol: [_tokenSymbol: type];
+  _tokenType: [_tokenType: type];
+  _tokenURI: [_tokenURI: type];
+  _tokens: [_tokens: type];
+  _total: [_total: type];
+  _totalAmount: [_totalAmount: type];
+  _totalSupply: [_totalSupply: type];
+  _tournamentId: [_tournamentId: type];
+  _trade: [_trade: type];
+  _tradeData: [_tradeData: type];
+  _trader: [_trader: type];
+  _tranche: [_tranche: type];
+  _transactionId: [_transactionId: type];
+  _transferFee: [_transferFee: type];
+  _treasury: [_treasury: type];
+  _treasuryFee: [_treasuryFee: type];
+  _trigger: [_trigger: type];
+  _triggerAboveThreshold: [_triggerAboveThreshold: type];
+  _triggerPrice: [_triggerPrice: type];
+  _troveId: [_troveId: type];
+  _type: [_type: type];
+  _underlying: [_underlying: type];
+  _underlyingAsset: [_underlyingAsset: type];
+  _universe: [_universe: type];
+  _unlockTime: [_unlockTime: type];
+  _updateData: [_updateData: type];
+  _upperHint: [_upperHint: type];
+  _uri: [_uri: type];
+  _user: [_user: type];
+  _userAddr: [_userAddr: type];
+  _userAddress: [_userAddress: type];
+  _users: [_users: type];
+  _v: [_v: type];
+  _val: [_val: type];
+  _validator: [_validator: type];
+  _validatorId: [_validatorId: type];
+  _value: [_value: type];
+  _values: [_values: type];
+  _vault: [_vault: type];
+  _vaultId: [_vaultId: type];
+  _vaultProxy: [_vaultProxy: type];
+  _vaultToken: [_vaultToken: type];
+  _vaults: [_vaults: type];
+  _verifier: [_verifier: type];
+  _version: [_version: type];
+  _vestingId: [_vestingId: type];
+  _voter: [_voter: type];
+  _wallet: [_wallet: type];
+  _walletAddress: [_walletAddress: type];
+  _week: [_week: type];
+  _weiAmount: [_weiAmount: type];
+  _weight: [_weight: type];
+  _weights: [_weights: type];
+  _weth: [_weth: type];
+  _whitelist: [_whitelist: type];
+  _who: [_who: type];
+  _withUpdate: [_withUpdate: type];
+  _withdrawAmount: [_withdrawAmount: type];
+  _worker: [_worker: type];
+  _x: [_x: type];
+  _y: [_y: type];
+  _zroPaymentAddress: [_zroPaymentAddress: type];
+  a: [a: type];
+  acceptableFixedInterestRate: [acceptableFixedInterestRate: type];
+  account: [account: type];
+  accountAddress: [accountAddress: type];
+  accountId: [accountId: type];
+  account_: [account_: type];
+  accounts: [accounts: type];
+  action: [action: type];
+  actions: [actions: type];
+  active: [active: type];
+  adapter: [adapter: type];
+  add: [add: type];
+  addr: [addr: type];
+  addr_: [addr_: type];
+  address: [address: type];
+  address_: [address_: type];
+  addresses: [addresses: type];
+  addrs: [addrs: type];
+  addy: [addy: type];
+  admin: [admin: type];
+  adr: [adr: type];
+  affiliate: [affiliate: type];
+  agent: [agent: type];
+  allocation: [allocation: type];
+  allow: [allow: type];
+  allowFailure: [allowFailure: type];
+  allowance: [allowance: type];
+  allowed: [allowed: type];
+  amm: [amm: type];
+  amount: [amount: type];
+  amount0: [amount0: type];
+  amount0Min: [amount0Min: type];
+  amount1: [amount1: type];
+  amount1Min: [amount1Min: type];
+  amountADesired: [amountADesired: type];
+  amountAMin: [amountAMin: type];
+  amountBDesired: [amountBDesired: type];
+  amountBMin: [amountBMin: type];
+  amountETHMin: [amountETHMin: type];
+  amountIn: [amountIn: type];
+  amountInMax: [amountInMax: type];
+  amountOut: [amountOut: type];
+  amountOutMin: [amountOutMin: type];
+  amountOutMinimum: [amountOutMinimum: type];
+  amountTokenDesired: [amountTokenDesired: type];
+  amountTokenMin: [amountTokenMin: type];
+  amount_: [amount_: type];
+  amounts: [amounts: type];
+  amounts_: [amounts_: type];
+  amt: [amt: type];
+  ancillaryData: [ancillaryData: type];
+  app: [app: type];
+  appId: [appId: type];
+  approveMax: [approveMax: type];
+  approved: [approved: type];
+  approver: [approver: type];
+  arg0: [arg0: type];
+  arg1: [arg1: type];
+  args: [args: type];
+  ask: [ask: type];
+  asset: [asset: type];
+  assetAddress: [assetAddress: type];
+  assetAmount: [assetAmount: type];
+  assetId: [assetId: type];
+  assetIds: [assetIds: type];
+  assetToken: [assetToken: type];
+  assetType: [assetType: type];
+  asset_: [asset_: type];
+  assets: [assets: type];
+  auctionId: [auctionId: type];
+  author: [author: type];
+  authority: [authority: type];
+  authorized: [authorized: type];
+  available: [available: type];
+  b: [b: type];
+  balance: [balance: type];
+  balances: [balances: type];
+  base: [base: type];
+  baseAmount: [baseAmount: type];
+  baseToken: [baseToken: type];
+  baseURI: [baseURI: type];
+  baseURI_: [baseURI_: type];
+  baseUri: [baseUri: type];
+  batch: [batch: type];
+  batchId: [batchId: type];
+  batchSize: [batchSize: type];
+  beneficiary: [beneficiary: type];
+  bid: [bid: type];
+  bidder: [bidder: type];
+  binStep: [binStep: type];
+  blockNumber: [blockNumber: type];
+  boardId: [boardId: type];
+  bond: [bond: type];
+  borrowAmount: [borrowAmount: type];
+  borrower: [borrower: type];
+  borrowers: [borrowers: type];
+  boxId: [boxId: type];
+  bps: [bps: type];
+  bridgeRequest: [bridgeRequest: type];
+  buffer: [buffer: type];
+  bundleId: [bundleId: type];
+  burn: [burn: type];
+  burnAmount: [burnAmount: type];
+  burner: [burner: type];
+  buy: [buy: type];
+  buyAmount: [buyAmount: type];
+  buyToken: [buyToken: type];
+  buyer: [buyer: type];
+  c: [c: type];
+  cToken: [cToken: type];
+  cTokens: [cTokens: type];
+  call: [call: type];
+  callData: [callData: type];
+  callback: [callback: type];
+  callbackData: [callbackData: type];
+  calldatas: [calldatas: type];
+  caller: [caller: type];
+  caller_: [caller_: type];
+  calls: [calls: type];
+  campaign: [campaign: type];
+  campaignId: [campaignId: type];
+  candidate: [candidate: type];
+  cap: [cap: type];
+  category: [category: type];
+  categoryId: [categoryId: type];
+  cdp: [cdp: type];
+  chainId: [chainId: type];
+  chainId_: [chainId_: type];
+  channel: [channel: type];
+  channelId: [channelId: type];
+  cityId: [cityId: type];
+  claim: [claim: type];
+  claimAmount: [claimAmount: type];
+  claimId: [claimId: type];
+  claimer: [claimer: type];
+  claims: [claims: type];
+  clone: [clone: type];
+  code: [code: type];
+  coin: [coin: type];
+  coinIndex: [coinIndex: type];
+  coinType: [coinType: type];
+  collateral: [collateral: type];
+  collateralAmount: [collateralAmount: type];
+  collateralAsset: [collateralAsset: type];
+  collateralId: [collateralId: type];
+  collateralToken: [collateralToken: type];
+  collateralType: [collateralType: type];
+  collection: [collection: type];
+  collectionAddress: [collectionAddress: type];
+  collectionId: [collectionId: type];
+  collection_: [collection_: type];
+  cometProxy: [cometProxy: type];
+  comment: [comment: type];
+  component: [component: type];
+  comptroller: [comptroller: type];
+  comptroller_: [comptroller_: type];
+  conditionId: [conditionId: type];
+  config: [config: type];
+  context: [context: type];
+  contractAddr: [contractAddr: type];
+  contractAddress: [contractAddress: type];
+  contributor: [contributor: type];
+  controller: [controller: type];
+  core: [core: type];
+  cost: [cost: type];
+  count: [count: type];
+  coverId: [coverId: type];
+  creator: [creator: type];
+  creatorContractAddress: [creatorContractAddress: type];
+  creditAccount: [creditAccount: type];
+  creditor: [creditor: type];
+  ctx: [ctx: type];
+  cup: [cup: type];
+  curr: [curr: type];
+  currency: [currency: type];
+  currencyAmount: [currencyAmount: type];
+  currencyCt: [currencyCt: type];
+  currencyId: [currencyId: type];
+  currencyKey: [currencyKey: type];
+  currencyKeys: [currencyKeys: type];
+  currency_: [currency_: type];
+  cursor: [cursor: type];
+  d: [d: type];
+  data: [data: type];
+  dataStore: [dataStore: type];
+  data_: [data_: type];
+  datas: [datas: type];
+  date: [date: type];
+  day: [day: type];
+  deadLine: [deadLine: type];
+  deadline: [deadline: type];
+  deadline_: [deadline_: type];
+  debt: [debt: type];
+  decimals: [decimals: type];
+  decimals_: [decimals_: type];
+  defaultAdmin: [defaultAdmin: type];
+  delegate: [delegate: type];
+  delegatee: [delegatee: type];
+  delegator: [delegator: type];
+  delta: [delta: type];
+  denominator: [denominator: type];
+  deployer: [deployer: type];
+  deposit: [deposit: type];
+  depositAmount: [depositAmount: type];
+  depositData: [depositData: type];
+  depositId: [depositId: type];
+  depositToken: [depositToken: type];
+  depositor: [depositor: type];
+  desc: [desc: type];
+  description: [description: type];
+  dest: [dest: type];
+  destToken: [destToken: type];
+  destination: [destination: type];
+  destinationAddress: [destinationAddress: type];
+  destinationChain: [destinationChain: type];
+  destinationChainId: [destinationChainId: type];
+  destinationDomain: [destinationDomain: type];
+  details: [details: type];
+  dev: [dev: type];
+  dexData: [dexData: type];
+  dexId: [dexId: type];
+  direction: [direction: type];
+  disabled: [disabled: type];
+  distributionId: [distributionId: type];
+  distributor: [distributor: type];
+  divisor: [divisor: type];
+  dns: [dns: type];
+  domain: [domain: type];
+  domainHash: [domainHash: type];
+  domainSeparator: [domainSeparator: type];
+  dropId: [dropId: type];
+  dsId: [dsId: type];
+  dst: [dst: type];
+  dstChainId: [dstChainId: type];
+  dungeonId: [dungeonId: type];
+  duration: [duration: type];
+  dx: [dx: type];
+  e: [e: type];
+  edition: [edition: type];
+  editionId: [editionId: type];
+  eid: [eid: type];
+  enable: [enable: type];
+  enabled: [enabled: type];
+  end: [end: type];
+  endIdx: [endIdx: type];
+  endIndex: [endIndex: type];
+  endTime: [endTime: type];
+  endTime_: [endTime_: type];
+  endTimestamp: [endTimestamp: type];
+  ens: [ens: type];
+  epoch: [epoch: type];
+  epochId: [epochId: type];
+  erc20: [erc20: type];
+  erc20Address: [erc20Address: type];
+  erc721Address: [erc721Address: type];
+  errorData: [errorData: type];
+  eth: [eth: type];
+  ethAmount: [ethAmount: type];
+  eventId: [eventId: type];
+  exchange: [exchange: type];
+  exchangeData: [exchangeData: type];
+  exchangeId: [exchangeId: type];
+  excluded: [excluded: type];
+  executor: [executor: type];
+  exempt: [exempt: type];
+  expiration: [expiration: type];
+  expirationTime: [expirationTime: type];
+  expiry: [expiry: type];
+  extension: [extension: type];
+  extraData: [extraData: type];
+  f: [f: type];
+  factory: [factory: type];
+  failures: [failures: type];
+  farmId: [farmId: type];
+  fee: [fee: type];
+  feeAmount: [feeAmount: type];
+  feeBps: [feeBps: type];
+  feeRecipient: [feeRecipient: type];
+  feeType: [feeType: type];
+  fee_: [fee_: type];
+  fees: [fees: type];
+  fid: [fid: type];
+  flag: [flag: type];
+  flags: [flags: type];
+  from: [from: type];
+  fromAmount: [fromAmount: type];
+  fromMode: [fromMode: type];
+  fromToken: [fromToken: type];
+  from_: [from_: type];
+  fund: [fund: type];
+  funder: [funder: type];
+  fyToken: [fyToken: type];
+  g: [g: type];
+  gameId: [gameId: type];
+  gas: [gas: type];
+  gasLimit: [gasLimit: type];
+  gateway: [gateway: type];
+  gateways: [gateways: type];
+  gauge: [gauge: type];
+  goodUntil: [goodUntil: type];
+  group: [group: type];
+  groupId: [groupId: type];
+  guardian: [guardian: type];
+  guildId: [guildId: type];
+  guy: [guy: type];
+  h: [h: type];
+  handler: [handler: type];
+  hash: [hash: type];
+  hashes: [hashes: type];
+  hero: [hero: type];
+  heroId: [heroId: type];
+  heroToken: [heroToken: type];
+  holder: [holder: type];
+  holders: [holders: type];
+  hook: [hook: type];
+  hookData: [hookData: type];
+  host: [host: type];
+  i: [i: type];
+  id: [id: type];
+  id_: [id_: type];
+  identifier: [identifier: type];
+  identity: [identity: type];
+  ids: [ids: type];
+  idsLength: [idsLength: type];
+  idx: [idx: type];
+  ilk: [ilk: type];
+  ilkIndex: [ilkIndex: type];
+  impl: [impl: type];
+  implementation: [implementation: type];
+  inbound_tkn: [inbound_tkn: type];
+  increase: [increase: type];
+  index: [index: type];
+  indexToken: [indexToken: type];
+  index_: [index_: type];
+  indexes: [indexes: type];
+  indices: [indices: type];
+  info: [info: type];
+  initData: [initData: type];
+  initialExchangeRateMantissa_: [initialExchangeRateMantissa_: type];
+  initialOwner: [initialOwner: type];
+  initiator: [initiator: type];
+  input: [input: type];
+  inputAmount: [inputAmount: type];
+  inputAsset: [inputAsset: type];
+  inputToken: [inputToken: type];
+  inputs: [inputs: type];
+  instanceId: [instanceId: type];
+  instrument: [instrument: type];
+  instrumentId: [instrumentId: type];
+  interestRateModel_: [interestRateModel_: type];
+  interfaceId: [interfaceId: type];
+  interval: [interval: type];
+  investor: [investor: type];
+  ipfsHash: [ipfsHash: type];
+  isActive: [isActive: type];
+  isAllowed: [isAllowed: type];
+  isEnabled: [isEnabled: type];
+  isExcluded: [isExcluded: type];
+  isLong: [isLong: type];
+  isPaused: [isPaused: type];
+  issuer: [issuer: type];
+  item: [item: type];
+  itemId: [itemId: type];
+  itemIds: [itemIds: type];
+  items: [items: type];
+  j: [j: type];
+  k: [k: type];
+  keeper: [keeper: type];
+  key: [key: type];
+  keys: [keys: type];
+  kind: [kind: type];
+  l: [l: type];
+  label: [label: type];
+  leaf: [leaf: type];
+  lender: [lender: type];
+  length: [length: type];
+  level: [level: type];
+  leverage: [leverage: type];
+  lien: [lien: type];
+  lienId: [lienId: type];
+  limit: [limit: type];
+  liquidator: [liquidator: type];
+  liquidity: [liquidity: type];
+  liquidityFee: [liquidityFee: type];
+  listingId: [listingId: type];
+  loan: [loan: type];
+  loanId: [loanId: type];
+  lock: [lock: type];
+  lockDuration: [lockDuration: type];
+  lockTime: [lockTime: type];
+  locked: [locked: type];
+  long: [long: type];
+  lp: [lp: type];
+  lpAmount: [lpAmount: type];
+  lpToken: [lpToken: type];
+  lpTokens: [lpTokens: type];
+  m: [m: type];
+  maker: [maker: type];
+  makerSignature: [makerSignature: type];
+  manager: [manager: type];
+  margin: [margin: type];
+  marginAccountID: [marginAccountID: type];
+  market: [market: type];
+  marketId: [marketId: type];
+  marketId_: [marketId_: type];
+  marketIndex: [marketIndex: type];
+  marketParams: [marketParams: type];
+  marketing: [marketing: type];
+  marketingFee: [marketingFee: type];
+  markets: [markets: type];
+  maturity: [maturity: type];
+  max: [max: type];
+  maxAmount: [maxAmount: type];
+  maxAmountIn: [maxAmountIn: type];
+  maxPrice: [maxPrice: type];
+  maxSupply: [maxSupply: type];
+  member: [member: type];
+  memo: [memo: type];
+  merchant: [merchant: type];
+  merkleProof: [merkleProof: type];
+  merkleProofs: [merkleProofs: type];
+  merkleRoot: [merkleRoot: type];
+  merkleRoot_: [merkleRoot_: type];
+  message: [message: type];
+  messageHash: [messageHash: type];
+  metadata: [metadata: type];
+  metadataURI: [metadataURI: type];
+  min: [min: type];
+  minAmount: [minAmount: type];
+  minAmountOut: [minAmountOut: type];
+  minAmounts: [minAmounts: type];
+  minBuyAmount: [minBuyAmount: type];
+  minOut: [minOut: type];
+  minPrice: [minPrice: type];
+  minReturn: [minReturn: type];
+  minReturnAmount: [minReturnAmount: type];
+  miner: [miner: type];
+  mintAmount: [mintAmount: type];
+  mintId: [mintId: type];
+  minter: [minter: type];
+  minter_: [minter_: type];
+  mode: [mode: type];
+  module: [module: type];
+  month: [month: type];
+  msgSender: [msgSender: type];
+  multiplier: [multiplier: type];
+  n: [n: type];
+  name: [name: type];
+  name_: [name_: type];
+  names: [names: type];
+  namespace: [namespace: type];
+  ne: [ne: type];
+  needed: [needed: type];
+  new: [new: type];
+  newAddress: [newAddress: type];
+  newAdmin: [newAdmin: type];
+  newAmount: [newAmount: type];
+  newContract: [newContract: type];
+  newFee: [newFee: type];
+  newImplementation: [newImplementation: type];
+  newLimit: [newLimit: type];
+  newManager: [newManager: type];
+  newMax: [newMax: type];
+  newName: [newName: type];
+  newOwner: [newOwner: type];
+  newPrice: [newPrice: type];
+  newRate: [newRate: type];
+  newRatio: [newRatio: type];
+  newRecipient: [newRecipient: type];
+  newStatus: [newStatus: type];
+  newThreshold: [newThreshold: type];
+  newValue: [newValue: type];
+  newWallet: [newWallet: type];
+  next: [next: type];
+  nextOwner: [nextOwner: type];
+  nft: [nft: type];
+  nftAddress: [nftAddress: type];
+  nftAsset: [nftAsset: type];
+  nftContract: [nftContract: type];
+  nftID: [nftID: type];
+  nftId: [nftId: type];
+  nftIds: [nftIds: type];
+  nftRecipient: [nftRecipient: type];
+  nftTokenId: [nftTokenId: type];
+  nft_: [nft_: type];
+  node: [node: type];
+  nodeID: [nodeID: type];
+  nodeId: [nodeId: type];
+  nodeIndex: [nodeIndex: type];
+  nodeOperatorId: [nodeOperatorId: type];
+  nonce: [nonce: type];
+  nonceKey: [nonceKey: type];
+  nonce_: [nonce_: type];
+  num: [num: type];
+  numToMint: [numToMint: type];
+  numTokens: [numTokens: type];
+  number: [number: type];
+  numberOfTokens: [numberOfTokens: type];
+  numerator: [numerator: type];
+  o: [o: type];
+  offer: [offer: type];
+  offerId: [offerId: type];
+  offerer: [offerer: type];
+  offset: [offset: type];
+  olKey: [olKey: type];
+  old: [old: type];
+  onBehalf: [onBehalf: type];
+  onBehalfOf: [onBehalfOf: type];
+  open: [open: type];
+  operation: [operation: type];
+  operator: [operator: type];
+  operatorId: [operatorId: type];
+  operatorIds: [operatorIds: type];
+  operators: [operators: type];
+  option: [option: type];
+  options: [options: type];
+  oracle: [oracle: type];
+  oracles: [oracles: type];
+  order: [order: type];
+  orderHash: [orderHash: type];
+  orderId: [orderId: type];
+  orderType: [orderType: type];
+  order_: [order_: type];
+  orders: [orders: type];
+  outbound_tkn: [outbound_tkn: type];
+  output: [output: type];
+  outputAmount: [outputAmount: type];
+  outputReference: [outputReference: type];
+  outputToken: [outputToken: type];
+  owner: [owner: type];
+  ownerAddress: [ownerAddress: type];
+  owner_: [owner_: type];
+  owners: [owners: type];
+  p: [p: type];
+  pToken: [pToken: type];
+  pageSize: [pageSize: type];
+  pair: [pair: type];
+  pairId: [pairId: type];
+  pairIndex: [pairIndex: type];
+  pairs: [pairs: type];
+  param: [param: type];
+  parameters: [parameters: type];
+  params: [params: type];
+  params_: [params_: type];
+  parentId: [parentId: type];
+  partner: [partner: type];
+  partyA: [partyA: type];
+  path: [path: type];
+  paths: [paths: type];
+  pause: [pause: type];
+  paused: [paused: type];
+  payee: [payee: type];
+  payer: [payer: type];
+  payload: [payload: type];
+  paymentToken: [paymentToken: type];
+  percent: [percent: type];
+  percentage: [percentage: type];
+  period: [period: type];
+  permission: [permission: type];
+  permissions: [permissions: type];
+  permit: [permit: type];
+  permitData: [permitData: type];
+  permitDeadline: [permitDeadline: type];
+  petId: [petId: type];
+  phase: [phase: type];
+  pid: [pid: type];
+  plan: [plan: type];
+  planId: [planId: type];
+  player: [player: type];
+  playerId: [playerId: type];
+  points: [points: type];
+  policyId: [policyId: type];
+  policyType: [policyType: type];
+  pool: [pool: type];
+  poolAddress: [poolAddress: type];
+  poolFee: [poolFee: type];
+  poolHash: [poolHash: type];
+  poolID: [poolID: type];
+  poolId: [poolId: type];
+  poolId_: [poolId_: type];
+  poolIndex: [poolIndex: type];
+  poolKey: [poolKey: type];
+  poolToken: [poolToken: type];
+  poolType: [poolType: type];
+  pool_: [pool_: type];
+  pools: [pools: type];
+  pos: [pos: type];
+  position: [position: type];
+  positionId: [positionId: type];
+  positions: [positions: type];
+  previous: [previous: type];
+  previousOwner: [previousOwner: type];
+  price: [price: type];
+  priceUpdateData: [priceUpdateData: type];
+  price_: [price_: type];
+  prices: [prices: type];
+  primary: [primary: type];
+  principal: [principal: type];
+  product: [product: type];
+  productId: [productId: type];
+  profileId: [profileId: type];
+  profit: [profit: type];
+  projectId: [projectId: type];
+  proof: [proof: type];
+  proof_: [proof_: type];
+  proofs: [proofs: type];
+  proposal: [proposal: type];
+  proposalId: [proposalId: type];
+  proposer: [proposer: type];
+  protocol: [protocol: type];
+  provider: [provider: type];
+  proxy: [proxy: type];
+  publicKey: [publicKey: type];
+  q: [q: type];
+  qty: [qty: type];
+  quantities: [quantities: type];
+  quantity: [quantity: type];
+  queries: [queries: type];
+  questID: [questID: type];
+  questId: [questId: type];
+  questId_: [questId_: type];
+  questionID: [questionID: type];
+  question_id: [question_id: type];
+  quorumNumber: [quorumNumber: type];
+  quote: [quote: type];
+  quoteId: [quoteId: type];
+  quoteToken: [quoteToken: type];
+  r: [r: type];
+  raffleId: [raffleId: type];
+  rarity: [rarity: type];
+  rate: [rate: type];
+  ratio: [ratio: type];
+  reason: [reason: type];
+  receiver: [receiver: type];
+  receiverAddress: [receiverAddress: type];
+  receiver_: [receiver_: type];
+  receivers: [receivers: type];
+  recipient: [recipient: type];
+  recipient_: [recipient_: type];
+  recipients: [recipients: type];
+  redeemer: [redeemer: type];
+  ref: [ref: type];
+  referral: [referral: type];
+  referralCode: [referralCode: type];
+  referralId: [referralId: type];
+  referrer: [referrer: type];
+  refund: [refund: type];
+  refundAddress: [refundAddress: type];
+  registry: [registry: type];
+  relayer: [relayer: type];
+  repayAmount: [repayAmount: type];
+  req: [req: type];
+  request: [request: type];
+  requestId: [requestId: type];
+  requestIds: [requestIds: type];
+  requester: [requester: type];
+  requests: [requests: type];
+  required: [required: type];
+  rescueOrder: [rescueOrder: type];
+  reserve: [reserve: type];
+  reserveId: [reserveId: type];
+  resolvedName: [resolvedName: type];
+  resolver: [resolver: type];
+  resourceID: [resourceID: type];
+  responses: [responses: type];
+  restricted: [restricted: type];
+  result: [result: type];
+  returnData: [returnData: type];
+  reverseName: [reverseName: type];
+  reverseResolver: [reverseResolver: type];
+  reward: [reward: type];
+  rewardAmount: [rewardAmount: type];
+  rewardToken: [rewardToken: type];
+  rewards: [rewards: type];
+  riskIndicatorsInputs: [riskIndicatorsInputs: type];
+  role: [role: type];
+  roleId: [roleId: type];
+  roles: [roles: type];
+  root: [root: type];
+  round: [round: type];
+  roundId: [roundId: type];
+  route: [route: type];
+  router: [router: type];
+  routes: [routes: type];
+  s: [s: type];
+  safe: [safe: type];
+  salt: [salt: type];
+  scId: [scId: type];
+  schainHash: [schainHash: type];
+  schainName: [schainName: type];
+  score: [score: type];
+  season: [season: type];
+  seasonId: [seasonId: type];
+  secret: [secret: type];
+  secs: [secs: type];
+  seed: [seed: type];
+  selector: [selector: type];
+  sell: [sell: type];
+  sellAmount: [sellAmount: type];
+  sellOrder: [sellOrder: type];
+  sellToken: [sellToken: type];
+  seller: [seller: type];
+  sender: [sender: type];
+  seriesId: [seriesId: type];
+  serviceId: [serviceId: type];
+  settings: [settings: type];
+  share: [share: type];
+  shareAmount: [shareAmount: type];
+  shares: [shares: type];
+  sharesAmount: [sharesAmount: type];
+  sharesSubject: [sharesSubject: type];
+  shares_: [shares_: type];
+  side: [side: type];
+  sig: [sig: type];
+  signature: [signature: type];
+  signature_: [signature_: type];
+  signatures: [signatures: type];
+  signer: [signer: type];
+  size: [size: type];
+  sizeDelta: [sizeDelta: type];
+  slippage: [slippage: type];
+  slot: [slot: type];
+  slot_: [slot_: type];
+  smartVault: [smartVault: type];
+  source: [source: type];
+  sourceAmount: [sourceAmount: type];
+  sourceToken: [sourceToken: type];
+  spender: [spender: type];
+  sqrtPriceLimitX96: [sqrtPriceLimitX96: type];
+  sqrtPriceX96: [sqrtPriceX96: type];
+  src: [src: type];
+  srcAmount: [srcAmount: type];
+  srcToken: [srcToken: type];
+  stable: [stable: type];
+  stage: [stage: type];
+  stake: [stake: type];
+  stakeAmount: [stakeAmount: type];
+  stakeId: [stakeId: type];
+  stakeIndex: [stakeIndex: type];
+  staker: [staker: type];
+  stakerAddr: [stakerAddr: type];
+  stakingToken: [stakingToken: type];
+  starkKey: [starkKey: type];
+  start: [start: type];
+  startDate: [startDate: type];
+  startIdx: [startIdx: type];
+  startIndex: [startIndex: type];
+  startTime: [startTime: type];
+  startTime_: [startTime_: type];
+  startTimestamp: [startTimestamp: type];
+  state: [state: type];
+  status: [status: type];
+  statuses: [statuses: type];
+  strategies: [strategies: type];
+  strategy: [strategy: type];
+  streamId: [streamId: type];
+  strike: [strike: type];
+  subAccountId: [subAccountId: type];
+  subId: [subId: type];
+  subaccount: [subaccount: type];
+  subject: [subject: type];
+  subjectType: [subjectType: type];
+  subscriber: [subscriber: type];
+  success: [success: type];
+  superToken: [superToken: type];
+  supply: [supply: type];
+  support: [support: type];
+  swap: [swap: type];
+  swapData: [swapData: type];
+  swapFee: [swapFee: type];
+  swapFeePercentage: [swapFeePercentage: type];
+  swapId: [swapId: type];
+  swapParams: [swapParams: type];
+  swapTarget: [swapTarget: type];
+  swaps: [swaps: type];
+  sweepTokens: [sweepTokens: type];
+  symbol: [symbol: type];
+  symbol_: [symbol_: type];
+  t: [t: type];
+  tAmount: [tAmount: type];
+  tableId: [tableId: type];
+  tag: [tag: type];
+  taker: [taker: type];
+  target: [target: type];
+  targetAddress: [targetAddress: type];
+  targetContract: [targetContract: type];
+  targetToken: [targetToken: type];
+  targets: [targets: type];
+  taskId: [taskId: type];
+  tax: [tax: type];
+  taxFee: [taxFee: type];
+  term: [term: type];
+  termAuctionId: [termAuctionId: type];
+  termId: [termId: type];
+  termRepoId: [termRepoId: type];
+  theSignature: [theSignature: type];
+  threshold: [threshold: type];
+  tick: [tick: type];
+  tickLower: [tickLower: type];
+  tickSpacing: [tickSpacing: type];
+  tickUpper: [tickUpper: type];
+  ticketId: [ticketId: type];
+  tid: [tid: type];
+  tier: [tier: type];
+  tierId: [tierId: type];
+  time: [time: type];
+  timestamp: [timestamp: type];
+  to: [to: type];
+  toAddress: [toAddress: type];
+  toChain: [toChain: type];
+  toChainId: [toChainId: type];
+  toToken: [toToken: type];
+  to_: [to_: type];
+  tok: [tok: type];
+  token: [token: type];
+  token0: [token0: type];
+  token1: [token1: type];
+  tokenA: [tokenA: type];
+  tokenAddr: [tokenAddr: type];
+  tokenAddress: [tokenAddress: type];
+  tokenAddresses: [tokenAddresses: type];
+  tokenAmount: [tokenAmount: type];
+  tokenAmountIn: [tokenAmountIn: type];
+  tokenAmounts: [tokenAmounts: type];
+  tokenB: [tokenB: type];
+  tokenContract: [tokenContract: type];
+  tokenID: [tokenID: type];
+  tokenIDs: [tokenIDs: type];
+  tokenId: [tokenId: type];
+  tokenId_: [tokenId_: type];
+  tokenIds: [tokenIds: type];
+  tokenIds_: [tokenIds_: type];
+  tokenIn: [tokenIn: type];
+  tokenIndex: [tokenIndex: type];
+  tokenName: [tokenName: type];
+  tokenOut: [tokenOut: type];
+  tokenOwner: [tokenOwner: type];
+  tokenRecipient: [tokenRecipient: type];
+  tokenSymbol: [tokenSymbol: type];
+  tokenType: [tokenType: type];
+  tokenURI: [tokenURI: type];
+  tokenUri: [tokenUri: type];
+  tokenX: [tokenX: type];
+  tokenY: [tokenY: type];
+  token_: [token_: type];
+  tokenid: [tokenid: type];
+  tokens: [tokens: type];
+  tokens_: [tokens_: type];
+  tos: [tos: type];
+  total: [total: type];
+  totalAmount: [totalAmount: type];
+  totalSupply: [totalSupply: type];
+  tournamentId: [tournamentId: type];
+  trade: [trade: type];
+  trader: [trader: type];
+  traitId: [traitId: type];
+  tranche: [tranche: type];
+  trancheId: [trancheId: type];
+  transactionId: [transactionId: type];
+  treasury: [treasury: type];
+  true_or_false: [true_or_false: type];
+  ts: [ts: type];
+  ttl: [ttl: type];
+  txHash: [txHash: type];
+  typeId: [typeId: type];
+  type_: [type_: type];
+  u: [u: type];
+  underlying: [underlying: type];
+  underlyingToken: [underlyingToken: type];
+  underlying_: [underlying_: type];
+  updateData: [updateData: type];
+  updater: [updater: type];
+  uri: [uri: type];
+  uri_: [uri_: type];
+  url: [url: type];
+  usdcAmount: [usdcAmount: type];
+  user: [user: type];
+  userAddr: [userAddr: type];
+  userAddress: [userAddress: type];
+  userData: [userData: type];
+  userId: [userId: type];
+  userOp: [userOp: type];
+  user_: [user_: type];
+  users: [users: type];
+  usr: [usr: type];
+  v: [v: type];
+  vToken: [vToken: type];
+  val: [val: type];
+  validAfter: [validAfter: type];
+  validBefore: [validBefore: type];
+  validUntil: [validUntil: type];
+  validator: [validator: type];
+  validatorId: [validatorId: type];
+  value: [value: type];
+  value_: [value_: type];
+  values: [values: type];
+  valuesLength: [valuesLength: type];
+  vars: [vars: type];
+  vault: [vault: type];
+  vaultAddress: [vaultAddress: type];
+  vaultAddresses: [vaultAddresses: type];
+  vaultID: [vaultID: type];
+  vaultId: [vaultId: type];
+  vault_: [vault_: type];
+  vectorId: [vectorId: type];
+  verifier: [verifier: type];
+  version: [version: type];
+  volume: [volume: type];
+  voter: [voter: type];
+  vs: [vs: type];
+  w: [w: type];
+  wad: [wad: type];
+  wallet: [wallet: type];
+  walletAddress: [walletAddress: type];
+  wallet_: [wallet_: type];
+  wallets: [wallets: type];
+  week: [week: type];
+  weight: [weight: type];
+  weights: [weights: type];
+  weth: [weth: type];
+  what: [what: type];
+  whitelist: [whitelist: type];
+  whitelisted: [whitelisted: type];
+  who: [who: type];
+  withdrawAmount: [withdrawAmount: type];
+  worldId: [worldId: type];
+  wrappedToken: [wrappedToken: type];
+  x: [x: type];
+  y: [y: type];
+  year: [year: type];
+  yieldToken: [yieldToken: type];
+  z: [z: type];
+  zeroForOne: [zeroForOne: type];
+  zone: [zone: type];
+}
+//#endregion
+//#region ../../node_modules/.bun/abitype@1.2.4+e016764623ac6761/node_modules/abitype/dist/types/utils.d.ts
+/**
+ * Converts {@link AbiType} to corresponding TypeScript primitive type.
+ *
+ * Does not include full array or tuple conversion. Use {@link AbiParameterToPrimitiveType} to fully convert arrays and tuples.
+ *
+ * @param abiType - {@link AbiType} to convert to TypeScript representation
+ * @param abiParameterKind - Optional {@link AbiParameterKind} to narrow by parameter type
+ * @returns TypeScript primitive type
+ */
+type AbiTypeToPrimitiveType<abiType extends AbiType, abiParameterKind extends AbiParameterKind = AbiParameterKind> = abiType extends SolidityBytes ? PrimitiveTypeLookup[abiType][abiParameterKind] : PrimitiveTypeLookup[abiType];
+interface PrimitiveTypeLookup extends SolidityIntMap, SolidityByteMap, SolidityArrayMap {
+  address: ResolvedRegister['addressType'];
+  bool: boolean;
+  function: `${ResolvedRegister['addressType']}${string}`;
+  string: string;
+  tuple: Record<string, unknown>;
+}
+type SolidityIntMap = { [_ in SolidityInt]: _ extends `${'u' | ''}int${infer bits extends keyof BitsTypeLookup}` ? BitsTypeLookup[bits] : never };
+type SolidityByteMap = { [_ in SolidityBytes]: ResolvedRegister['bytesType'] };
+type SolidityArrayMap = { [_ in SolidityArray]: readonly unknown[] };
+type GreaterThan48Bits = Exclude<MBits, 8 | 16 | 24 | 32 | 40 | 48 | NoBits>;
+type LessThanOrEqualTo48Bits = Exclude<MBits, GreaterThan48Bits | NoBits>;
+type NoBits = '';
+type BitsTypeLookup = { [key in MBits]: ResolvedRegister[key extends LessThanOrEqualTo48Bits ? 'intType' : 'bigIntType'] };
+/**
+ * Converts {@link AbiParameter} to corresponding TypeScript primitive type.
+ *
+ * @param abiParameter - {@link AbiParameter} to convert to TypeScript representation
+ * @param abiParameterKind - Optional {@link AbiParameterKind} to narrow by parameter type
+ * @returns TypeScript primitive type
+ */
+type AbiParameterToPrimitiveType<abiParameter extends AbiParameter | {
+  name: string;
+  type: unknown;
+}, abiParameterKind extends AbiParameterKind = AbiParameterKind> = abiParameter['type'] extends AbiBasicType ? AbiTypeToPrimitiveType<abiParameter['type'], abiParameterKind> : abiParameter extends {
+  type: SolidityTuple;
+  components: infer components extends readonly AbiParameter[];
+} ? AbiComponentsToPrimitiveType<components, abiParameterKind> : MaybeExtractArrayParameterType<abiParameter['type']> extends [infer head extends string, infer size] ? AbiArrayToPrimitiveType<abiParameter, abiParameterKind, head, size> : ResolvedRegister['strictAbiType'] extends true ? Error$1<`Unknown type '${abiParameter['type'] & string}'.`> : abiParameter extends {
+  components: Error$1<string>;
+} ? abiParameter['components'] : unknown;
+type AbiBasicType = Exclude<AbiType, SolidityTuple | SolidityArray>;
+type AbiComponentsToPrimitiveType<components extends readonly AbiParameter[], abiParameterKind extends AbiParameterKind> = components extends readonly [] ? [] : components[number]['name'] extends Exclude<components[number]['name'] & string, undefined | ''> ? { [component in components[number] as component['name'] & {}]: AbiParameterToPrimitiveType<component, abiParameterKind> } : { [key in keyof components]: AbiParameterToPrimitiveType<components[key], abiParameterKind> };
+type MaybeExtractArrayParameterType<type> =
+/**
+ * First, infer `Head` against a known size type (either fixed-length array value or `""`).
+ *
+ * | Input           | Head         |
+ * | --------------- | ------------ |
+ * | `string[]`      | `string`     |
+ * | `string[][][3]` | `string[][]` |
+ */
+type extends `${infer head}[${'' | `${SolidityFixedArrayRange}`}]` ? type extends `${head}[${infer size}]` ? [head, size] : undefined : undefined;
+type AbiArrayToPrimitiveType<abiParameter extends AbiParameter | {
+  name: string;
+  type: unknown;
+}, abiParameterKind extends AbiParameterKind, head extends string, size> = size extends keyof SolidityFixedArraySizeLookup ? Tuple<AbiParameterToPrimitiveType<Merge<abiParameter, {
+  type: head;
+}>, abiParameterKind>, SolidityFixedArraySizeLookup[size]> : readonly AbiParameterToPrimitiveType<Merge<abiParameter, {
+  type: head;
+}>, abiParameterKind>[];
+/**
+ * Converts array of {@link AbiParameter} to corresponding TypeScript primitive types.
+ *
+ * @param abiParameters - Array of {@link AbiParameter} to convert to TypeScript representations
+ * @param abiParameterKind - Optional {@link AbiParameterKind} to narrow by parameter type
+ * @returns Array of TypeScript primitive types
+ */
+type AbiParametersToPrimitiveTypes<abiParameters extends readonly AbiParameter[], abiParameterKind extends AbiParameterKind = AbiParameterKind, experimental_namedTuples extends boolean = ResolvedRegister['experimental_namedTuples']> = experimental_namedTuples extends true ? AbiParametersToPrimitiveTypes_named<abiParameters, abiParameterKind> : AbiParametersToPrimitiveTypes_mapped<abiParameters, abiParameterKind>;
+type AbiParametersToPrimitiveTypes_mapped<abiParameters extends readonly AbiParameter[], abiParameterKind extends AbiParameterKind = AbiParameterKind> = Pretty<{ [key in keyof abiParameters]: AbiParameterToPrimitiveType<abiParameters[key], abiParameterKind> }>;
+type AbiParametersToPrimitiveTypes_named<abiParameters extends readonly AbiParameter[], abiParameterKind extends AbiParameterKind = AbiParameterKind, acc extends readonly unknown[] = [], depth extends readonly number[] = []> = depth['length'] extends 15 ? readonly unknown[] : abiParameters extends readonly [infer head1 extends AbiParameter, infer head2 extends AbiParameter, infer head3 extends AbiParameter, infer head4 extends AbiParameter, infer head5 extends AbiParameter, infer head6 extends AbiParameter, ...infer tail extends readonly AbiParameter[]] ? AbiParametersToPrimitiveTypes_named<tail, abiParameterKind, readonly [...acc, ...ToNamedTuple<head1, abiParameterKind>, ...ToNamedTuple<head2, abiParameterKind>, ...ToNamedTuple<head3, abiParameterKind>, ...ToNamedTuple<head4, abiParameterKind>, ...ToNamedTuple<head5, abiParameterKind>, ...ToNamedTuple<head6, abiParameterKind>], [...depth, 1]> : abiParameters extends readonly [infer head1 extends AbiParameter, infer head2 extends AbiParameter, infer head3 extends AbiParameter, infer head4 extends AbiParameter, infer head5 extends AbiParameter] ? readonly [...acc, ...ToNamedTuple<head1, abiParameterKind>, ...ToNamedTuple<head2, abiParameterKind>, ...ToNamedTuple<head3, abiParameterKind>, ...ToNamedTuple<head4, abiParameterKind>, ...ToNamedTuple<head5, abiParameterKind>] : abiParameters extends readonly [infer head1 extends AbiParameter, infer head2 extends AbiParameter, infer head3 extends AbiParameter, infer head4 extends AbiParameter] ? readonly [...acc, ...ToNamedTuple<head1, abiParameterKind>, ...ToNamedTuple<head2, abiParameterKind>, ...ToNamedTuple<head3, abiParameterKind>, ...ToNamedTuple<head4, abiParameterKind>] : abiParameters extends readonly [infer head1 extends AbiParameter, infer head2 extends AbiParameter, infer head3 extends AbiParameter] ? readonly [...acc, ...ToNamedTuple<head1, abiParameterKind>, ...ToNamedTuple<head2, abiParameterKind>, ...ToNamedTuple<head3, abiParameterKind>] : abiParameters extends readonly [infer head1 extends AbiParameter, infer head2 extends AbiParameter] ? readonly [...acc, ...ToNamedTuple<head1, abiParameterKind>, ...ToNamedTuple<head2, abiParameterKind>] : abiParameters extends readonly [infer head extends AbiParameter] ? readonly [...acc, ...ToNamedTuple<head, abiParameterKind>] : acc extends readonly [] ? abiParameters extends readonly [] ? readonly [] : readonly unknown[] : acc;
+type ToNamedTuple<abiParameter extends AbiParameter, abiParameterKind extends AbiParameterKind> = unwrapName<AbiParameterToPrimitiveType<abiParameter, abiParameterKind>, abiParameter['name']>;
+type unwrapName<type, name> = name extends string ? AbiParameterTupleNameLookup<type>[name] : [type];
+/**
+ * Checks if type is {@link Abi}.
+ *
+ * @param abi - {@link Abi} to check
+ * @returns Boolean for whether {@link abi} is {@link Abi}
+ */
+/**
+ * Extracts all {@link AbiError} types from {@link Abi}.
+ *
+ * @param abi - {@link Abi} to extract errors from
+ * @returns All {@link AbiError} types from {@link Abi}
+ */
+type ExtractAbiErrors<abi extends Abi> = Extract<abi[number], {
+  type: 'error';
+}>;
+/**
+ * Extracts all {@link AbiError} names from {@link Abi}.
+ *
+ * @param abi - {@link Abi} to extract error names from
+ * @returns Union of error names
+ */
+type ExtractAbiErrorNames<abi extends Abi> = ExtractAbiErrors<abi>['name'];
+/**
+ * Extracts {@link AbiError} with name from {@link Abi}.
+ *
+ * @param abi - {@link Abi} to extract {@link AbiError} from
+ * @param errorName - String name of error to extract from {@link Abi}
+ * @returns Matching {@link AbiError}
+ */
+type ExtractAbiError<abi extends Abi, errorName extends ExtractAbiErrorNames<abi>> = Extract<ExtractAbiErrors<abi>, {
+  name: errorName;
+}>;
+//#endregion
+//#region ../sdk/dist/types/compact/error.d.ts
+declare module 'abitype' {
+  interface Register {
+    experimental_namedTuples: true;
+  }
+}
+type IErrorAbi = typeof puppetErrorAbi;
+type ICompactContractErrorName = ExtractAbiErrorNames<IErrorAbi>;
+type ICompactContractErrorArgs<N extends ICompactContractErrorName> = AbiParametersToPrimitiveTypes<ExtractAbiError<IErrorAbi, N>['inputs']>;
+type IStrikeSeverity = 'server' | 'soft' | 'hard';
+declare class CompactError extends Error {
+  readonly code: string;
+  readonly severity: IStrikeSeverity;
+  constructor(code: string, message: string, severity?: IStrikeSeverity);
+}
+declare class CompactContractError<N extends ICompactContractErrorName = ICompactContractErrorName> extends Error {
+  readonly code: N;
+  readonly args: ICompactContractErrorArgs<N>;
+  readonly severity: IStrikeSeverity;
+  constructor(code: N, args: ICompactContractErrorArgs<N>);
+}
+declare function humanizeErrorCode(code: string): string;
+declare function humanizeContractError(code: string, args: readonly unknown[]): string;
+declare function formatThrownError(err: unknown): string;
+//#endregion
+//#region src/core.d.ts
+interface IOperatorConfig {
+  baseTokenId: Hex;
+  matchmakerUrl?: string;
+  indexerUrl?: string;
+  rpcUrl?: string;
+  user?: Address;
+  signerKey?: Hex;
+  siteUrl?: string;
+  pairPort?: number;
+  dryRun?: boolean;
+}
+interface IOperatorCore {
+  user: Address;
+  signer: Address;
+  account: Address;
+  fund: Address;
+  baseTokenId: Hex;
+  token: Address;
+  publicClient: PublicClient;
+  sql: IIndexerClient;
+  compact: ICompact;
+  status: ICompact['status'];
+  isOpen: () => boolean;
+  getFundBalance: () => Promise<bigint>;
+  getFundSignedBalance: () => Promise<bigint>;
+  operate: (callList: IIAccount__Call[], transferList?: IIAccount__SignTransfer[]) => Promise<IAttestResult>;
+  close: () => void;
+}
+declare function createOperatorCore(config: IOperatorConfig): Promise<IOperatorCore>;
+//#endregion
+export { CompactError as a, humanizeErrorCode as c, ICompactOpts as d, IMatchmakerStatus as f, CompactContractError as i, IAttestResult as l, TOKEN_ID as m, IOperatorCore as n, formatThrownError as o, createCompact as p, createOperatorCore as r, humanizeContractError as s, IOperatorConfig as t, ICompact as u };