diff --git a/CHANGELOG.md b/CHANGELOG.md index ceb2a6c4..74f1353f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,13 @@ All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). +## [2.6.0] - 2024-02-26 + +### Added + +- `prepareWithdrawal` has been updated to use V2 withdrawal logic for StarkEx V4 contract. +- Add StarkEx V4 contract bindings so that SDK can interact with the contract. + ## [2.5.4] - 2024-02-20 ### Added diff --git a/package.json b/package.json index 713b2e78..2cc9ee15 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "@imtbl/core-sdk", - "version": "2.5.4", + "version": "2.6.0", "description": "Immutable Core SDK", "main": "dist/index.cjs.js", "module": "dist/index.es.js", diff --git a/src/contracts/contracts/Core.ts b/src/contracts/contracts/StarkV3.ts similarity index 99% rename from src/contracts/contracts/Core.ts rename to src/contracts/contracts/StarkV3.ts index 0dae7701..96f3bf07 100644 --- a/src/contracts/contracts/Core.ts +++ b/src/contracts/contracts/StarkV3.ts @@ -27,7 +27,7 @@ import type { OnEvent, } from "../common"; -export interface CoreInterface extends utils.Interface { +export interface StarkV3Interface extends utils.Interface { functions: { "announceAvailabilityVerifierRemovalIntent(address)": FunctionFragment; "announceVerifierRemovalIntent(address)": FunctionFragment; @@ -864,12 +864,12 @@ export type LogWithdrawalPerformedEvent = TypedEvent< export type LogWithdrawalPerformedEventFilter = TypedEventFilter; -export interface Core extends BaseContract { +export interface StarkV3 extends BaseContract { connect(signerOrProvider: Signer | Provider | string): this; attach(addressOrName: string): this; deployed(): Promise; - interface: CoreInterface; + interface: StarkV3Interface; queryFilter( event: TypedEventFilter, diff --git a/src/contracts/contracts/StarkV4.ts b/src/contracts/contracts/StarkV4.ts new file mode 100644 index 00000000..0113f226 --- /dev/null +++ b/src/contracts/contracts/StarkV4.ts @@ -0,0 +1,3940 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PayableOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, +} from "../common"; + +export interface StarkV4Interface extends utils.Interface { + functions: { + "VERSION()": FunctionFragment; + "initialize(bytes)": FunctionFragment; + "DEPOSIT_CANCEL_DELAY()": FunctionFragment; + "FREEZE_GRACE_PERIOD()": FunctionFragment; + "MAIN_GOVERNANCE_INFO_TAG()": FunctionFragment; + "MAX_FORCED_ACTIONS_REQS_PER_BLOCK()": FunctionFragment; + "MAX_VERIFIER_COUNT()": FunctionFragment; + "UNFREEZE_DELAY()": FunctionFragment; + "VERIFIER_REMOVAL_DELAY()": FunctionFragment; + "announceAvailabilityVerifierRemovalIntent(address)": FunctionFragment; + "announceVerifierRemovalIntent(address)": FunctionFragment; + "getRegisteredAvailabilityVerifiers()": FunctionFragment; + "getRegisteredVerifiers()": FunctionFragment; + "isAvailabilityVerifier(address)": FunctionFragment; + "isFrozen()": FunctionFragment; + "isVerifier(address)": FunctionFragment; + "mainAcceptGovernance()": FunctionFragment; + "mainCancelNomination()": FunctionFragment; + "mainIsGovernor(address)": FunctionFragment; + "mainNominateNewGovernor(address)": FunctionFragment; + "mainRemoveGovernor(address)": FunctionFragment; + "registerAvailabilityVerifier(address,string)": FunctionFragment; + "registerVerifier(address,string)": FunctionFragment; + "removeAvailabilityVerifier(address)": FunctionFragment; + "removeVerifier(address)": FunctionFragment; + "unFreeze()": FunctionFragment; + "defaultVaultWithdrawalLock()": FunctionFragment; + "deposit(uint256,uint256,uint256)": FunctionFragment; + "deposit(uint256,uint256,uint256,uint256)": FunctionFragment; + "depositCancel(uint256,uint256,uint256)": FunctionFragment; + "depositERC20(uint256,uint256,uint256,uint256)": FunctionFragment; + "depositEth(uint256,uint256,uint256)": FunctionFragment; + "depositNft(uint256,uint256,uint256,uint256)": FunctionFragment; + "depositNftReclaim(uint256,uint256,uint256,uint256)": FunctionFragment; + "depositReclaim(uint256,uint256,uint256)": FunctionFragment; + "getActionCount()": FunctionFragment; + "getActionHashByIndex(uint256)": FunctionFragment; + "getAssetInfo(uint256)": FunctionFragment; + "getCancellationRequest(uint256,uint256,uint256)": FunctionFragment; + "getDepositBalance(uint256,uint256,uint256)": FunctionFragment; + "getEthKey(uint256)": FunctionFragment; + "getFullWithdrawalRequest(uint256,uint256)": FunctionFragment; + "getQuantizedDepositBalance(uint256,uint256,uint256)": FunctionFragment; + "getQuantum(uint256)": FunctionFragment; + "getWithdrawalBalance(uint256,uint256)": FunctionFragment; + "isAssetRegistered(uint256)": FunctionFragment; + "isTokenAdmin(address)": FunctionFragment; + "onERC721Received(address,address,uint256,bytes)": FunctionFragment; + "orderRegistryAddress()": FunctionFragment; + "registerAndDepositERC20(address,uint256,bytes,uint256,uint256,uint256)": FunctionFragment; + "registerAndDepositEth(address,uint256,bytes,uint256,uint256)": FunctionFragment; + "registerEthAddress(address,uint256,bytes)": FunctionFragment; + "registerSender(uint256,bytes)": FunctionFragment; + "registerToken(uint256,bytes)": FunctionFragment; + "registerToken(uint256,bytes,uint256)": FunctionFragment; + "registerTokenAdmin(address)": FunctionFragment; + "unregisterTokenAdmin(address)": FunctionFragment; + "withdraw(uint256,uint256)": FunctionFragment; + "withdrawAndMint(uint256,uint256,bytes)": FunctionFragment; + "withdrawNft(uint256,uint256,uint256)": FunctionFragment; + "STARKEX_MAX_DEFAULT_VAULT_LOCK()": FunctionFragment; + "escape(uint256,uint256,uint256,uint256)": FunctionFragment; + "getLastBatchId()": FunctionFragment; + "getOrderRoot()": FunctionFragment; + "getOrderTreeHeight()": FunctionFragment; + "getSequenceNumber()": FunctionFragment; + "getVaultRoot()": FunctionFragment; + "getVaultTreeHeight()": FunctionFragment; + "isOperator(address)": FunctionFragment; + "registerOperator(address)": FunctionFragment; + "unregisterOperator(address)": FunctionFragment; + "updateState(uint256[],uint256[])": FunctionFragment; + "freezeRequest(uint256,uint256)": FunctionFragment; + "fullWithdrawalRequest(uint256,uint256)": FunctionFragment; + "depositERC20ToVault(uint256,uint256,uint256)": FunctionFragment; + "depositEthToVault(uint256,uint256)": FunctionFragment; + "getQuantizedVaultBalance(address,uint256,uint256)": FunctionFragment; + "getVaultBalance(address,uint256,uint256)": FunctionFragment; + "getVaultWithdrawalLock(address,uint256,uint256)": FunctionFragment; + "isStrictVaultBalancePolicy()": FunctionFragment; + "isVaultLocked(address,uint256,uint256)": FunctionFragment; + "lockVault(uint256,uint256,uint256)": FunctionFragment; + "setDefaultVaultWithdrawalLock(uint256)": FunctionFragment; + "withdrawFromVault(uint256,uint256,uint256)": FunctionFragment; + "updateImplementationActivationTime(address,bytes,bool)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "VERSION" + | "initialize" + | "DEPOSIT_CANCEL_DELAY" + | "FREEZE_GRACE_PERIOD" + | "MAIN_GOVERNANCE_INFO_TAG" + | "MAX_FORCED_ACTIONS_REQS_PER_BLOCK" + | "MAX_VERIFIER_COUNT" + | "UNFREEZE_DELAY" + | "VERIFIER_REMOVAL_DELAY" + | "announceAvailabilityVerifierRemovalIntent" + | "announceVerifierRemovalIntent" + | "getRegisteredAvailabilityVerifiers" + | "getRegisteredVerifiers" + | "isAvailabilityVerifier" + | "isFrozen" + | "isVerifier" + | "mainAcceptGovernance" + | "mainCancelNomination" + | "mainIsGovernor" + | "mainNominateNewGovernor" + | "mainRemoveGovernor" + | "registerAvailabilityVerifier" + | "registerVerifier" + | "removeAvailabilityVerifier" + | "removeVerifier" + | "unFreeze" + | "defaultVaultWithdrawalLock" + | "deposit(uint256,uint256,uint256)" + | "deposit(uint256,uint256,uint256,uint256)" + | "depositCancel" + | "depositERC20" + | "depositEth" + | "depositNft" + | "depositNftReclaim" + | "depositReclaim" + | "getActionCount" + | "getActionHashByIndex" + | "getAssetInfo" + | "getCancellationRequest" + | "getDepositBalance" + | "getEthKey" + | "getFullWithdrawalRequest" + | "getQuantizedDepositBalance" + | "getQuantum" + | "getWithdrawalBalance" + | "isAssetRegistered" + | "isTokenAdmin" + | "onERC721Received" + | "orderRegistryAddress" + | "registerAndDepositERC20" + | "registerAndDepositEth" + | "registerEthAddress" + | "registerSender" + | "registerToken(uint256,bytes)" + | "registerToken(uint256,bytes,uint256)" + | "registerTokenAdmin" + | "unregisterTokenAdmin" + | "withdraw" + | "withdrawAndMint" + | "withdrawNft" + | "STARKEX_MAX_DEFAULT_VAULT_LOCK" + | "escape" + | "getLastBatchId" + | "getOrderRoot" + | "getOrderTreeHeight" + | "getSequenceNumber" + | "getVaultRoot" + | "getVaultTreeHeight" + | "isOperator" + | "registerOperator" + | "unregisterOperator" + | "updateState" + | "freezeRequest" + | "fullWithdrawalRequest" + | "depositERC20ToVault" + | "depositEthToVault" + | "getQuantizedVaultBalance" + | "getVaultBalance" + | "getVaultWithdrawalLock" + | "isStrictVaultBalancePolicy" + | "isVaultLocked" + | "lockVault" + | "setDefaultVaultWithdrawalLock" + | "withdrawFromVault" + | "updateImplementationActivationTime" + ): FunctionFragment; + + encodeFunctionData(functionFragment: "VERSION", values?: undefined): string; + encodeFunctionData( + functionFragment: "initialize", + values: [BytesLike] + ): string; + encodeFunctionData( + functionFragment: "DEPOSIT_CANCEL_DELAY", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "FREEZE_GRACE_PERIOD", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "MAIN_GOVERNANCE_INFO_TAG", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "MAX_FORCED_ACTIONS_REQS_PER_BLOCK", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "MAX_VERIFIER_COUNT", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "UNFREEZE_DELAY", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "VERIFIER_REMOVAL_DELAY", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "announceAvailabilityVerifierRemovalIntent", + values: [string] + ): string; + encodeFunctionData( + functionFragment: "announceVerifierRemovalIntent", + values: [string] + ): string; + encodeFunctionData( + functionFragment: "getRegisteredAvailabilityVerifiers", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "getRegisteredVerifiers", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "isAvailabilityVerifier", + values: [string] + ): string; + encodeFunctionData(functionFragment: "isFrozen", values?: undefined): string; + encodeFunctionData(functionFragment: "isVerifier", values: [string]): string; + encodeFunctionData( + functionFragment: "mainAcceptGovernance", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "mainCancelNomination", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "mainIsGovernor", + values: [string] + ): string; + encodeFunctionData( + functionFragment: "mainNominateNewGovernor", + values: [string] + ): string; + encodeFunctionData( + functionFragment: "mainRemoveGovernor", + values: [string] + ): string; + encodeFunctionData( + functionFragment: "registerAvailabilityVerifier", + values: [string, string] + ): string; + encodeFunctionData( + functionFragment: "registerVerifier", + values: [string, string] + ): string; + encodeFunctionData( + functionFragment: "removeAvailabilityVerifier", + values: [string] + ): string; + encodeFunctionData( + functionFragment: "removeVerifier", + values: [string] + ): string; + encodeFunctionData(functionFragment: "unFreeze", values?: undefined): string; + encodeFunctionData( + functionFragment: "defaultVaultWithdrawalLock", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "deposit(uint256,uint256,uint256)", + values: [BigNumberish, BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "deposit(uint256,uint256,uint256,uint256)", + values: [BigNumberish, BigNumberish, BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "depositCancel", + values: [BigNumberish, BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "depositERC20", + values: [BigNumberish, BigNumberish, BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "depositEth", + values: [BigNumberish, BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "depositNft", + values: [BigNumberish, BigNumberish, BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "depositNftReclaim", + values: [BigNumberish, BigNumberish, BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "depositReclaim", + values: [BigNumberish, BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "getActionCount", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "getActionHashByIndex", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "getAssetInfo", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "getCancellationRequest", + values: [BigNumberish, BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "getDepositBalance", + values: [BigNumberish, BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "getEthKey", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "getFullWithdrawalRequest", + values: [BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "getQuantizedDepositBalance", + values: [BigNumberish, BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "getQuantum", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "getWithdrawalBalance", + values: [BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "isAssetRegistered", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "isTokenAdmin", + values: [string] + ): string; + encodeFunctionData( + functionFragment: "onERC721Received", + values: [string, string, BigNumberish, BytesLike] + ): string; + encodeFunctionData( + functionFragment: "orderRegistryAddress", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "registerAndDepositERC20", + values: [ + string, + BigNumberish, + BytesLike, + BigNumberish, + BigNumberish, + BigNumberish + ] + ): string; + encodeFunctionData( + functionFragment: "registerAndDepositEth", + values: [string, BigNumberish, BytesLike, BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "registerEthAddress", + values: [string, BigNumberish, BytesLike] + ): string; + encodeFunctionData( + functionFragment: "registerSender", + values: [BigNumberish, BytesLike] + ): string; + encodeFunctionData( + functionFragment: "registerToken(uint256,bytes)", + values: [BigNumberish, BytesLike] + ): string; + encodeFunctionData( + functionFragment: "registerToken(uint256,bytes,uint256)", + values: [BigNumberish, BytesLike, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "registerTokenAdmin", + values: [string] + ): string; + encodeFunctionData( + functionFragment: "unregisterTokenAdmin", + values: [string] + ): string; + encodeFunctionData( + functionFragment: "withdraw", + values: [BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "withdrawAndMint", + values: [BigNumberish, BigNumberish, BytesLike] + ): string; + encodeFunctionData( + functionFragment: "withdrawNft", + values: [BigNumberish, BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "STARKEX_MAX_DEFAULT_VAULT_LOCK", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "escape", + values: [BigNumberish, BigNumberish, BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "getLastBatchId", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "getOrderRoot", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "getOrderTreeHeight", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "getSequenceNumber", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "getVaultRoot", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "getVaultTreeHeight", + values?: undefined + ): string; + encodeFunctionData(functionFragment: "isOperator", values: [string]): string; + encodeFunctionData( + functionFragment: "registerOperator", + values: [string] + ): string; + encodeFunctionData( + functionFragment: "unregisterOperator", + values: [string] + ): string; + encodeFunctionData( + functionFragment: "updateState", + values: [BigNumberish[], BigNumberish[]] + ): string; + encodeFunctionData( + functionFragment: "freezeRequest", + values: [BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "fullWithdrawalRequest", + values: [BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "depositERC20ToVault", + values: [BigNumberish, BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "depositEthToVault", + values: [BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "getQuantizedVaultBalance", + values: [string, BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "getVaultBalance", + values: [string, BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "getVaultWithdrawalLock", + values: [string, BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "isStrictVaultBalancePolicy", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "isVaultLocked", + values: [string, BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "lockVault", + values: [BigNumberish, BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "setDefaultVaultWithdrawalLock", + values: [BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "withdrawFromVault", + values: [BigNumberish, BigNumberish, BigNumberish] + ): string; + encodeFunctionData( + functionFragment: "updateImplementationActivationTime", + values: [string, BytesLike, boolean] + ): string; + + decodeFunctionResult(functionFragment: "VERSION", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "DEPOSIT_CANCEL_DELAY", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "FREEZE_GRACE_PERIOD", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "MAIN_GOVERNANCE_INFO_TAG", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "MAX_FORCED_ACTIONS_REQS_PER_BLOCK", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "MAX_VERIFIER_COUNT", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "UNFREEZE_DELAY", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "VERIFIER_REMOVAL_DELAY", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "announceAvailabilityVerifierRemovalIntent", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "announceVerifierRemovalIntent", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getRegisteredAvailabilityVerifiers", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getRegisteredVerifiers", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "isAvailabilityVerifier", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "isFrozen", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "isVerifier", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "mainAcceptGovernance", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "mainCancelNomination", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "mainIsGovernor", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "mainNominateNewGovernor", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "mainRemoveGovernor", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "registerAvailabilityVerifier", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "registerVerifier", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "removeAvailabilityVerifier", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "removeVerifier", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "unFreeze", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "defaultVaultWithdrawalLock", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "deposit(uint256,uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "deposit(uint256,uint256,uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "depositCancel", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "depositERC20", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "depositEth", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "depositNft", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "depositNftReclaim", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "depositReclaim", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getActionCount", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getActionHashByIndex", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getAssetInfo", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getCancellationRequest", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getDepositBalance", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "getEthKey", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "getFullWithdrawalRequest", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getQuantizedDepositBalance", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "getQuantum", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "getWithdrawalBalance", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "isAssetRegistered", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "isTokenAdmin", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "onERC721Received", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "orderRegistryAddress", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "registerAndDepositERC20", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "registerAndDepositEth", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "registerEthAddress", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "registerSender", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "registerToken(uint256,bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "registerToken(uint256,bytes,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "registerTokenAdmin", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "unregisterTokenAdmin", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "withdrawAndMint", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "withdrawNft", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "STARKEX_MAX_DEFAULT_VAULT_LOCK", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "escape", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "getLastBatchId", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getOrderRoot", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getOrderTreeHeight", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getSequenceNumber", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getVaultRoot", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getVaultTreeHeight", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "isOperator", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "registerOperator", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "unregisterOperator", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "updateState", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "freezeRequest", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "fullWithdrawalRequest", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "depositERC20ToVault", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "depositEthToVault", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getQuantizedVaultBalance", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getVaultBalance", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getVaultWithdrawalLock", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "isStrictVaultBalancePolicy", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "isVaultLocked", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "lockVault", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "setDefaultVaultWithdrawalLock", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "withdrawFromVault", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "updateImplementationActivationTime", + data: BytesLike + ): Result; + + events: { + "LogFrozen()": EventFragment; + "LogNewGovernorAccepted(address)": EventFragment; + "LogNominatedGovernor(address)": EventFragment; + "LogNominationCancelled()": EventFragment; + "LogRegistered(address,string)": EventFragment; + "LogRemovalIntent(address,string)": EventFragment; + "LogRemoved(address,string)": EventFragment; + "LogRemovedGovernor(address)": EventFragment; + "LogUnFrozen()": EventFragment; + "LogDeposit(address,uint256,uint256,uint256,uint256,uint256)": EventFragment; + "LogDepositCancel(uint256,uint256,uint256)": EventFragment; + "LogDepositCancelReclaimed(uint256,uint256,uint256,uint256,uint256)": EventFragment; + "LogDepositNftCancelReclaimed(uint256,uint256,uint256,uint256,uint256)": EventFragment; + "LogMintWithdrawalPerformed(uint256,uint256,uint256,uint256,uint256)": EventFragment; + "LogMintableWithdrawalAllowed(uint256,uint256,uint256)": EventFragment; + "LogNftDeposit(address,uint256,uint256,uint256,uint256,uint256)": EventFragment; + "LogNftWithdrawalAllowed(uint256,uint256)": EventFragment; + "LogNftWithdrawalPerformed(uint256,uint256,uint256,uint256,address)": EventFragment; + "LogTokenAdminAdded(address)": EventFragment; + "LogTokenAdminRemoved(address)": EventFragment; + "LogTokenRegistered(uint256,bytes,uint256)": EventFragment; + "LogUserRegistered(address,uint256,address)": EventFragment; + "LogWithdrawalAllowed(uint256,uint256,uint256,uint256)": EventFragment; + "LogWithdrawalPerformed(uint256,uint256,uint256,uint256,address)": EventFragment; + "LogOperatorAdded(address)": EventFragment; + "LogOperatorRemoved(address)": EventFragment; + "LogRootUpdate(uint256,uint256,uint256,uint256)": EventFragment; + "LogStateTransitionFact(bytes32)": EventFragment; + "LogVaultBalanceChangeApplied(address,uint256,uint256,int256)": EventFragment; + "LogFullWithdrawalRequest(uint256,uint256)": EventFragment; + "LogDefaultVaultWithdrawalLockSet(uint256)": EventFragment; + "LogDepositToVault(address,uint256,uint256,uint256,uint256)": EventFragment; + "LogVaultWithdrawalLockSet(address,uint256,uint256,uint256)": EventFragment; + "LogWithdrawalFromVault(address,uint256,uint256,uint256,uint256)": EventFragment; + "ImplementationActivationRescheduled(address,uint256)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "LogFrozen"): EventFragment; + getEvent(nameOrSignatureOrTopic: "LogNewGovernorAccepted"): EventFragment; + getEvent(nameOrSignatureOrTopic: "LogNominatedGovernor"): EventFragment; + getEvent(nameOrSignatureOrTopic: "LogNominationCancelled"): EventFragment; + getEvent(nameOrSignatureOrTopic: "LogRegistered"): EventFragment; + getEvent(nameOrSignatureOrTopic: "LogRemovalIntent"): EventFragment; + getEvent(nameOrSignatureOrTopic: "LogRemoved"): EventFragment; + getEvent(nameOrSignatureOrTopic: "LogRemovedGovernor"): EventFragment; + getEvent(nameOrSignatureOrTopic: "LogUnFrozen"): EventFragment; + getEvent(nameOrSignatureOrTopic: "LogDeposit"): EventFragment; + getEvent(nameOrSignatureOrTopic: "LogDepositCancel"): EventFragment; + getEvent(nameOrSignatureOrTopic: "LogDepositCancelReclaimed"): EventFragment; + getEvent( + nameOrSignatureOrTopic: "LogDepositNftCancelReclaimed" + ): EventFragment; + getEvent(nameOrSignatureOrTopic: "LogMintWithdrawalPerformed"): EventFragment; + getEvent( + nameOrSignatureOrTopic: "LogMintableWithdrawalAllowed" + ): EventFragment; + getEvent(nameOrSignatureOrTopic: "LogNftDeposit"): EventFragment; + getEvent(nameOrSignatureOrTopic: "LogNftWithdrawalAllowed"): EventFragment; + getEvent(nameOrSignatureOrTopic: "LogNftWithdrawalPerformed"): EventFragment; + getEvent(nameOrSignatureOrTopic: "LogTokenAdminAdded"): EventFragment; + getEvent(nameOrSignatureOrTopic: "LogTokenAdminRemoved"): EventFragment; + getEvent(nameOrSignatureOrTopic: "LogTokenRegistered"): EventFragment; + getEvent(nameOrSignatureOrTopic: "LogUserRegistered"): EventFragment; + getEvent(nameOrSignatureOrTopic: "LogWithdrawalAllowed"): EventFragment; + getEvent(nameOrSignatureOrTopic: "LogWithdrawalPerformed"): EventFragment; + getEvent(nameOrSignatureOrTopic: "LogOperatorAdded"): EventFragment; + getEvent(nameOrSignatureOrTopic: "LogOperatorRemoved"): EventFragment; + getEvent(nameOrSignatureOrTopic: "LogRootUpdate"): EventFragment; + getEvent(nameOrSignatureOrTopic: "LogStateTransitionFact"): EventFragment; + getEvent( + nameOrSignatureOrTopic: "LogVaultBalanceChangeApplied" + ): EventFragment; + getEvent(nameOrSignatureOrTopic: "LogFullWithdrawalRequest"): EventFragment; + getEvent( + nameOrSignatureOrTopic: "LogDefaultVaultWithdrawalLockSet" + ): EventFragment; + getEvent(nameOrSignatureOrTopic: "LogDepositToVault"): EventFragment; + getEvent(nameOrSignatureOrTopic: "LogVaultWithdrawalLockSet"): EventFragment; + getEvent(nameOrSignatureOrTopic: "LogWithdrawalFromVault"): EventFragment; + getEvent( + nameOrSignatureOrTopic: "ImplementationActivationRescheduled" + ): EventFragment; +} + +export interface LogFrozenEventObject {} +export type LogFrozenEvent = TypedEvent<[], LogFrozenEventObject>; + +export type LogFrozenEventFilter = TypedEventFilter; + +export interface LogNewGovernorAcceptedEventObject { + acceptedGovernor: string; +} +export type LogNewGovernorAcceptedEvent = TypedEvent< + [string], + LogNewGovernorAcceptedEventObject +>; + +export type LogNewGovernorAcceptedEventFilter = + TypedEventFilter; + +export interface LogNominatedGovernorEventObject { + nominatedGovernor: string; +} +export type LogNominatedGovernorEvent = TypedEvent< + [string], + LogNominatedGovernorEventObject +>; + +export type LogNominatedGovernorEventFilter = + TypedEventFilter; + +export interface LogNominationCancelledEventObject {} +export type LogNominationCancelledEvent = TypedEvent< + [], + LogNominationCancelledEventObject +>; + +export type LogNominationCancelledEventFilter = + TypedEventFilter; + +export interface LogRegisteredEventObject { + entry: string; + entryId: string; +} +export type LogRegisteredEvent = TypedEvent< + [string, string], + LogRegisteredEventObject +>; + +export type LogRegisteredEventFilter = TypedEventFilter; + +export interface LogRemovalIntentEventObject { + entry: string; + entryId: string; +} +export type LogRemovalIntentEvent = TypedEvent< + [string, string], + LogRemovalIntentEventObject +>; + +export type LogRemovalIntentEventFilter = + TypedEventFilter; + +export interface LogRemovedEventObject { + entry: string; + entryId: string; +} +export type LogRemovedEvent = TypedEvent< + [string, string], + LogRemovedEventObject +>; + +export type LogRemovedEventFilter = TypedEventFilter; + +export interface LogRemovedGovernorEventObject { + removedGovernor: string; +} +export type LogRemovedGovernorEvent = TypedEvent< + [string], + LogRemovedGovernorEventObject +>; + +export type LogRemovedGovernorEventFilter = + TypedEventFilter; + +export interface LogUnFrozenEventObject {} +export type LogUnFrozenEvent = TypedEvent<[], LogUnFrozenEventObject>; + +export type LogUnFrozenEventFilter = TypedEventFilter; + +export interface LogDepositEventObject { + depositorEthKey: string; + starkKey: BigNumber; + vaultId: BigNumber; + assetType: BigNumber; + nonQuantizedAmount: BigNumber; + quantizedAmount: BigNumber; +} +export type LogDepositEvent = TypedEvent< + [string, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber], + LogDepositEventObject +>; + +export type LogDepositEventFilter = TypedEventFilter; + +export interface LogDepositCancelEventObject { + starkKey: BigNumber; + vaultId: BigNumber; + assetId: BigNumber; +} +export type LogDepositCancelEvent = TypedEvent< + [BigNumber, BigNumber, BigNumber], + LogDepositCancelEventObject +>; + +export type LogDepositCancelEventFilter = + TypedEventFilter; + +export interface LogDepositCancelReclaimedEventObject { + starkKey: BigNumber; + vaultId: BigNumber; + assetType: BigNumber; + nonQuantizedAmount: BigNumber; + quantizedAmount: BigNumber; +} +export type LogDepositCancelReclaimedEvent = TypedEvent< + [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber], + LogDepositCancelReclaimedEventObject +>; + +export type LogDepositCancelReclaimedEventFilter = + TypedEventFilter; + +export interface LogDepositNftCancelReclaimedEventObject { + starkKey: BigNumber; + vaultId: BigNumber; + assetType: BigNumber; + tokenId: BigNumber; + assetId: BigNumber; +} +export type LogDepositNftCancelReclaimedEvent = TypedEvent< + [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber], + LogDepositNftCancelReclaimedEventObject +>; + +export type LogDepositNftCancelReclaimedEventFilter = + TypedEventFilter; + +export interface LogMintWithdrawalPerformedEventObject { + ownerKey: BigNumber; + assetType: BigNumber; + nonQuantizedAmount: BigNumber; + quantizedAmount: BigNumber; + assetId: BigNumber; +} +export type LogMintWithdrawalPerformedEvent = TypedEvent< + [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber], + LogMintWithdrawalPerformedEventObject +>; + +export type LogMintWithdrawalPerformedEventFilter = + TypedEventFilter; + +export interface LogMintableWithdrawalAllowedEventObject { + ownerKey: BigNumber; + assetId: BigNumber; + quantizedAmount: BigNumber; +} +export type LogMintableWithdrawalAllowedEvent = TypedEvent< + [BigNumber, BigNumber, BigNumber], + LogMintableWithdrawalAllowedEventObject +>; + +export type LogMintableWithdrawalAllowedEventFilter = + TypedEventFilter; + +export interface LogNftDepositEventObject { + depositorEthKey: string; + starkKey: BigNumber; + vaultId: BigNumber; + assetType: BigNumber; + tokenId: BigNumber; + assetId: BigNumber; +} +export type LogNftDepositEvent = TypedEvent< + [string, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber], + LogNftDepositEventObject +>; + +export type LogNftDepositEventFilter = TypedEventFilter; + +export interface LogNftWithdrawalAllowedEventObject { + ownerKey: BigNumber; + assetId: BigNumber; +} +export type LogNftWithdrawalAllowedEvent = TypedEvent< + [BigNumber, BigNumber], + LogNftWithdrawalAllowedEventObject +>; + +export type LogNftWithdrawalAllowedEventFilter = + TypedEventFilter; + +export interface LogNftWithdrawalPerformedEventObject { + ownerKey: BigNumber; + assetType: BigNumber; + tokenId: BigNumber; + assetId: BigNumber; + recipient: string; +} +export type LogNftWithdrawalPerformedEvent = TypedEvent< + [BigNumber, BigNumber, BigNumber, BigNumber, string], + LogNftWithdrawalPerformedEventObject +>; + +export type LogNftWithdrawalPerformedEventFilter = + TypedEventFilter; + +export interface LogTokenAdminAddedEventObject { + tokenAdmin: string; +} +export type LogTokenAdminAddedEvent = TypedEvent< + [string], + LogTokenAdminAddedEventObject +>; + +export type LogTokenAdminAddedEventFilter = + TypedEventFilter; + +export interface LogTokenAdminRemovedEventObject { + tokenAdmin: string; +} +export type LogTokenAdminRemovedEvent = TypedEvent< + [string], + LogTokenAdminRemovedEventObject +>; + +export type LogTokenAdminRemovedEventFilter = + TypedEventFilter; + +export interface LogTokenRegisteredEventObject { + assetType: BigNumber; + assetInfo: string; + quantum: BigNumber; +} +export type LogTokenRegisteredEvent = TypedEvent< + [BigNumber, string, BigNumber], + LogTokenRegisteredEventObject +>; + +export type LogTokenRegisteredEventFilter = + TypedEventFilter; + +export interface LogUserRegisteredEventObject { + ethKey: string; + starkKey: BigNumber; + sender: string; +} +export type LogUserRegisteredEvent = TypedEvent< + [string, BigNumber, string], + LogUserRegisteredEventObject +>; + +export type LogUserRegisteredEventFilter = + TypedEventFilter; + +export interface LogWithdrawalAllowedEventObject { + ownerKey: BigNumber; + assetType: BigNumber; + nonQuantizedAmount: BigNumber; + quantizedAmount: BigNumber; +} +export type LogWithdrawalAllowedEvent = TypedEvent< + [BigNumber, BigNumber, BigNumber, BigNumber], + LogWithdrawalAllowedEventObject +>; + +export type LogWithdrawalAllowedEventFilter = + TypedEventFilter; + +export interface LogWithdrawalPerformedEventObject { + ownerKey: BigNumber; + assetType: BigNumber; + nonQuantizedAmount: BigNumber; + quantizedAmount: BigNumber; + recipient: string; +} +export type LogWithdrawalPerformedEvent = TypedEvent< + [BigNumber, BigNumber, BigNumber, BigNumber, string], + LogWithdrawalPerformedEventObject +>; + +export type LogWithdrawalPerformedEventFilter = + TypedEventFilter; + +export interface LogOperatorAddedEventObject { + operator: string; +} +export type LogOperatorAddedEvent = TypedEvent< + [string], + LogOperatorAddedEventObject +>; + +export type LogOperatorAddedEventFilter = + TypedEventFilter; + +export interface LogOperatorRemovedEventObject { + operator: string; +} +export type LogOperatorRemovedEvent = TypedEvent< + [string], + LogOperatorRemovedEventObject +>; + +export type LogOperatorRemovedEventFilter = + TypedEventFilter; + +export interface LogRootUpdateEventObject { + sequenceNumber: BigNumber; + batchId: BigNumber; + vaultRoot: BigNumber; + orderRoot: BigNumber; +} +export type LogRootUpdateEvent = TypedEvent< + [BigNumber, BigNumber, BigNumber, BigNumber], + LogRootUpdateEventObject +>; + +export type LogRootUpdateEventFilter = TypedEventFilter; + +export interface LogStateTransitionFactEventObject { + stateTransitionFact: string; +} +export type LogStateTransitionFactEvent = TypedEvent< + [string], + LogStateTransitionFactEventObject +>; + +export type LogStateTransitionFactEventFilter = + TypedEventFilter; + +export interface LogVaultBalanceChangeAppliedEventObject { + ethKey: string; + assetId: BigNumber; + vaultId: BigNumber; + quantizedAmountChange: BigNumber; +} +export type LogVaultBalanceChangeAppliedEvent = TypedEvent< + [string, BigNumber, BigNumber, BigNumber], + LogVaultBalanceChangeAppliedEventObject +>; + +export type LogVaultBalanceChangeAppliedEventFilter = + TypedEventFilter; + +export interface LogFullWithdrawalRequestEventObject { + starkKey: BigNumber; + vaultId: BigNumber; +} +export type LogFullWithdrawalRequestEvent = TypedEvent< + [BigNumber, BigNumber], + LogFullWithdrawalRequestEventObject +>; + +export type LogFullWithdrawalRequestEventFilter = + TypedEventFilter; + +export interface LogDefaultVaultWithdrawalLockSetEventObject { + newDefaultLockTime: BigNumber; +} +export type LogDefaultVaultWithdrawalLockSetEvent = TypedEvent< + [BigNumber], + LogDefaultVaultWithdrawalLockSetEventObject +>; + +export type LogDefaultVaultWithdrawalLockSetEventFilter = + TypedEventFilter; + +export interface LogDepositToVaultEventObject { + ethKey: string; + assetId: BigNumber; + vaultId: BigNumber; + nonQuantizedAmount: BigNumber; + quantizedAmount: BigNumber; +} +export type LogDepositToVaultEvent = TypedEvent< + [string, BigNumber, BigNumber, BigNumber, BigNumber], + LogDepositToVaultEventObject +>; + +export type LogDepositToVaultEventFilter = + TypedEventFilter; + +export interface LogVaultWithdrawalLockSetEventObject { + ethKey: string; + assetId: BigNumber; + vaultId: BigNumber; + timeRelease: BigNumber; +} +export type LogVaultWithdrawalLockSetEvent = TypedEvent< + [string, BigNumber, BigNumber, BigNumber], + LogVaultWithdrawalLockSetEventObject +>; + +export type LogVaultWithdrawalLockSetEventFilter = + TypedEventFilter; + +export interface LogWithdrawalFromVaultEventObject { + ethKey: string; + assetId: BigNumber; + vaultId: BigNumber; + nonQuantizedAmount: BigNumber; + quantizedAmount: BigNumber; +} +export type LogWithdrawalFromVaultEvent = TypedEvent< + [string, BigNumber, BigNumber, BigNumber, BigNumber], + LogWithdrawalFromVaultEventObject +>; + +export type LogWithdrawalFromVaultEventFilter = + TypedEventFilter; + +export interface ImplementationActivationRescheduledEventObject { + implementation: string; + updatedActivationTime: BigNumber; +} +export type ImplementationActivationRescheduledEvent = TypedEvent< + [string, BigNumber], + ImplementationActivationRescheduledEventObject +>; + +export type ImplementationActivationRescheduledEventFilter = + TypedEventFilter; + +export interface StarkV4 extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: StarkV4Interface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + VERSION(overrides?: CallOverrides): Promise<[string]>; + + initialize( + data: BytesLike, + overrides?: Overrides & { from?: string } + ): Promise; + + DEPOSIT_CANCEL_DELAY(overrides?: CallOverrides): Promise<[BigNumber]>; + + FREEZE_GRACE_PERIOD(overrides?: CallOverrides): Promise<[BigNumber]>; + + MAIN_GOVERNANCE_INFO_TAG(overrides?: CallOverrides): Promise<[string]>; + + MAX_FORCED_ACTIONS_REQS_PER_BLOCK( + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + MAX_VERIFIER_COUNT(overrides?: CallOverrides): Promise<[BigNumber]>; + + UNFREEZE_DELAY(overrides?: CallOverrides): Promise<[BigNumber]>; + + VERIFIER_REMOVAL_DELAY(overrides?: CallOverrides): Promise<[BigNumber]>; + + announceAvailabilityVerifierRemovalIntent( + verifier: string, + overrides?: Overrides & { from?: string } + ): Promise; + + announceVerifierRemovalIntent( + verifier: string, + overrides?: Overrides & { from?: string } + ): Promise; + + getRegisteredAvailabilityVerifiers( + overrides?: CallOverrides + ): Promise<[string[]] & { _verifers: string[] }>; + + getRegisteredVerifiers( + overrides?: CallOverrides + ): Promise<[string[]] & { _verifers: string[] }>; + + isAvailabilityVerifier( + verifierAddress: string, + overrides?: CallOverrides + ): Promise<[boolean]>; + + isFrozen(overrides?: CallOverrides): Promise<[boolean]>; + + isVerifier( + verifierAddress: string, + overrides?: CallOverrides + ): Promise<[boolean]>; + + mainAcceptGovernance( + overrides?: Overrides & { from?: string } + ): Promise; + + mainCancelNomination( + overrides?: Overrides & { from?: string } + ): Promise; + + mainIsGovernor( + testGovernor: string, + overrides?: CallOverrides + ): Promise<[boolean]>; + + mainNominateNewGovernor( + newGovernor: string, + overrides?: Overrides & { from?: string } + ): Promise; + + mainRemoveGovernor( + governorForRemoval: string, + overrides?: Overrides & { from?: string } + ): Promise; + + registerAvailabilityVerifier( + verifier: string, + identifier: string, + overrides?: Overrides & { from?: string } + ): Promise; + + registerVerifier( + verifier: string, + identifier: string, + overrides?: Overrides & { from?: string } + ): Promise; + + removeAvailabilityVerifier( + verifier: string, + overrides?: Overrides & { from?: string } + ): Promise; + + removeVerifier( + verifier: string, + overrides?: Overrides & { from?: string } + ): Promise; + + unFreeze( + overrides?: Overrides & { from?: string } + ): Promise; + + defaultVaultWithdrawalLock(overrides?: CallOverrides): Promise<[BigNumber]>; + + "deposit(uint256,uint256,uint256)"( + starkKey: BigNumberish, + assetType: BigNumberish, + vaultId: BigNumberish, + overrides?: PayableOverrides & { from?: string } + ): Promise; + + "deposit(uint256,uint256,uint256,uint256)"( + starkKey: BigNumberish, + assetType: BigNumberish, + vaultId: BigNumberish, + quantizedAmount: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + depositCancel( + starkKey: BigNumberish, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + depositERC20( + starkKey: BigNumberish, + assetType: BigNumberish, + vaultId: BigNumberish, + quantizedAmount: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + depositEth( + starkKey: BigNumberish, + assetType: BigNumberish, + vaultId: BigNumberish, + overrides?: PayableOverrides & { from?: string } + ): Promise; + + depositNft( + starkKey: BigNumberish, + assetType: BigNumberish, + vaultId: BigNumberish, + tokenId: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + depositNftReclaim( + starkKey: BigNumberish, + assetType: BigNumberish, + vaultId: BigNumberish, + tokenId: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + depositReclaim( + starkKey: BigNumberish, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + getActionCount(overrides?: CallOverrides): Promise<[BigNumber]>; + + getActionHashByIndex( + actionIndex: BigNumberish, + overrides?: CallOverrides + ): Promise<[string]>; + + getAssetInfo( + assetType: BigNumberish, + overrides?: CallOverrides + ): Promise<[string] & { assetInfo: string }>; + + getCancellationRequest( + starkKey: BigNumberish, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise<[BigNumber] & { request: BigNumber }>; + + getDepositBalance( + starkKey: BigNumberish, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise<[BigNumber] & { balance: BigNumber }>; + + getEthKey( + ownerKey: BigNumberish, + overrides?: CallOverrides + ): Promise<[string]>; + + getFullWithdrawalRequest( + starkKey: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise<[BigNumber] & { res: BigNumber }>; + + getQuantizedDepositBalance( + starkKey: BigNumberish, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise<[BigNumber] & { balance: BigNumber }>; + + getQuantum( + presumedAssetType: BigNumberish, + overrides?: CallOverrides + ): Promise<[BigNumber] & { quantum: BigNumber }>; + + getWithdrawalBalance( + ownerKey: BigNumberish, + assetId: BigNumberish, + overrides?: CallOverrides + ): Promise<[BigNumber] & { balance: BigNumber }>; + + isAssetRegistered( + assetType: BigNumberish, + overrides?: CallOverrides + ): Promise<[boolean]>; + + isTokenAdmin( + testedAdmin: string, + overrides?: CallOverrides + ): Promise<[boolean]>; + + onERC721Received( + arg0: string, + arg1: string, + arg2: BigNumberish, + arg3: BytesLike, + overrides?: Overrides & { from?: string } + ): Promise; + + orderRegistryAddress(overrides?: CallOverrides): Promise<[string]>; + + registerAndDepositERC20( + ethKey: string, + starkKey: BigNumberish, + signature: BytesLike, + assetType: BigNumberish, + vaultId: BigNumberish, + quantizedAmount: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + registerAndDepositEth( + ethKey: string, + starkKey: BigNumberish, + signature: BytesLike, + assetType: BigNumberish, + vaultId: BigNumberish, + overrides?: PayableOverrides & { from?: string } + ): Promise; + + registerEthAddress( + ethKey: string, + starkKey: BigNumberish, + starkSignature: BytesLike, + overrides?: Overrides & { from?: string } + ): Promise; + + registerSender( + starkKey: BigNumberish, + starkSignature: BytesLike, + overrides?: Overrides & { from?: string } + ): Promise; + + "registerToken(uint256,bytes)"( + assetType: BigNumberish, + assetInfo: BytesLike, + overrides?: Overrides & { from?: string } + ): Promise; + + "registerToken(uint256,bytes,uint256)"( + assetType: BigNumberish, + assetInfo: BytesLike, + quantum: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + registerTokenAdmin( + newAdmin: string, + overrides?: Overrides & { from?: string } + ): Promise; + + unregisterTokenAdmin( + oldAdmin: string, + overrides?: Overrides & { from?: string } + ): Promise; + + withdraw( + ownerKey: BigNumberish, + assetType: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + withdrawAndMint( + ownerKey: BigNumberish, + assetType: BigNumberish, + mintingBlob: BytesLike, + overrides?: Overrides & { from?: string } + ): Promise; + + withdrawNft( + ownerKey: BigNumberish, + assetType: BigNumberish, + tokenId: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + STARKEX_MAX_DEFAULT_VAULT_LOCK( + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + escape( + starkKey: BigNumberish, + vaultId: BigNumberish, + assetId: BigNumberish, + quantizedAmount: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + getLastBatchId( + overrides?: CallOverrides + ): Promise<[BigNumber] & { batchId: BigNumber }>; + + getOrderRoot( + overrides?: CallOverrides + ): Promise<[BigNumber] & { root: BigNumber }>; + + getOrderTreeHeight( + overrides?: CallOverrides + ): Promise<[BigNumber] & { height: BigNumber }>; + + getSequenceNumber( + overrides?: CallOverrides + ): Promise<[BigNumber] & { seq: BigNumber }>; + + getVaultRoot( + overrides?: CallOverrides + ): Promise<[BigNumber] & { root: BigNumber }>; + + getVaultTreeHeight( + overrides?: CallOverrides + ): Promise<[BigNumber] & { height: BigNumber }>; + + isOperator( + testedOperator: string, + overrides?: CallOverrides + ): Promise<[boolean]>; + + registerOperator( + newOperator: string, + overrides?: Overrides & { from?: string } + ): Promise; + + unregisterOperator( + removedOperator: string, + overrides?: Overrides & { from?: string } + ): Promise; + + updateState( + publicInput: BigNumberish[], + applicationData: BigNumberish[], + overrides?: Overrides & { from?: string } + ): Promise; + + freezeRequest( + starkKey: BigNumberish, + vaultId: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + fullWithdrawalRequest( + starkKey: BigNumberish, + vaultId: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + depositERC20ToVault( + assetId: BigNumberish, + vaultId: BigNumberish, + quantizedAmount: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + depositEthToVault( + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: PayableOverrides & { from?: string } + ): Promise; + + getQuantizedVaultBalance( + ethKey: string, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + getVaultBalance( + ethKey: string, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + getVaultWithdrawalLock( + ethKey: string, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + isStrictVaultBalancePolicy(overrides?: CallOverrides): Promise<[boolean]>; + + isVaultLocked( + ethKey: string, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise<[boolean]>; + + lockVault( + assetId: BigNumberish, + vaultId: BigNumberish, + lockTime: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + setDefaultVaultWithdrawalLock( + newDefaultTime: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + withdrawFromVault( + assetId: BigNumberish, + vaultId: BigNumberish, + quantizedAmount: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + updateImplementationActivationTime( + implementation: string, + data: BytesLike, + finalize: boolean, + overrides?: Overrides & { from?: string } + ): Promise; + }; + + VERSION(overrides?: CallOverrides): Promise; + + initialize( + data: BytesLike, + overrides?: Overrides & { from?: string } + ): Promise; + + DEPOSIT_CANCEL_DELAY(overrides?: CallOverrides): Promise; + + FREEZE_GRACE_PERIOD(overrides?: CallOverrides): Promise; + + MAIN_GOVERNANCE_INFO_TAG(overrides?: CallOverrides): Promise; + + MAX_FORCED_ACTIONS_REQS_PER_BLOCK( + overrides?: CallOverrides + ): Promise; + + MAX_VERIFIER_COUNT(overrides?: CallOverrides): Promise; + + UNFREEZE_DELAY(overrides?: CallOverrides): Promise; + + VERIFIER_REMOVAL_DELAY(overrides?: CallOverrides): Promise; + + announceAvailabilityVerifierRemovalIntent( + verifier: string, + overrides?: Overrides & { from?: string } + ): Promise; + + announceVerifierRemovalIntent( + verifier: string, + overrides?: Overrides & { from?: string } + ): Promise; + + getRegisteredAvailabilityVerifiers( + overrides?: CallOverrides + ): Promise; + + getRegisteredVerifiers(overrides?: CallOverrides): Promise; + + isAvailabilityVerifier( + verifierAddress: string, + overrides?: CallOverrides + ): Promise; + + isFrozen(overrides?: CallOverrides): Promise; + + isVerifier( + verifierAddress: string, + overrides?: CallOverrides + ): Promise; + + mainAcceptGovernance( + overrides?: Overrides & { from?: string } + ): Promise; + + mainCancelNomination( + overrides?: Overrides & { from?: string } + ): Promise; + + mainIsGovernor( + testGovernor: string, + overrides?: CallOverrides + ): Promise; + + mainNominateNewGovernor( + newGovernor: string, + overrides?: Overrides & { from?: string } + ): Promise; + + mainRemoveGovernor( + governorForRemoval: string, + overrides?: Overrides & { from?: string } + ): Promise; + + registerAvailabilityVerifier( + verifier: string, + identifier: string, + overrides?: Overrides & { from?: string } + ): Promise; + + registerVerifier( + verifier: string, + identifier: string, + overrides?: Overrides & { from?: string } + ): Promise; + + removeAvailabilityVerifier( + verifier: string, + overrides?: Overrides & { from?: string } + ): Promise; + + removeVerifier( + verifier: string, + overrides?: Overrides & { from?: string } + ): Promise; + + unFreeze( + overrides?: Overrides & { from?: string } + ): Promise; + + defaultVaultWithdrawalLock(overrides?: CallOverrides): Promise; + + "deposit(uint256,uint256,uint256)"( + starkKey: BigNumberish, + assetType: BigNumberish, + vaultId: BigNumberish, + overrides?: PayableOverrides & { from?: string } + ): Promise; + + "deposit(uint256,uint256,uint256,uint256)"( + starkKey: BigNumberish, + assetType: BigNumberish, + vaultId: BigNumberish, + quantizedAmount: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + depositCancel( + starkKey: BigNumberish, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + depositERC20( + starkKey: BigNumberish, + assetType: BigNumberish, + vaultId: BigNumberish, + quantizedAmount: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + depositEth( + starkKey: BigNumberish, + assetType: BigNumberish, + vaultId: BigNumberish, + overrides?: PayableOverrides & { from?: string } + ): Promise; + + depositNft( + starkKey: BigNumberish, + assetType: BigNumberish, + vaultId: BigNumberish, + tokenId: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + depositNftReclaim( + starkKey: BigNumberish, + assetType: BigNumberish, + vaultId: BigNumberish, + tokenId: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + depositReclaim( + starkKey: BigNumberish, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + getActionCount(overrides?: CallOverrides): Promise; + + getActionHashByIndex( + actionIndex: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getAssetInfo( + assetType: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getCancellationRequest( + starkKey: BigNumberish, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getDepositBalance( + starkKey: BigNumberish, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getEthKey(ownerKey: BigNumberish, overrides?: CallOverrides): Promise; + + getFullWithdrawalRequest( + starkKey: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getQuantizedDepositBalance( + starkKey: BigNumberish, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getQuantum( + presumedAssetType: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getWithdrawalBalance( + ownerKey: BigNumberish, + assetId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + isAssetRegistered( + assetType: BigNumberish, + overrides?: CallOverrides + ): Promise; + + isTokenAdmin( + testedAdmin: string, + overrides?: CallOverrides + ): Promise; + + onERC721Received( + arg0: string, + arg1: string, + arg2: BigNumberish, + arg3: BytesLike, + overrides?: Overrides & { from?: string } + ): Promise; + + orderRegistryAddress(overrides?: CallOverrides): Promise; + + registerAndDepositERC20( + ethKey: string, + starkKey: BigNumberish, + signature: BytesLike, + assetType: BigNumberish, + vaultId: BigNumberish, + quantizedAmount: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + registerAndDepositEth( + ethKey: string, + starkKey: BigNumberish, + signature: BytesLike, + assetType: BigNumberish, + vaultId: BigNumberish, + overrides?: PayableOverrides & { from?: string } + ): Promise; + + registerEthAddress( + ethKey: string, + starkKey: BigNumberish, + starkSignature: BytesLike, + overrides?: Overrides & { from?: string } + ): Promise; + + registerSender( + starkKey: BigNumberish, + starkSignature: BytesLike, + overrides?: Overrides & { from?: string } + ): Promise; + + "registerToken(uint256,bytes)"( + assetType: BigNumberish, + assetInfo: BytesLike, + overrides?: Overrides & { from?: string } + ): Promise; + + "registerToken(uint256,bytes,uint256)"( + assetType: BigNumberish, + assetInfo: BytesLike, + quantum: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + registerTokenAdmin( + newAdmin: string, + overrides?: Overrides & { from?: string } + ): Promise; + + unregisterTokenAdmin( + oldAdmin: string, + overrides?: Overrides & { from?: string } + ): Promise; + + withdraw( + ownerKey: BigNumberish, + assetType: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + withdrawAndMint( + ownerKey: BigNumberish, + assetType: BigNumberish, + mintingBlob: BytesLike, + overrides?: Overrides & { from?: string } + ): Promise; + + withdrawNft( + ownerKey: BigNumberish, + assetType: BigNumberish, + tokenId: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + STARKEX_MAX_DEFAULT_VAULT_LOCK(overrides?: CallOverrides): Promise; + + escape( + starkKey: BigNumberish, + vaultId: BigNumberish, + assetId: BigNumberish, + quantizedAmount: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + getLastBatchId(overrides?: CallOverrides): Promise; + + getOrderRoot(overrides?: CallOverrides): Promise; + + getOrderTreeHeight(overrides?: CallOverrides): Promise; + + getSequenceNumber(overrides?: CallOverrides): Promise; + + getVaultRoot(overrides?: CallOverrides): Promise; + + getVaultTreeHeight(overrides?: CallOverrides): Promise; + + isOperator( + testedOperator: string, + overrides?: CallOverrides + ): Promise; + + registerOperator( + newOperator: string, + overrides?: Overrides & { from?: string } + ): Promise; + + unregisterOperator( + removedOperator: string, + overrides?: Overrides & { from?: string } + ): Promise; + + updateState( + publicInput: BigNumberish[], + applicationData: BigNumberish[], + overrides?: Overrides & { from?: string } + ): Promise; + + freezeRequest( + starkKey: BigNumberish, + vaultId: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + fullWithdrawalRequest( + starkKey: BigNumberish, + vaultId: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + depositERC20ToVault( + assetId: BigNumberish, + vaultId: BigNumberish, + quantizedAmount: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + depositEthToVault( + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: PayableOverrides & { from?: string } + ): Promise; + + getQuantizedVaultBalance( + ethKey: string, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getVaultBalance( + ethKey: string, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getVaultWithdrawalLock( + ethKey: string, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + isStrictVaultBalancePolicy(overrides?: CallOverrides): Promise; + + isVaultLocked( + ethKey: string, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + lockVault( + assetId: BigNumberish, + vaultId: BigNumberish, + lockTime: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + setDefaultVaultWithdrawalLock( + newDefaultTime: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + withdrawFromVault( + assetId: BigNumberish, + vaultId: BigNumberish, + quantizedAmount: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + updateImplementationActivationTime( + implementation: string, + data: BytesLike, + finalize: boolean, + overrides?: Overrides & { from?: string } + ): Promise; + + callStatic: { + VERSION(overrides?: CallOverrides): Promise; + + initialize(data: BytesLike, overrides?: CallOverrides): Promise; + + DEPOSIT_CANCEL_DELAY(overrides?: CallOverrides): Promise; + + FREEZE_GRACE_PERIOD(overrides?: CallOverrides): Promise; + + MAIN_GOVERNANCE_INFO_TAG(overrides?: CallOverrides): Promise; + + MAX_FORCED_ACTIONS_REQS_PER_BLOCK( + overrides?: CallOverrides + ): Promise; + + MAX_VERIFIER_COUNT(overrides?: CallOverrides): Promise; + + UNFREEZE_DELAY(overrides?: CallOverrides): Promise; + + VERIFIER_REMOVAL_DELAY(overrides?: CallOverrides): Promise; + + announceAvailabilityVerifierRemovalIntent( + verifier: string, + overrides?: CallOverrides + ): Promise; + + announceVerifierRemovalIntent( + verifier: string, + overrides?: CallOverrides + ): Promise; + + getRegisteredAvailabilityVerifiers( + overrides?: CallOverrides + ): Promise; + + getRegisteredVerifiers(overrides?: CallOverrides): Promise; + + isAvailabilityVerifier( + verifierAddress: string, + overrides?: CallOverrides + ): Promise; + + isFrozen(overrides?: CallOverrides): Promise; + + isVerifier( + verifierAddress: string, + overrides?: CallOverrides + ): Promise; + + mainAcceptGovernance(overrides?: CallOverrides): Promise; + + mainCancelNomination(overrides?: CallOverrides): Promise; + + mainIsGovernor( + testGovernor: string, + overrides?: CallOverrides + ): Promise; + + mainNominateNewGovernor( + newGovernor: string, + overrides?: CallOverrides + ): Promise; + + mainRemoveGovernor( + governorForRemoval: string, + overrides?: CallOverrides + ): Promise; + + registerAvailabilityVerifier( + verifier: string, + identifier: string, + overrides?: CallOverrides + ): Promise; + + registerVerifier( + verifier: string, + identifier: string, + overrides?: CallOverrides + ): Promise; + + removeAvailabilityVerifier( + verifier: string, + overrides?: CallOverrides + ): Promise; + + removeVerifier(verifier: string, overrides?: CallOverrides): Promise; + + unFreeze(overrides?: CallOverrides): Promise; + + defaultVaultWithdrawalLock(overrides?: CallOverrides): Promise; + + "deposit(uint256,uint256,uint256)"( + starkKey: BigNumberish, + assetType: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + "deposit(uint256,uint256,uint256,uint256)"( + starkKey: BigNumberish, + assetType: BigNumberish, + vaultId: BigNumberish, + quantizedAmount: BigNumberish, + overrides?: CallOverrides + ): Promise; + + depositCancel( + starkKey: BigNumberish, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + depositERC20( + starkKey: BigNumberish, + assetType: BigNumberish, + vaultId: BigNumberish, + quantizedAmount: BigNumberish, + overrides?: CallOverrides + ): Promise; + + depositEth( + starkKey: BigNumberish, + assetType: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + depositNft( + starkKey: BigNumberish, + assetType: BigNumberish, + vaultId: BigNumberish, + tokenId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + depositNftReclaim( + starkKey: BigNumberish, + assetType: BigNumberish, + vaultId: BigNumberish, + tokenId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + depositReclaim( + starkKey: BigNumberish, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getActionCount(overrides?: CallOverrides): Promise; + + getActionHashByIndex( + actionIndex: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getAssetInfo( + assetType: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getCancellationRequest( + starkKey: BigNumberish, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getDepositBalance( + starkKey: BigNumberish, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getEthKey( + ownerKey: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getFullWithdrawalRequest( + starkKey: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getQuantizedDepositBalance( + starkKey: BigNumberish, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getQuantum( + presumedAssetType: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getWithdrawalBalance( + ownerKey: BigNumberish, + assetId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + isAssetRegistered( + assetType: BigNumberish, + overrides?: CallOverrides + ): Promise; + + isTokenAdmin( + testedAdmin: string, + overrides?: CallOverrides + ): Promise; + + onERC721Received( + arg0: string, + arg1: string, + arg2: BigNumberish, + arg3: BytesLike, + overrides?: CallOverrides + ): Promise; + + orderRegistryAddress(overrides?: CallOverrides): Promise; + + registerAndDepositERC20( + ethKey: string, + starkKey: BigNumberish, + signature: BytesLike, + assetType: BigNumberish, + vaultId: BigNumberish, + quantizedAmount: BigNumberish, + overrides?: CallOverrides + ): Promise; + + registerAndDepositEth( + ethKey: string, + starkKey: BigNumberish, + signature: BytesLike, + assetType: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + registerEthAddress( + ethKey: string, + starkKey: BigNumberish, + starkSignature: BytesLike, + overrides?: CallOverrides + ): Promise; + + registerSender( + starkKey: BigNumberish, + starkSignature: BytesLike, + overrides?: CallOverrides + ): Promise; + + "registerToken(uint256,bytes)"( + assetType: BigNumberish, + assetInfo: BytesLike, + overrides?: CallOverrides + ): Promise; + + "registerToken(uint256,bytes,uint256)"( + assetType: BigNumberish, + assetInfo: BytesLike, + quantum: BigNumberish, + overrides?: CallOverrides + ): Promise; + + registerTokenAdmin( + newAdmin: string, + overrides?: CallOverrides + ): Promise; + + unregisterTokenAdmin( + oldAdmin: string, + overrides?: CallOverrides + ): Promise; + + withdraw( + ownerKey: BigNumberish, + assetType: BigNumberish, + overrides?: CallOverrides + ): Promise; + + withdrawAndMint( + ownerKey: BigNumberish, + assetType: BigNumberish, + mintingBlob: BytesLike, + overrides?: CallOverrides + ): Promise; + + withdrawNft( + ownerKey: BigNumberish, + assetType: BigNumberish, + tokenId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + STARKEX_MAX_DEFAULT_VAULT_LOCK( + overrides?: CallOverrides + ): Promise; + + escape( + starkKey: BigNumberish, + vaultId: BigNumberish, + assetId: BigNumberish, + quantizedAmount: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getLastBatchId(overrides?: CallOverrides): Promise; + + getOrderRoot(overrides?: CallOverrides): Promise; + + getOrderTreeHeight(overrides?: CallOverrides): Promise; + + getSequenceNumber(overrides?: CallOverrides): Promise; + + getVaultRoot(overrides?: CallOverrides): Promise; + + getVaultTreeHeight(overrides?: CallOverrides): Promise; + + isOperator( + testedOperator: string, + overrides?: CallOverrides + ): Promise; + + registerOperator( + newOperator: string, + overrides?: CallOverrides + ): Promise; + + unregisterOperator( + removedOperator: string, + overrides?: CallOverrides + ): Promise; + + updateState( + publicInput: BigNumberish[], + applicationData: BigNumberish[], + overrides?: CallOverrides + ): Promise; + + freezeRequest( + starkKey: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + fullWithdrawalRequest( + starkKey: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + depositERC20ToVault( + assetId: BigNumberish, + vaultId: BigNumberish, + quantizedAmount: BigNumberish, + overrides?: CallOverrides + ): Promise; + + depositEthToVault( + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getQuantizedVaultBalance( + ethKey: string, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getVaultBalance( + ethKey: string, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getVaultWithdrawalLock( + ethKey: string, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + isStrictVaultBalancePolicy(overrides?: CallOverrides): Promise; + + isVaultLocked( + ethKey: string, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + lockVault( + assetId: BigNumberish, + vaultId: BigNumberish, + lockTime: BigNumberish, + overrides?: CallOverrides + ): Promise; + + setDefaultVaultWithdrawalLock( + newDefaultTime: BigNumberish, + overrides?: CallOverrides + ): Promise; + + withdrawFromVault( + assetId: BigNumberish, + vaultId: BigNumberish, + quantizedAmount: BigNumberish, + overrides?: CallOverrides + ): Promise; + + updateImplementationActivationTime( + implementation: string, + data: BytesLike, + finalize: boolean, + overrides?: CallOverrides + ): Promise; + }; + + filters: { + "LogFrozen()"(): LogFrozenEventFilter; + LogFrozen(): LogFrozenEventFilter; + + "LogNewGovernorAccepted(address)"( + acceptedGovernor?: null + ): LogNewGovernorAcceptedEventFilter; + LogNewGovernorAccepted( + acceptedGovernor?: null + ): LogNewGovernorAcceptedEventFilter; + + "LogNominatedGovernor(address)"( + nominatedGovernor?: null + ): LogNominatedGovernorEventFilter; + LogNominatedGovernor( + nominatedGovernor?: null + ): LogNominatedGovernorEventFilter; + + "LogNominationCancelled()"(): LogNominationCancelledEventFilter; + LogNominationCancelled(): LogNominationCancelledEventFilter; + + "LogRegistered(address,string)"( + entry?: null, + entryId?: null + ): LogRegisteredEventFilter; + LogRegistered(entry?: null, entryId?: null): LogRegisteredEventFilter; + + "LogRemovalIntent(address,string)"( + entry?: null, + entryId?: null + ): LogRemovalIntentEventFilter; + LogRemovalIntent(entry?: null, entryId?: null): LogRemovalIntentEventFilter; + + "LogRemoved(address,string)"( + entry?: null, + entryId?: null + ): LogRemovedEventFilter; + LogRemoved(entry?: null, entryId?: null): LogRemovedEventFilter; + + "LogRemovedGovernor(address)"( + removedGovernor?: null + ): LogRemovedGovernorEventFilter; + LogRemovedGovernor(removedGovernor?: null): LogRemovedGovernorEventFilter; + + "LogUnFrozen()"(): LogUnFrozenEventFilter; + LogUnFrozen(): LogUnFrozenEventFilter; + + "LogDeposit(address,uint256,uint256,uint256,uint256,uint256)"( + depositorEthKey?: null, + starkKey?: null, + vaultId?: null, + assetType?: null, + nonQuantizedAmount?: null, + quantizedAmount?: null + ): LogDepositEventFilter; + LogDeposit( + depositorEthKey?: null, + starkKey?: null, + vaultId?: null, + assetType?: null, + nonQuantizedAmount?: null, + quantizedAmount?: null + ): LogDepositEventFilter; + + "LogDepositCancel(uint256,uint256,uint256)"( + starkKey?: null, + vaultId?: null, + assetId?: null + ): LogDepositCancelEventFilter; + LogDepositCancel( + starkKey?: null, + vaultId?: null, + assetId?: null + ): LogDepositCancelEventFilter; + + "LogDepositCancelReclaimed(uint256,uint256,uint256,uint256,uint256)"( + starkKey?: null, + vaultId?: null, + assetType?: null, + nonQuantizedAmount?: null, + quantizedAmount?: null + ): LogDepositCancelReclaimedEventFilter; + LogDepositCancelReclaimed( + starkKey?: null, + vaultId?: null, + assetType?: null, + nonQuantizedAmount?: null, + quantizedAmount?: null + ): LogDepositCancelReclaimedEventFilter; + + "LogDepositNftCancelReclaimed(uint256,uint256,uint256,uint256,uint256)"( + starkKey?: null, + vaultId?: null, + assetType?: null, + tokenId?: null, + assetId?: null + ): LogDepositNftCancelReclaimedEventFilter; + LogDepositNftCancelReclaimed( + starkKey?: null, + vaultId?: null, + assetType?: null, + tokenId?: null, + assetId?: null + ): LogDepositNftCancelReclaimedEventFilter; + + "LogMintWithdrawalPerformed(uint256,uint256,uint256,uint256,uint256)"( + ownerKey?: null, + assetType?: null, + nonQuantizedAmount?: null, + quantizedAmount?: null, + assetId?: null + ): LogMintWithdrawalPerformedEventFilter; + LogMintWithdrawalPerformed( + ownerKey?: null, + assetType?: null, + nonQuantizedAmount?: null, + quantizedAmount?: null, + assetId?: null + ): LogMintWithdrawalPerformedEventFilter; + + "LogMintableWithdrawalAllowed(uint256,uint256,uint256)"( + ownerKey?: null, + assetId?: null, + quantizedAmount?: null + ): LogMintableWithdrawalAllowedEventFilter; + LogMintableWithdrawalAllowed( + ownerKey?: null, + assetId?: null, + quantizedAmount?: null + ): LogMintableWithdrawalAllowedEventFilter; + + "LogNftDeposit(address,uint256,uint256,uint256,uint256,uint256)"( + depositorEthKey?: null, + starkKey?: null, + vaultId?: null, + assetType?: null, + tokenId?: null, + assetId?: null + ): LogNftDepositEventFilter; + LogNftDeposit( + depositorEthKey?: null, + starkKey?: null, + vaultId?: null, + assetType?: null, + tokenId?: null, + assetId?: null + ): LogNftDepositEventFilter; + + "LogNftWithdrawalAllowed(uint256,uint256)"( + ownerKey?: null, + assetId?: null + ): LogNftWithdrawalAllowedEventFilter; + LogNftWithdrawalAllowed( + ownerKey?: null, + assetId?: null + ): LogNftWithdrawalAllowedEventFilter; + + "LogNftWithdrawalPerformed(uint256,uint256,uint256,uint256,address)"( + ownerKey?: null, + assetType?: null, + tokenId?: null, + assetId?: null, + recipient?: null + ): LogNftWithdrawalPerformedEventFilter; + LogNftWithdrawalPerformed( + ownerKey?: null, + assetType?: null, + tokenId?: null, + assetId?: null, + recipient?: null + ): LogNftWithdrawalPerformedEventFilter; + + "LogTokenAdminAdded(address)"( + tokenAdmin?: null + ): LogTokenAdminAddedEventFilter; + LogTokenAdminAdded(tokenAdmin?: null): LogTokenAdminAddedEventFilter; + + "LogTokenAdminRemoved(address)"( + tokenAdmin?: null + ): LogTokenAdminRemovedEventFilter; + LogTokenAdminRemoved(tokenAdmin?: null): LogTokenAdminRemovedEventFilter; + + "LogTokenRegistered(uint256,bytes,uint256)"( + assetType?: null, + assetInfo?: null, + quantum?: null + ): LogTokenRegisteredEventFilter; + LogTokenRegistered( + assetType?: null, + assetInfo?: null, + quantum?: null + ): LogTokenRegisteredEventFilter; + + "LogUserRegistered(address,uint256,address)"( + ethKey?: null, + starkKey?: null, + sender?: null + ): LogUserRegisteredEventFilter; + LogUserRegistered( + ethKey?: null, + starkKey?: null, + sender?: null + ): LogUserRegisteredEventFilter; + + "LogWithdrawalAllowed(uint256,uint256,uint256,uint256)"( + ownerKey?: null, + assetType?: null, + nonQuantizedAmount?: null, + quantizedAmount?: null + ): LogWithdrawalAllowedEventFilter; + LogWithdrawalAllowed( + ownerKey?: null, + assetType?: null, + nonQuantizedAmount?: null, + quantizedAmount?: null + ): LogWithdrawalAllowedEventFilter; + + "LogWithdrawalPerformed(uint256,uint256,uint256,uint256,address)"( + ownerKey?: null, + assetType?: null, + nonQuantizedAmount?: null, + quantizedAmount?: null, + recipient?: null + ): LogWithdrawalPerformedEventFilter; + LogWithdrawalPerformed( + ownerKey?: null, + assetType?: null, + nonQuantizedAmount?: null, + quantizedAmount?: null, + recipient?: null + ): LogWithdrawalPerformedEventFilter; + + "LogOperatorAdded(address)"(operator?: null): LogOperatorAddedEventFilter; + LogOperatorAdded(operator?: null): LogOperatorAddedEventFilter; + + "LogOperatorRemoved(address)"( + operator?: null + ): LogOperatorRemovedEventFilter; + LogOperatorRemoved(operator?: null): LogOperatorRemovedEventFilter; + + "LogRootUpdate(uint256,uint256,uint256,uint256)"( + sequenceNumber?: null, + batchId?: null, + vaultRoot?: null, + orderRoot?: null + ): LogRootUpdateEventFilter; + LogRootUpdate( + sequenceNumber?: null, + batchId?: null, + vaultRoot?: null, + orderRoot?: null + ): LogRootUpdateEventFilter; + + "LogStateTransitionFact(bytes32)"( + stateTransitionFact?: null + ): LogStateTransitionFactEventFilter; + LogStateTransitionFact( + stateTransitionFact?: null + ): LogStateTransitionFactEventFilter; + + "LogVaultBalanceChangeApplied(address,uint256,uint256,int256)"( + ethKey?: null, + assetId?: null, + vaultId?: null, + quantizedAmountChange?: null + ): LogVaultBalanceChangeAppliedEventFilter; + LogVaultBalanceChangeApplied( + ethKey?: null, + assetId?: null, + vaultId?: null, + quantizedAmountChange?: null + ): LogVaultBalanceChangeAppliedEventFilter; + + "LogFullWithdrawalRequest(uint256,uint256)"( + starkKey?: null, + vaultId?: null + ): LogFullWithdrawalRequestEventFilter; + LogFullWithdrawalRequest( + starkKey?: null, + vaultId?: null + ): LogFullWithdrawalRequestEventFilter; + + "LogDefaultVaultWithdrawalLockSet(uint256)"( + newDefaultLockTime?: null + ): LogDefaultVaultWithdrawalLockSetEventFilter; + LogDefaultVaultWithdrawalLockSet( + newDefaultLockTime?: null + ): LogDefaultVaultWithdrawalLockSetEventFilter; + + "LogDepositToVault(address,uint256,uint256,uint256,uint256)"( + ethKey?: null, + assetId?: null, + vaultId?: null, + nonQuantizedAmount?: null, + quantizedAmount?: null + ): LogDepositToVaultEventFilter; + LogDepositToVault( + ethKey?: null, + assetId?: null, + vaultId?: null, + nonQuantizedAmount?: null, + quantizedAmount?: null + ): LogDepositToVaultEventFilter; + + "LogVaultWithdrawalLockSet(address,uint256,uint256,uint256)"( + ethKey?: null, + assetId?: null, + vaultId?: null, + timeRelease?: null + ): LogVaultWithdrawalLockSetEventFilter; + LogVaultWithdrawalLockSet( + ethKey?: null, + assetId?: null, + vaultId?: null, + timeRelease?: null + ): LogVaultWithdrawalLockSetEventFilter; + + "LogWithdrawalFromVault(address,uint256,uint256,uint256,uint256)"( + ethKey?: null, + assetId?: null, + vaultId?: null, + nonQuantizedAmount?: null, + quantizedAmount?: null + ): LogWithdrawalFromVaultEventFilter; + LogWithdrawalFromVault( + ethKey?: null, + assetId?: null, + vaultId?: null, + nonQuantizedAmount?: null, + quantizedAmount?: null + ): LogWithdrawalFromVaultEventFilter; + + "ImplementationActivationRescheduled(address,uint256)"( + implementation?: string | null, + updatedActivationTime?: null + ): ImplementationActivationRescheduledEventFilter; + ImplementationActivationRescheduled( + implementation?: string | null, + updatedActivationTime?: null + ): ImplementationActivationRescheduledEventFilter; + }; + + estimateGas: { + VERSION(overrides?: CallOverrides): Promise; + + initialize( + data: BytesLike, + overrides?: Overrides & { from?: string } + ): Promise; + + DEPOSIT_CANCEL_DELAY(overrides?: CallOverrides): Promise; + + FREEZE_GRACE_PERIOD(overrides?: CallOverrides): Promise; + + MAIN_GOVERNANCE_INFO_TAG(overrides?: CallOverrides): Promise; + + MAX_FORCED_ACTIONS_REQS_PER_BLOCK( + overrides?: CallOverrides + ): Promise; + + MAX_VERIFIER_COUNT(overrides?: CallOverrides): Promise; + + UNFREEZE_DELAY(overrides?: CallOverrides): Promise; + + VERIFIER_REMOVAL_DELAY(overrides?: CallOverrides): Promise; + + announceAvailabilityVerifierRemovalIntent( + verifier: string, + overrides?: Overrides & { from?: string } + ): Promise; + + announceVerifierRemovalIntent( + verifier: string, + overrides?: Overrides & { from?: string } + ): Promise; + + getRegisteredAvailabilityVerifiers( + overrides?: CallOverrides + ): Promise; + + getRegisteredVerifiers(overrides?: CallOverrides): Promise; + + isAvailabilityVerifier( + verifierAddress: string, + overrides?: CallOverrides + ): Promise; + + isFrozen(overrides?: CallOverrides): Promise; + + isVerifier( + verifierAddress: string, + overrides?: CallOverrides + ): Promise; + + mainAcceptGovernance( + overrides?: Overrides & { from?: string } + ): Promise; + + mainCancelNomination( + overrides?: Overrides & { from?: string } + ): Promise; + + mainIsGovernor( + testGovernor: string, + overrides?: CallOverrides + ): Promise; + + mainNominateNewGovernor( + newGovernor: string, + overrides?: Overrides & { from?: string } + ): Promise; + + mainRemoveGovernor( + governorForRemoval: string, + overrides?: Overrides & { from?: string } + ): Promise; + + registerAvailabilityVerifier( + verifier: string, + identifier: string, + overrides?: Overrides & { from?: string } + ): Promise; + + registerVerifier( + verifier: string, + identifier: string, + overrides?: Overrides & { from?: string } + ): Promise; + + removeAvailabilityVerifier( + verifier: string, + overrides?: Overrides & { from?: string } + ): Promise; + + removeVerifier( + verifier: string, + overrides?: Overrides & { from?: string } + ): Promise; + + unFreeze(overrides?: Overrides & { from?: string }): Promise; + + defaultVaultWithdrawalLock(overrides?: CallOverrides): Promise; + + "deposit(uint256,uint256,uint256)"( + starkKey: BigNumberish, + assetType: BigNumberish, + vaultId: BigNumberish, + overrides?: PayableOverrides & { from?: string } + ): Promise; + + "deposit(uint256,uint256,uint256,uint256)"( + starkKey: BigNumberish, + assetType: BigNumberish, + vaultId: BigNumberish, + quantizedAmount: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + depositCancel( + starkKey: BigNumberish, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + depositERC20( + starkKey: BigNumberish, + assetType: BigNumberish, + vaultId: BigNumberish, + quantizedAmount: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + depositEth( + starkKey: BigNumberish, + assetType: BigNumberish, + vaultId: BigNumberish, + overrides?: PayableOverrides & { from?: string } + ): Promise; + + depositNft( + starkKey: BigNumberish, + assetType: BigNumberish, + vaultId: BigNumberish, + tokenId: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + depositNftReclaim( + starkKey: BigNumberish, + assetType: BigNumberish, + vaultId: BigNumberish, + tokenId: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + depositReclaim( + starkKey: BigNumberish, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + getActionCount(overrides?: CallOverrides): Promise; + + getActionHashByIndex( + actionIndex: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getAssetInfo( + assetType: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getCancellationRequest( + starkKey: BigNumberish, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getDepositBalance( + starkKey: BigNumberish, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getEthKey( + ownerKey: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getFullWithdrawalRequest( + starkKey: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getQuantizedDepositBalance( + starkKey: BigNumberish, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getQuantum( + presumedAssetType: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getWithdrawalBalance( + ownerKey: BigNumberish, + assetId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + isAssetRegistered( + assetType: BigNumberish, + overrides?: CallOverrides + ): Promise; + + isTokenAdmin( + testedAdmin: string, + overrides?: CallOverrides + ): Promise; + + onERC721Received( + arg0: string, + arg1: string, + arg2: BigNumberish, + arg3: BytesLike, + overrides?: Overrides & { from?: string } + ): Promise; + + orderRegistryAddress(overrides?: CallOverrides): Promise; + + registerAndDepositERC20( + ethKey: string, + starkKey: BigNumberish, + signature: BytesLike, + assetType: BigNumberish, + vaultId: BigNumberish, + quantizedAmount: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + registerAndDepositEth( + ethKey: string, + starkKey: BigNumberish, + signature: BytesLike, + assetType: BigNumberish, + vaultId: BigNumberish, + overrides?: PayableOverrides & { from?: string } + ): Promise; + + registerEthAddress( + ethKey: string, + starkKey: BigNumberish, + starkSignature: BytesLike, + overrides?: Overrides & { from?: string } + ): Promise; + + registerSender( + starkKey: BigNumberish, + starkSignature: BytesLike, + overrides?: Overrides & { from?: string } + ): Promise; + + "registerToken(uint256,bytes)"( + assetType: BigNumberish, + assetInfo: BytesLike, + overrides?: Overrides & { from?: string } + ): Promise; + + "registerToken(uint256,bytes,uint256)"( + assetType: BigNumberish, + assetInfo: BytesLike, + quantum: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + registerTokenAdmin( + newAdmin: string, + overrides?: Overrides & { from?: string } + ): Promise; + + unregisterTokenAdmin( + oldAdmin: string, + overrides?: Overrides & { from?: string } + ): Promise; + + withdraw( + ownerKey: BigNumberish, + assetType: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + withdrawAndMint( + ownerKey: BigNumberish, + assetType: BigNumberish, + mintingBlob: BytesLike, + overrides?: Overrides & { from?: string } + ): Promise; + + withdrawNft( + ownerKey: BigNumberish, + assetType: BigNumberish, + tokenId: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + STARKEX_MAX_DEFAULT_VAULT_LOCK( + overrides?: CallOverrides + ): Promise; + + escape( + starkKey: BigNumberish, + vaultId: BigNumberish, + assetId: BigNumberish, + quantizedAmount: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + getLastBatchId(overrides?: CallOverrides): Promise; + + getOrderRoot(overrides?: CallOverrides): Promise; + + getOrderTreeHeight(overrides?: CallOverrides): Promise; + + getSequenceNumber(overrides?: CallOverrides): Promise; + + getVaultRoot(overrides?: CallOverrides): Promise; + + getVaultTreeHeight(overrides?: CallOverrides): Promise; + + isOperator( + testedOperator: string, + overrides?: CallOverrides + ): Promise; + + registerOperator( + newOperator: string, + overrides?: Overrides & { from?: string } + ): Promise; + + unregisterOperator( + removedOperator: string, + overrides?: Overrides & { from?: string } + ): Promise; + + updateState( + publicInput: BigNumberish[], + applicationData: BigNumberish[], + overrides?: Overrides & { from?: string } + ): Promise; + + freezeRequest( + starkKey: BigNumberish, + vaultId: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + fullWithdrawalRequest( + starkKey: BigNumberish, + vaultId: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + depositERC20ToVault( + assetId: BigNumberish, + vaultId: BigNumberish, + quantizedAmount: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + depositEthToVault( + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: PayableOverrides & { from?: string } + ): Promise; + + getQuantizedVaultBalance( + ethKey: string, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getVaultBalance( + ethKey: string, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getVaultWithdrawalLock( + ethKey: string, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + isStrictVaultBalancePolicy(overrides?: CallOverrides): Promise; + + isVaultLocked( + ethKey: string, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + lockVault( + assetId: BigNumberish, + vaultId: BigNumberish, + lockTime: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + setDefaultVaultWithdrawalLock( + newDefaultTime: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + withdrawFromVault( + assetId: BigNumberish, + vaultId: BigNumberish, + quantizedAmount: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + updateImplementationActivationTime( + implementation: string, + data: BytesLike, + finalize: boolean, + overrides?: Overrides & { from?: string } + ): Promise; + }; + + populateTransaction: { + VERSION(overrides?: CallOverrides): Promise; + + initialize( + data: BytesLike, + overrides?: Overrides & { from?: string } + ): Promise; + + DEPOSIT_CANCEL_DELAY( + overrides?: CallOverrides + ): Promise; + + FREEZE_GRACE_PERIOD( + overrides?: CallOverrides + ): Promise; + + MAIN_GOVERNANCE_INFO_TAG( + overrides?: CallOverrides + ): Promise; + + MAX_FORCED_ACTIONS_REQS_PER_BLOCK( + overrides?: CallOverrides + ): Promise; + + MAX_VERIFIER_COUNT( + overrides?: CallOverrides + ): Promise; + + UNFREEZE_DELAY(overrides?: CallOverrides): Promise; + + VERIFIER_REMOVAL_DELAY( + overrides?: CallOverrides + ): Promise; + + announceAvailabilityVerifierRemovalIntent( + verifier: string, + overrides?: Overrides & { from?: string } + ): Promise; + + announceVerifierRemovalIntent( + verifier: string, + overrides?: Overrides & { from?: string } + ): Promise; + + getRegisteredAvailabilityVerifiers( + overrides?: CallOverrides + ): Promise; + + getRegisteredVerifiers( + overrides?: CallOverrides + ): Promise; + + isAvailabilityVerifier( + verifierAddress: string, + overrides?: CallOverrides + ): Promise; + + isFrozen(overrides?: CallOverrides): Promise; + + isVerifier( + verifierAddress: string, + overrides?: CallOverrides + ): Promise; + + mainAcceptGovernance( + overrides?: Overrides & { from?: string } + ): Promise; + + mainCancelNomination( + overrides?: Overrides & { from?: string } + ): Promise; + + mainIsGovernor( + testGovernor: string, + overrides?: CallOverrides + ): Promise; + + mainNominateNewGovernor( + newGovernor: string, + overrides?: Overrides & { from?: string } + ): Promise; + + mainRemoveGovernor( + governorForRemoval: string, + overrides?: Overrides & { from?: string } + ): Promise; + + registerAvailabilityVerifier( + verifier: string, + identifier: string, + overrides?: Overrides & { from?: string } + ): Promise; + + registerVerifier( + verifier: string, + identifier: string, + overrides?: Overrides & { from?: string } + ): Promise; + + removeAvailabilityVerifier( + verifier: string, + overrides?: Overrides & { from?: string } + ): Promise; + + removeVerifier( + verifier: string, + overrides?: Overrides & { from?: string } + ): Promise; + + unFreeze( + overrides?: Overrides & { from?: string } + ): Promise; + + defaultVaultWithdrawalLock( + overrides?: CallOverrides + ): Promise; + + "deposit(uint256,uint256,uint256)"( + starkKey: BigNumberish, + assetType: BigNumberish, + vaultId: BigNumberish, + overrides?: PayableOverrides & { from?: string } + ): Promise; + + "deposit(uint256,uint256,uint256,uint256)"( + starkKey: BigNumberish, + assetType: BigNumberish, + vaultId: BigNumberish, + quantizedAmount: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + depositCancel( + starkKey: BigNumberish, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + depositERC20( + starkKey: BigNumberish, + assetType: BigNumberish, + vaultId: BigNumberish, + quantizedAmount: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + depositEth( + starkKey: BigNumberish, + assetType: BigNumberish, + vaultId: BigNumberish, + overrides?: PayableOverrides & { from?: string } + ): Promise; + + depositNft( + starkKey: BigNumberish, + assetType: BigNumberish, + vaultId: BigNumberish, + tokenId: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + depositNftReclaim( + starkKey: BigNumberish, + assetType: BigNumberish, + vaultId: BigNumberish, + tokenId: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + depositReclaim( + starkKey: BigNumberish, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + getActionCount(overrides?: CallOverrides): Promise; + + getActionHashByIndex( + actionIndex: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getAssetInfo( + assetType: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getCancellationRequest( + starkKey: BigNumberish, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getDepositBalance( + starkKey: BigNumberish, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getEthKey( + ownerKey: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getFullWithdrawalRequest( + starkKey: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getQuantizedDepositBalance( + starkKey: BigNumberish, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getQuantum( + presumedAssetType: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getWithdrawalBalance( + ownerKey: BigNumberish, + assetId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + isAssetRegistered( + assetType: BigNumberish, + overrides?: CallOverrides + ): Promise; + + isTokenAdmin( + testedAdmin: string, + overrides?: CallOverrides + ): Promise; + + onERC721Received( + arg0: string, + arg1: string, + arg2: BigNumberish, + arg3: BytesLike, + overrides?: Overrides & { from?: string } + ): Promise; + + orderRegistryAddress( + overrides?: CallOverrides + ): Promise; + + registerAndDepositERC20( + ethKey: string, + starkKey: BigNumberish, + signature: BytesLike, + assetType: BigNumberish, + vaultId: BigNumberish, + quantizedAmount: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + registerAndDepositEth( + ethKey: string, + starkKey: BigNumberish, + signature: BytesLike, + assetType: BigNumberish, + vaultId: BigNumberish, + overrides?: PayableOverrides & { from?: string } + ): Promise; + + registerEthAddress( + ethKey: string, + starkKey: BigNumberish, + starkSignature: BytesLike, + overrides?: Overrides & { from?: string } + ): Promise; + + registerSender( + starkKey: BigNumberish, + starkSignature: BytesLike, + overrides?: Overrides & { from?: string } + ): Promise; + + "registerToken(uint256,bytes)"( + assetType: BigNumberish, + assetInfo: BytesLike, + overrides?: Overrides & { from?: string } + ): Promise; + + "registerToken(uint256,bytes,uint256)"( + assetType: BigNumberish, + assetInfo: BytesLike, + quantum: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + registerTokenAdmin( + newAdmin: string, + overrides?: Overrides & { from?: string } + ): Promise; + + unregisterTokenAdmin( + oldAdmin: string, + overrides?: Overrides & { from?: string } + ): Promise; + + withdraw( + ownerKey: BigNumberish, + assetType: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + withdrawAndMint( + ownerKey: BigNumberish, + assetType: BigNumberish, + mintingBlob: BytesLike, + overrides?: Overrides & { from?: string } + ): Promise; + + withdrawNft( + ownerKey: BigNumberish, + assetType: BigNumberish, + tokenId: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + STARKEX_MAX_DEFAULT_VAULT_LOCK( + overrides?: CallOverrides + ): Promise; + + escape( + starkKey: BigNumberish, + vaultId: BigNumberish, + assetId: BigNumberish, + quantizedAmount: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + getLastBatchId(overrides?: CallOverrides): Promise; + + getOrderRoot(overrides?: CallOverrides): Promise; + + getOrderTreeHeight( + overrides?: CallOverrides + ): Promise; + + getSequenceNumber(overrides?: CallOverrides): Promise; + + getVaultRoot(overrides?: CallOverrides): Promise; + + getVaultTreeHeight( + overrides?: CallOverrides + ): Promise; + + isOperator( + testedOperator: string, + overrides?: CallOverrides + ): Promise; + + registerOperator( + newOperator: string, + overrides?: Overrides & { from?: string } + ): Promise; + + unregisterOperator( + removedOperator: string, + overrides?: Overrides & { from?: string } + ): Promise; + + updateState( + publicInput: BigNumberish[], + applicationData: BigNumberish[], + overrides?: Overrides & { from?: string } + ): Promise; + + freezeRequest( + starkKey: BigNumberish, + vaultId: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + fullWithdrawalRequest( + starkKey: BigNumberish, + vaultId: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + depositERC20ToVault( + assetId: BigNumberish, + vaultId: BigNumberish, + quantizedAmount: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + depositEthToVault( + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: PayableOverrides & { from?: string } + ): Promise; + + getQuantizedVaultBalance( + ethKey: string, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getVaultBalance( + ethKey: string, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + getVaultWithdrawalLock( + ethKey: string, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + isStrictVaultBalancePolicy( + overrides?: CallOverrides + ): Promise; + + isVaultLocked( + ethKey: string, + assetId: BigNumberish, + vaultId: BigNumberish, + overrides?: CallOverrides + ): Promise; + + lockVault( + assetId: BigNumberish, + vaultId: BigNumberish, + lockTime: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + setDefaultVaultWithdrawalLock( + newDefaultTime: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + withdrawFromVault( + assetId: BigNumberish, + vaultId: BigNumberish, + quantizedAmount: BigNumberish, + overrides?: Overrides & { from?: string } + ): Promise; + + updateImplementationActivationTime( + implementation: string, + data: BytesLike, + finalize: boolean, + overrides?: Overrides & { from?: string } + ): Promise; + }; +} diff --git a/src/contracts/contracts/index.ts b/src/contracts/contracts/index.ts index 957b08bf..c46f6e86 100644 --- a/src/contracts/contracts/index.ts +++ b/src/contracts/contracts/index.ts @@ -1,5 +1,6 @@ /* Autogenerated file. Do not edit manually. */ /* tslint:disable */ /* eslint-disable */ -export type { Core } from "./Core"; +export type { StarkV3 } from "./StarkV3"; +export type { StarkV4 } from "./StarkV4"; export type { Registration } from "./Registration"; diff --git a/src/contracts/factories/contracts/Core__factory.ts b/src/contracts/factories/contracts/StarkV3__factory.ts similarity index 99% rename from src/contracts/factories/contracts/Core__factory.ts rename to src/contracts/factories/contracts/StarkV3__factory.ts index 291c1663..5df5f91c 100644 --- a/src/contracts/factories/contracts/Core__factory.ts +++ b/src/contracts/factories/contracts/StarkV3__factory.ts @@ -4,7 +4,7 @@ import { Contract, Signer, utils } from "ethers"; import type { Provider } from "@ethersproject/providers"; -import type { Core, CoreInterface } from "../../contracts/Core"; +import type { StarkV3, StarkV3Interface } from "../../contracts/StarkV3"; const _abi = [ { @@ -1597,12 +1597,12 @@ const _abi = [ }, ]; -export class Core__factory { +export class StarkV3__factory { static readonly abi = _abi; - static createInterface(): CoreInterface { - return new utils.Interface(_abi) as CoreInterface; + static createInterface(): StarkV3Interface { + return new utils.Interface(_abi) as StarkV3Interface; } - static connect(address: string, signerOrProvider: Signer | Provider): Core { - return new Contract(address, _abi, signerOrProvider) as Core; + static connect(address: string, signerOrProvider: Signer | Provider): StarkV3 { + return new Contract(address, _abi, signerOrProvider) as StarkV3; } } diff --git a/src/contracts/factories/contracts/StarkV4__factory.ts b/src/contracts/factories/contracts/StarkV4__factory.ts new file mode 100644 index 00000000..6df04295 --- /dev/null +++ b/src/contracts/factories/contracts/StarkV4__factory.ts @@ -0,0 +1,2436 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { StarkV4, StarkV4Interface } from "../../contracts/StarkV4"; + +const _abi = [ + { + stateMutability: "payable", + type: "fallback", + }, + { + inputs: [], + name: "VERSION", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "initialize", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + stateMutability: "payable", + type: "receive", + }, + { + anonymous: false, + inputs: [], + name: "LogFrozen", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "acceptedGovernor", + type: "address", + }, + ], + name: "LogNewGovernorAccepted", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "nominatedGovernor", + type: "address", + }, + ], + name: "LogNominatedGovernor", + type: "event", + }, + { + anonymous: false, + inputs: [], + name: "LogNominationCancelled", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "entry", + type: "address", + }, + { + indexed: false, + internalType: "string", + name: "entryId", + type: "string", + }, + ], + name: "LogRegistered", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "entry", + type: "address", + }, + { + indexed: false, + internalType: "string", + name: "entryId", + type: "string", + }, + ], + name: "LogRemovalIntent", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "entry", + type: "address", + }, + { + indexed: false, + internalType: "string", + name: "entryId", + type: "string", + }, + ], + name: "LogRemoved", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "removedGovernor", + type: "address", + }, + ], + name: "LogRemovedGovernor", + type: "event", + }, + { + anonymous: false, + inputs: [], + name: "LogUnFrozen", + type: "event", + }, + { + inputs: [], + name: "DEPOSIT_CANCEL_DELAY", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "FREEZE_GRACE_PERIOD", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "MAIN_GOVERNANCE_INFO_TAG", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "MAX_FORCED_ACTIONS_REQS_PER_BLOCK", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "MAX_VERIFIER_COUNT", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "UNFREEZE_DELAY", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "VERIFIER_REMOVAL_DELAY", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "verifier", + type: "address", + }, + ], + name: "announceAvailabilityVerifierRemovalIntent", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "verifier", + type: "address", + }, + ], + name: "announceVerifierRemovalIntent", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "getRegisteredAvailabilityVerifiers", + outputs: [ + { + internalType: "address[]", + name: "_verifers", + type: "address[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "getRegisteredVerifiers", + outputs: [ + { + internalType: "address[]", + name: "_verifers", + type: "address[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "verifierAddress", + type: "address", + }, + ], + name: "isAvailabilityVerifier", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "isFrozen", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "verifierAddress", + type: "address", + }, + ], + name: "isVerifier", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "mainAcceptGovernance", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "mainCancelNomination", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "testGovernor", + type: "address", + }, + ], + name: "mainIsGovernor", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newGovernor", + type: "address", + }, + ], + name: "mainNominateNewGovernor", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "governorForRemoval", + type: "address", + }, + ], + name: "mainRemoveGovernor", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "verifier", + type: "address", + }, + { + internalType: "string", + name: "identifier", + type: "string", + }, + ], + name: "registerAvailabilityVerifier", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "verifier", + type: "address", + }, + { + internalType: "string", + name: "identifier", + type: "string", + }, + ], + name: "registerVerifier", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "verifier", + type: "address", + }, + ], + name: "removeAvailabilityVerifier", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "verifier", + type: "address", + }, + ], + name: "removeVerifier", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "unFreeze", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "depositorEthKey", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "starkKey", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "assetType", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "nonQuantizedAmount", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "quantizedAmount", + type: "uint256", + }, + ], + name: "LogDeposit", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "starkKey", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "assetId", + type: "uint256", + }, + ], + name: "LogDepositCancel", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "starkKey", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "assetType", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "nonQuantizedAmount", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "quantizedAmount", + type: "uint256", + }, + ], + name: "LogDepositCancelReclaimed", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "starkKey", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "assetType", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "tokenId", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "assetId", + type: "uint256", + }, + ], + name: "LogDepositNftCancelReclaimed", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "ownerKey", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "assetType", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "nonQuantizedAmount", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "quantizedAmount", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "assetId", + type: "uint256", + }, + ], + name: "LogMintWithdrawalPerformed", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "ownerKey", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "assetId", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "quantizedAmount", + type: "uint256", + }, + ], + name: "LogMintableWithdrawalAllowed", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "depositorEthKey", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "starkKey", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "assetType", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "tokenId", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "assetId", + type: "uint256", + }, + ], + name: "LogNftDeposit", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "ownerKey", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "assetId", + type: "uint256", + }, + ], + name: "LogNftWithdrawalAllowed", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "ownerKey", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "assetType", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "tokenId", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "assetId", + type: "uint256", + }, + { + indexed: false, + internalType: "address", + name: "recipient", + type: "address", + }, + ], + name: "LogNftWithdrawalPerformed", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "tokenAdmin", + type: "address", + }, + ], + name: "LogTokenAdminAdded", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "tokenAdmin", + type: "address", + }, + ], + name: "LogTokenAdminRemoved", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "assetType", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "assetInfo", + type: "bytes", + }, + { + indexed: false, + internalType: "uint256", + name: "quantum", + type: "uint256", + }, + ], + name: "LogTokenRegistered", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "ethKey", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "starkKey", + type: "uint256", + }, + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + ], + name: "LogUserRegistered", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "ownerKey", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "assetType", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "nonQuantizedAmount", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "quantizedAmount", + type: "uint256", + }, + ], + name: "LogWithdrawalAllowed", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "ownerKey", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "assetType", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "nonQuantizedAmount", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "quantizedAmount", + type: "uint256", + }, + { + indexed: false, + internalType: "address", + name: "recipient", + type: "address", + }, + ], + name: "LogWithdrawalPerformed", + type: "event", + }, + { + inputs: [], + name: "defaultVaultWithdrawalLock", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "starkKey", + type: "uint256", + }, + { + internalType: "uint256", + name: "assetType", + type: "uint256", + }, + { + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + ], + name: "deposit", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "starkKey", + type: "uint256", + }, + { + internalType: "uint256", + name: "assetType", + type: "uint256", + }, + { + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + { + internalType: "uint256", + name: "quantizedAmount", + type: "uint256", + }, + ], + name: "deposit", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "starkKey", + type: "uint256", + }, + { + internalType: "uint256", + name: "assetId", + type: "uint256", + }, + { + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + ], + name: "depositCancel", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "starkKey", + type: "uint256", + }, + { + internalType: "uint256", + name: "assetType", + type: "uint256", + }, + { + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + { + internalType: "uint256", + name: "quantizedAmount", + type: "uint256", + }, + ], + name: "depositERC20", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "starkKey", + type: "uint256", + }, + { + internalType: "uint256", + name: "assetType", + type: "uint256", + }, + { + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + ], + name: "depositEth", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "starkKey", + type: "uint256", + }, + { + internalType: "uint256", + name: "assetType", + type: "uint256", + }, + { + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + { + internalType: "uint256", + name: "tokenId", + type: "uint256", + }, + ], + name: "depositNft", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "starkKey", + type: "uint256", + }, + { + internalType: "uint256", + name: "assetType", + type: "uint256", + }, + { + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + { + internalType: "uint256", + name: "tokenId", + type: "uint256", + }, + ], + name: "depositNftReclaim", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "starkKey", + type: "uint256", + }, + { + internalType: "uint256", + name: "assetId", + type: "uint256", + }, + { + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + ], + name: "depositReclaim", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "getActionCount", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "actionIndex", + type: "uint256", + }, + ], + name: "getActionHashByIndex", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "assetType", + type: "uint256", + }, + ], + name: "getAssetInfo", + outputs: [ + { + internalType: "bytes", + name: "assetInfo", + type: "bytes", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "starkKey", + type: "uint256", + }, + { + internalType: "uint256", + name: "assetId", + type: "uint256", + }, + { + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + ], + name: "getCancellationRequest", + outputs: [ + { + internalType: "uint256", + name: "request", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "starkKey", + type: "uint256", + }, + { + internalType: "uint256", + name: "assetId", + type: "uint256", + }, + { + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + ], + name: "getDepositBalance", + outputs: [ + { + internalType: "uint256", + name: "balance", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "ownerKey", + type: "uint256", + }, + ], + name: "getEthKey", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "starkKey", + type: "uint256", + }, + { + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + ], + name: "getFullWithdrawalRequest", + outputs: [ + { + internalType: "uint256", + name: "res", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "starkKey", + type: "uint256", + }, + { + internalType: "uint256", + name: "assetId", + type: "uint256", + }, + { + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + ], + name: "getQuantizedDepositBalance", + outputs: [ + { + internalType: "uint256", + name: "balance", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "presumedAssetType", + type: "uint256", + }, + ], + name: "getQuantum", + outputs: [ + { + internalType: "uint256", + name: "quantum", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "ownerKey", + type: "uint256", + }, + { + internalType: "uint256", + name: "assetId", + type: "uint256", + }, + ], + name: "getWithdrawalBalance", + outputs: [ + { + internalType: "uint256", + name: "balance", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "assetType", + type: "uint256", + }, + ], + name: "isAssetRegistered", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "testedAdmin", + type: "address", + }, + ], + name: "isTokenAdmin", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + { + internalType: "address", + name: "", + type: "address", + }, + { + internalType: "uint256", + name: "", + type: "uint256", + }, + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + name: "onERC721Received", + outputs: [ + { + internalType: "bytes4", + name: "", + type: "bytes4", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "orderRegistryAddress", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "ethKey", + type: "address", + }, + { + internalType: "uint256", + name: "starkKey", + type: "uint256", + }, + { + internalType: "bytes", + name: "signature", + type: "bytes", + }, + { + internalType: "uint256", + name: "assetType", + type: "uint256", + }, + { + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + { + internalType: "uint256", + name: "quantizedAmount", + type: "uint256", + }, + ], + name: "registerAndDepositERC20", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "ethKey", + type: "address", + }, + { + internalType: "uint256", + name: "starkKey", + type: "uint256", + }, + { + internalType: "bytes", + name: "signature", + type: "bytes", + }, + { + internalType: "uint256", + name: "assetType", + type: "uint256", + }, + { + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + ], + name: "registerAndDepositEth", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "ethKey", + type: "address", + }, + { + internalType: "uint256", + name: "starkKey", + type: "uint256", + }, + { + internalType: "bytes", + name: "starkSignature", + type: "bytes", + }, + ], + name: "registerEthAddress", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "starkKey", + type: "uint256", + }, + { + internalType: "bytes", + name: "starkSignature", + type: "bytes", + }, + ], + name: "registerSender", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "assetType", + type: "uint256", + }, + { + internalType: "bytes", + name: "assetInfo", + type: "bytes", + }, + ], + name: "registerToken", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "assetType", + type: "uint256", + }, + { + internalType: "bytes", + name: "assetInfo", + type: "bytes", + }, + { + internalType: "uint256", + name: "quantum", + type: "uint256", + }, + ], + name: "registerToken", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newAdmin", + type: "address", + }, + ], + name: "registerTokenAdmin", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "oldAdmin", + type: "address", + }, + ], + name: "unregisterTokenAdmin", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "ownerKey", + type: "uint256", + }, + { + internalType: "uint256", + name: "assetType", + type: "uint256", + }, + ], + name: "withdraw", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "ownerKey", + type: "uint256", + }, + { + internalType: "uint256", + name: "assetType", + type: "uint256", + }, + { + internalType: "bytes", + name: "mintingBlob", + type: "bytes", + }, + ], + name: "withdrawAndMint", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "ownerKey", + type: "uint256", + }, + { + internalType: "uint256", + name: "assetType", + type: "uint256", + }, + { + internalType: "uint256", + name: "tokenId", + type: "uint256", + }, + ], + name: "withdrawNft", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "operator", + type: "address", + }, + ], + name: "LogOperatorAdded", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "operator", + type: "address", + }, + ], + name: "LogOperatorRemoved", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "sequenceNumber", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "batchId", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "vaultRoot", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "orderRoot", + type: "uint256", + }, + ], + name: "LogRootUpdate", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes32", + name: "stateTransitionFact", + type: "bytes32", + }, + ], + name: "LogStateTransitionFact", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "ethKey", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "assetId", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + { + indexed: false, + internalType: "int256", + name: "quantizedAmountChange", + type: "int256", + }, + ], + name: "LogVaultBalanceChangeApplied", + type: "event", + }, + { + inputs: [], + name: "STARKEX_MAX_DEFAULT_VAULT_LOCK", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "starkKey", + type: "uint256", + }, + { + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + { + internalType: "uint256", + name: "assetId", + type: "uint256", + }, + { + internalType: "uint256", + name: "quantizedAmount", + type: "uint256", + }, + ], + name: "escape", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "getLastBatchId", + outputs: [ + { + internalType: "uint256", + name: "batchId", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "getOrderRoot", + outputs: [ + { + internalType: "uint256", + name: "root", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "getOrderTreeHeight", + outputs: [ + { + internalType: "uint256", + name: "height", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "getSequenceNumber", + outputs: [ + { + internalType: "uint256", + name: "seq", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "getVaultRoot", + outputs: [ + { + internalType: "uint256", + name: "root", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "getVaultTreeHeight", + outputs: [ + { + internalType: "uint256", + name: "height", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "testedOperator", + type: "address", + }, + ], + name: "isOperator", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newOperator", + type: "address", + }, + ], + name: "registerOperator", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "removedOperator", + type: "address", + }, + ], + name: "unregisterOperator", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256[]", + name: "publicInput", + type: "uint256[]", + }, + { + internalType: "uint256[]", + name: "applicationData", + type: "uint256[]", + }, + ], + name: "updateState", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "starkKey", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + ], + name: "LogFullWithdrawalRequest", + type: "event", + }, + { + inputs: [ + { + internalType: "uint256", + name: "starkKey", + type: "uint256", + }, + { + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + ], + name: "freezeRequest", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "starkKey", + type: "uint256", + }, + { + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + ], + name: "fullWithdrawalRequest", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "newDefaultLockTime", + type: "uint256", + }, + ], + name: "LogDefaultVaultWithdrawalLockSet", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "ethKey", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "assetId", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "nonQuantizedAmount", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "quantizedAmount", + type: "uint256", + }, + ], + name: "LogDepositToVault", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "ethKey", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "assetId", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "timeRelease", + type: "uint256", + }, + ], + name: "LogVaultWithdrawalLockSet", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "ethKey", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "assetId", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "nonQuantizedAmount", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "quantizedAmount", + type: "uint256", + }, + ], + name: "LogWithdrawalFromVault", + type: "event", + }, + { + inputs: [ + { + internalType: "uint256", + name: "assetId", + type: "uint256", + }, + { + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + { + internalType: "uint256", + name: "quantizedAmount", + type: "uint256", + }, + ], + name: "depositERC20ToVault", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "assetId", + type: "uint256", + }, + { + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + ], + name: "depositEthToVault", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "ethKey", + type: "address", + }, + { + internalType: "uint256", + name: "assetId", + type: "uint256", + }, + { + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + ], + name: "getQuantizedVaultBalance", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "ethKey", + type: "address", + }, + { + internalType: "uint256", + name: "assetId", + type: "uint256", + }, + { + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + ], + name: "getVaultBalance", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "ethKey", + type: "address", + }, + { + internalType: "uint256", + name: "assetId", + type: "uint256", + }, + { + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + ], + name: "getVaultWithdrawalLock", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "isStrictVaultBalancePolicy", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "ethKey", + type: "address", + }, + { + internalType: "uint256", + name: "assetId", + type: "uint256", + }, + { + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + ], + name: "isVaultLocked", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "assetId", + type: "uint256", + }, + { + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + { + internalType: "uint256", + name: "lockTime", + type: "uint256", + }, + ], + name: "lockVault", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "newDefaultTime", + type: "uint256", + }, + ], + name: "setDefaultVaultWithdrawalLock", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "assetId", + type: "uint256", + }, + { + internalType: "uint256", + name: "vaultId", + type: "uint256", + }, + { + internalType: "uint256", + name: "quantizedAmount", + type: "uint256", + }, + ], + name: "withdrawFromVault", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "implementation", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "updatedActivationTime", + type: "uint256", + }, + ], + name: "ImplementationActivationRescheduled", + type: "event", + }, + { + inputs: [ + { + internalType: "address", + name: "implementation", + type: "address", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + { + internalType: "bool", + name: "finalize", + type: "bool", + }, + ], + name: "updateImplementationActivationTime", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, +] as const; + +export class StarkV4__factory { + static readonly abi = _abi; + static createInterface(): StarkV4Interface { + return new utils.Interface(_abi) as StarkV4Interface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): StarkV4 { + return new Contract(address, _abi, signerOrProvider) as StarkV4; + } +} diff --git a/src/contracts/factories/contracts/index.ts b/src/contracts/factories/contracts/index.ts index 4811ed30..4daa8254 100644 --- a/src/contracts/factories/contracts/index.ts +++ b/src/contracts/factories/contracts/index.ts @@ -1,5 +1,6 @@ /* Autogenerated file. Do not edit manually. */ /* tslint:disable */ /* eslint-disable */ -export { Core__factory } from "./Core__factory"; +export { StarkV3__factory } from "./StarkV3__factory"; +export { StarkV4__factory } from "./StarkV4__factory"; export { Registration__factory } from "./Registration__factory"; diff --git a/src/contracts/index.ts b/src/contracts/index.ts index 664dabce..90e26d92 100644 --- a/src/contracts/index.ts +++ b/src/contracts/index.ts @@ -13,7 +13,9 @@ export type { IERC721 } from './@openzeppelin/contracts/token/ERC721/IERC721'; export { IERC721__factory } from './factories/@openzeppelin/contracts/token/ERC721/IERC721__factory'; export type { IERC165 } from './@openzeppelin/contracts/utils/introspection/IERC165'; export { IERC165__factory } from './factories/@openzeppelin/contracts/utils/introspection/IERC165__factory'; -export type { Core } from './contracts/Core'; -export { Core__factory } from './factories/contracts/Core__factory'; +export type { StarkV3 } from './contracts/StarkV3'; +export { StarkV3__factory } from './factories/contracts/StarkV3__factory'; +export type { StarkV4 } from './contracts/StarkV4'; +export { StarkV4__factory } from './factories/contracts/StarkV4__factory'; export type { Registration } from './contracts/Registration'; export { Registration__factory } from './factories/contracts/Registration__factory'; diff --git a/src/exportContracts.ts b/src/exportContracts.ts index e667955e..dce0e68e 100644 --- a/src/exportContracts.ts +++ b/src/exportContracts.ts @@ -1,5 +1,5 @@ export { - Core__factory as Core, + StarkV3__factory as StarkV3, Registration__factory as Registration, IERC20__factory as IERC20, IERC721__factory as IERC721, diff --git a/src/workflows/deposit/depositERC20.ts b/src/workflows/deposit/depositERC20.ts index 1a452fa1..5705df2c 100644 --- a/src/workflows/deposit/depositERC20.ts +++ b/src/workflows/deposit/depositERC20.ts @@ -3,8 +3,8 @@ import { TransactionResponse } from '@ethersproject/providers'; import { DepositsApi, EncodingApi, TokensApi, UsersApi } from '../../api'; import { parseUnits } from '@ethersproject/units'; import { - Core, - Core__factory, + StarkV3, + StarkV3__factory, IERC20__factory, Registration__factory, } from '../../contracts'; @@ -27,7 +27,7 @@ async function executeDepositERC20( assetType: string, starkPublicKey: string, vaultId: number, - contract: Core, + contract: StarkV3, ): Promise { const populatedTransaction = await contract.populateTransaction.depositERC20( starkPublicKey, @@ -45,7 +45,7 @@ async function executeRegisterAndDepositERC20( assetType: string, starkPublicKey: string, vaultId: number, - contract: Core, + contract: StarkV3, usersApi: UsersApi, ): Promise { const etherKey = await signer.getAddress(); @@ -130,7 +130,7 @@ export async function depositERC20Workflow( const vaultId = signableDepositResult.data.vault_id; const quantizedAmount = BigNumber.from(signableDepositResult.data.amount); - const coreContract = Core__factory.connect( + const coreContract = StarkV3__factory.connect( config.ethConfiguration.coreContractAddress, signer, ); diff --git a/src/workflows/deposit/depositERC721.ts b/src/workflows/deposit/depositERC721.ts index 64e8209f..0c0a8420 100644 --- a/src/workflows/deposit/depositERC721.ts +++ b/src/workflows/deposit/depositERC721.ts @@ -2,8 +2,8 @@ import { Signer } from '@ethersproject/abstract-signer'; import { TransactionResponse } from '@ethersproject/providers'; import { DepositsApi, EncodingApi, UsersApi } from '../../api'; import { - Core, - Core__factory, + StarkV3, + StarkV3__factory, IERC721__factory, Registration__factory, } from '../../contracts'; @@ -25,7 +25,7 @@ async function executeDepositERC721( assetType: string, starkPublicKey: string, vaultId: number, - contract: Core, + contract: StarkV3, ): Promise { const populatedTransaction = await contract.populateTransaction.depositNft( starkPublicKey, @@ -85,7 +85,7 @@ export async function depositERC721Workflow( const starkPublicKey = signableDepositResult.data.stark_key; const vaultId = signableDepositResult.data.vault_id; - const coreContract = Core__factory.connect( + const coreContract = StarkV3__factory.connect( config.ethConfiguration.coreContractAddress, signer, ); diff --git a/src/workflows/deposit/depositEth.ts b/src/workflows/deposit/depositEth.ts index b04502c6..9f3dddbb 100644 --- a/src/workflows/deposit/depositEth.ts +++ b/src/workflows/deposit/depositEth.ts @@ -2,7 +2,11 @@ import { Signer } from '@ethersproject/abstract-signer'; import { TransactionResponse } from '@ethersproject/providers'; import { DepositsApi, EncodingApi, UsersApi } from '../../api'; import { parseUnits } from '@ethersproject/units'; -import { Core, Core__factory, Registration__factory } from '../../contracts'; +import { + StarkV3, + StarkV3__factory, + Registration__factory, +} from '../../contracts'; import { getSignableRegistrationOnchain, isRegisteredOnChainWorkflow, @@ -21,7 +25,7 @@ async function executeRegisterAndDepositEth( assetType: string, starkPublicKey: string, vaultId: number, - contract: Core, + contract: StarkV3, usersApi: UsersApi, ): Promise { const etherKey = await signer.getAddress(); @@ -50,7 +54,7 @@ async function executeDepositEth( assetType: string, starkPublicKey: string, vaultId: number, - contract: Core, + contract: StarkV3, ): Promise { const populatedTransaction = await contract.populateTransaction[ 'deposit(uint256,uint256,uint256)' @@ -99,7 +103,7 @@ export async function depositEthWorkflow( const starkPublicKey = signableDepositResult.data.stark_key; const vaultId = signableDepositResult.data.vault_id; - const coreContract = Core__factory.connect( + const coreContract = StarkV3__factory.connect( config.ethConfiguration.coreContractAddress, signer, ); diff --git a/src/workflows/withdrawal/completeERC20Withdrawal.ts b/src/workflows/withdrawal/completeERC20Withdrawal.ts index de237098..a92083a3 100644 --- a/src/workflows/withdrawal/completeERC20Withdrawal.ts +++ b/src/workflows/withdrawal/completeERC20Withdrawal.ts @@ -3,8 +3,8 @@ import { TransactionResponse } from '@ethersproject/providers'; import { EncodingApi, UsersApi } from '../../api'; import { ImmutableXConfiguration } from '../../config'; import { - Core, - Core__factory, + StarkV3, + StarkV3__factory, Registration, Registration__factory, } from '../../contracts'; @@ -45,7 +45,7 @@ async function executeWithdrawERC20( signer: Signer, assetType: string, starkPublicKey: string, - contract: Core, + contract: StarkV3, ): Promise { const populatedTransaction = await contract.populateTransaction.withdraw( starkPublicKey, @@ -67,7 +67,7 @@ export async function completeERC20WithdrawalWorkflow( token_address: token.tokenAddress, }); - const coreContract = Core__factory.connect( + const coreContract = StarkV3__factory.connect( config.ethConfiguration.coreContractAddress, signer, ); diff --git a/src/workflows/withdrawal/completeERC721Withdrawal.ts b/src/workflows/withdrawal/completeERC721Withdrawal.ts index 9e09cda9..bf7a0b38 100644 --- a/src/workflows/withdrawal/completeERC721Withdrawal.ts +++ b/src/workflows/withdrawal/completeERC721Withdrawal.ts @@ -1,8 +1,8 @@ import { Signer } from '@ethersproject/abstract-signer'; import { EncodingApi, MintsApi, UsersApi } from '../../api'; import { - Core, - Core__factory, + StarkV3, + StarkV3__factory, Registration, Registration__factory, } from '../../contracts'; @@ -30,7 +30,7 @@ async function executeWithdrawMintableERC721( assetType: string, starkPublicKey: string, mintingBlob: string, - contract: Core, + contract: StarkV3, ): Promise { const populatedTransaction = await contract.populateTransaction.withdrawAndMint( @@ -95,7 +95,7 @@ async function completeMintableERC721Withdrawal( ); const mintingBlob = getMintingBlob(token); - const coreContract = Core__factory.connect( + const coreContract = StarkV3__factory.connect( config.ethConfiguration.coreContractAddress, signer, ); @@ -163,7 +163,7 @@ async function executeWithdrawERC721( assetType: string, starkPublicKey: string, tokenId: string, - contract: Core, + contract: StarkV3, ): Promise { const populatedTransaction = await contract.populateTransaction.withdrawNft( starkPublicKey, @@ -186,7 +186,7 @@ async function completeERC721Withdrawal( token_address: token.tokenAddress, }); - const coreContract = Core__factory.connect( + const coreContract = StarkV3__factory.connect( config.ethConfiguration.coreContractAddress, signer, ); diff --git a/src/workflows/withdrawal/completeEthWithdrawal.ts b/src/workflows/withdrawal/completeEthWithdrawal.ts index 130207b3..e906ba86 100644 --- a/src/workflows/withdrawal/completeEthWithdrawal.ts +++ b/src/workflows/withdrawal/completeEthWithdrawal.ts @@ -3,8 +3,8 @@ import { TransactionResponse } from '@ethersproject/providers'; import { EncodingApi, UsersApi } from '../../api'; import { ImmutableXConfiguration } from '../../config'; import { - Core, - Core__factory, + StarkV3, + StarkV3__factory, Registration, Registration__factory, } from '../../contracts'; @@ -44,7 +44,7 @@ async function executeWithdrawEth( signer: Signer, assetType: string, starkPublicKey: string, - contract: Core, + contract: StarkV3, ): Promise { const populatedTransaction = await contract.populateTransaction.withdraw( starkPublicKey, @@ -63,7 +63,7 @@ export async function completeEthWithdrawalWorkflow( ) { const assetType = await getEncodeAssetInfo('asset', 'ETH', encodingApi); - const coreContract = Core__factory.connect( + const coreContract = StarkV3__factory.connect( config.ethConfiguration.coreContractAddress, signer, );