Interface CoreV4Contract

Hierarchy

  • BaseContract
    • CoreV4Contract

Properties

interface off on once removeListener functions callStatic filters estimateGas populateTransaction address signer provider resolvedAddress deployTransaction _deployedPromise _runningEvents _wrappedEmits

Methods

connect attach deployed queryFilter listeners removeAllListeners DEPOSIT_CANCEL_DELAY FREEZE_GRACE_PERIOD MAIN_GOVERNANCE_INFO_TAG MAX_FORCED_ACTIONS_REQS_PER_BLOCK MAX_VERIFIER_COUNT STARKEX_MAX_DEFAULT_VAULT_LOCK UNFREEZE_DELAY VERIFIER_REMOVAL_DELAY VERSION announceAvailabilityVerifierRemovalIntent announceVerifierRemovalIntent defaultVaultWithdrawalLock deposit(uint256,uint256,uint256) deposit(uint256,uint256,uint256,uint256) depositCancel depositERC20 depositERC20ToVault depositEth depositEthToVault depositNft depositNftReclaim depositReclaim escape freezeRequest fullWithdrawalRequest getActionCount getActionHashByIndex getAssetInfo getCancellationRequest getDepositBalance getEthKey getFullWithdrawalRequest getLastBatchId getOrderRoot getOrderTreeHeight getQuantizedDepositBalance getQuantizedVaultBalance getQuantum getRegisteredAvailabilityVerifiers getRegisteredVerifiers getSequenceNumber getVaultBalance getVaultRoot getVaultTreeHeight getVaultWithdrawalLock getWithdrawalBalance initialize isAssetRegistered isAvailabilityVerifier isFrozen isOperator isStrictVaultBalancePolicy isTokenAdmin isVaultLocked isVerifier lockVault mainAcceptGovernance mainCancelNomination mainIsGovernor mainNominateNewGovernor mainRemoveGovernor onERC721Received orderRegistryAddress registerAndDepositERC20 registerAndDepositEth registerAvailabilityVerifier registerEthAddress registerOperator registerSender registerToken(uint256,bytes) registerToken(uint256,bytes,uint256) registerTokenAdmin registerVerifier removeAvailabilityVerifier removeVerifier setDefaultVaultWithdrawalLock unFreeze unregisterOperator unregisterTokenAdmin updateImplementationActivationTime updateState withdraw withdrawAndMint withdrawFromVault withdrawNft _deployed fallback _checkRunningEvents _wrapEvent emit listenerCount

Properties

interface

interface: CoreV4Interface

off

off: OnEvent<x.Contracts.CoreV4Contract>

on

on: OnEvent<x.Contracts.CoreV4Contract>

once

once: OnEvent<x.Contracts.CoreV4Contract>

removeListener

removeListener: OnEvent<x.Contracts.CoreV4Contract>

functions

functions: {
    DEPOSIT_CANCEL_DELAY(overrides?) => Promise<[BigNumber]>;
    FREEZE_GRACE_PERIOD(overrides?) => Promise<[BigNumber]>;
    MAIN_GOVERNANCE_INFO_TAG(overrides?) => Promise<[string]>;
    MAX_FORCED_ACTIONS_REQS_PER_BLOCK(overrides?) => Promise<[BigNumber]>;
    MAX_VERIFIER_COUNT(overrides?) => Promise<[BigNumber]>;
    STARKEX_MAX_DEFAULT_VAULT_LOCK(overrides?) => Promise<[BigNumber]>;
    UNFREEZE_DELAY(overrides?) => Promise<[BigNumber]>;
    VERIFIER_REMOVAL_DELAY(overrides?) => Promise<[BigNumber]>;
    VERSION(overrides?) => Promise<[string]>;
    announceAvailabilityVerifierRemovalIntent(verifier, overrides?) => Promise<ContractTransaction>;
    announceVerifierRemovalIntent(verifier, overrides?) => Promise<ContractTransaction>;
    defaultVaultWithdrawalLock(overrides?) => Promise<[BigNumber]>;
    deposit(uint256,uint256,uint256)(starkKey, assetType, vaultId, overrides?) => Promise<ContractTransaction>;
    deposit(uint256,uint256,uint256,uint256)(starkKey, assetType, vaultId, quantizedAmount, overrides?) => Promise<ContractTransaction>;
    depositCancel(starkKey, assetId, vaultId, overrides?) => Promise<ContractTransaction>;
    depositERC20(starkKey, assetType, vaultId, quantizedAmount, overrides?) => Promise<ContractTransaction>;
    depositERC20ToVault(assetId, vaultId, quantizedAmount, overrides?) => Promise<ContractTransaction>;
    depositEth(starkKey, assetType, vaultId, overrides?) => Promise<ContractTransaction>;
    depositEthToVault(assetId, vaultId, overrides?) => Promise<ContractTransaction>;
    depositNft(starkKey, assetType, vaultId, tokenId, overrides?) => Promise<ContractTransaction>;
    depositNftReclaim(starkKey, assetType, vaultId, tokenId, overrides?) => Promise<ContractTransaction>;
    depositReclaim(starkKey, assetId, vaultId, overrides?) => Promise<ContractTransaction>;
    escape(starkKey, vaultId, assetId, quantizedAmount, overrides?) => Promise<ContractTransaction>;
    freezeRequest(starkKey, vaultId, overrides?) => Promise<ContractTransaction>;
    fullWithdrawalRequest(starkKey, vaultId, overrides?) => Promise<ContractTransaction>;
    getActionCount(overrides?) => Promise<[BigNumber]>;
    getActionHashByIndex(actionIndex, overrides?) => Promise<[string]>;
    getAssetInfo(assetType, overrides?) => Promise<[string] & {
        assetInfo: string;
    }>;
    getCancellationRequest(starkKey, assetId, vaultId, overrides?) => Promise<[BigNumber] & {
        request: BigNumber;
    }>;
    getDepositBalance(starkKey, assetId, vaultId, overrides?) => Promise<[BigNumber] & {
        balance: BigNumber;
    }>;
    getEthKey(ownerKey, overrides?) => Promise<[string]>;
    getFullWithdrawalRequest(starkKey, vaultId, overrides?) => Promise<[BigNumber] & {
        res: BigNumber;
    }>;
    getLastBatchId(overrides?) => Promise<[BigNumber] & {
        batchId: BigNumber;
    }>;
    getOrderRoot(overrides?) => Promise<[BigNumber] & {
        root: BigNumber;
    }>;
    getOrderTreeHeight(overrides?) => Promise<[BigNumber] & {
        height: BigNumber;
    }>;
    getQuantizedDepositBalance(starkKey, assetId, vaultId, overrides?) => Promise<[BigNumber] & {
        balance: BigNumber;
    }>;
    getQuantizedVaultBalance(ethKey, assetId, vaultId, overrides?) => Promise<[BigNumber]>;
    getQuantum(presumedAssetType, overrides?) => Promise<[BigNumber] & {
        quantum: BigNumber;
    }>;
    getRegisteredAvailabilityVerifiers(overrides?) => Promise<[string[]] & {
        _verifers: string[];
    }>;
    getRegisteredVerifiers(overrides?) => Promise<[string[]] & {
        _verifers: string[];
    }>;
    getSequenceNumber(overrides?) => Promise<[BigNumber] & {
        seq: BigNumber;
    }>;
    getVaultBalance(ethKey, assetId, vaultId, overrides?) => Promise<[BigNumber]>;
    getVaultRoot(overrides?) => Promise<[BigNumber] & {
        root: BigNumber;
    }>;
    getVaultTreeHeight(overrides?) => Promise<[BigNumber] & {
        height: BigNumber;
    }>;
    getVaultWithdrawalLock(ethKey, assetId, vaultId, overrides?) => Promise<[BigNumber]>;
    getWithdrawalBalance(ownerKey, assetId, overrides?) => Promise<[BigNumber] & {
        balance: BigNumber;
    }>;
    initialize(data, overrides?) => Promise<ContractTransaction>;
    isAssetRegistered(assetType, overrides?) => Promise<[boolean]>;
    isAvailabilityVerifier(verifierAddress, overrides?) => Promise<[boolean]>;
    isFrozen(overrides?) => Promise<[boolean]>;
    isOperator(testedOperator, overrides?) => Promise<[boolean]>;
    isStrictVaultBalancePolicy(overrides?) => Promise<[boolean]>;
    isTokenAdmin(testedAdmin, overrides?) => Promise<[boolean]>;
    isVaultLocked(ethKey, assetId, vaultId, overrides?) => Promise<[boolean]>;
    isVerifier(verifierAddress, overrides?) => Promise<[boolean]>;
    lockVault(assetId, vaultId, lockTime, overrides?) => Promise<ContractTransaction>;
    mainAcceptGovernance(overrides?) => Promise<ContractTransaction>;
    mainCancelNomination(overrides?) => Promise<ContractTransaction>;
    mainIsGovernor(testGovernor, overrides?) => Promise<[boolean]>;
    mainNominateNewGovernor(newGovernor, overrides?) => Promise<ContractTransaction>;
    mainRemoveGovernor(governorForRemoval, overrides?) => Promise<ContractTransaction>;
    onERC721Received(arg0, arg1, arg2, arg3, overrides?) => Promise<ContractTransaction>;
    orderRegistryAddress(overrides?) => Promise<[string]>;
    registerAndDepositERC20(ethKey, starkKey, signature, assetType, vaultId, quantizedAmount, overrides?) => Promise<ContractTransaction>;
    registerAndDepositEth(ethKey, starkKey, signature, assetType, vaultId, overrides?) => Promise<ContractTransaction>;
    registerAvailabilityVerifier(verifier, identifier, overrides?) => Promise<ContractTransaction>;
    registerEthAddress(ethKey, starkKey, starkSignature, overrides?) => Promise<ContractTransaction>;
    registerOperator(newOperator, overrides?) => Promise<ContractTransaction>;
    registerSender(starkKey, starkSignature, overrides?) => Promise<ContractTransaction>;
    registerToken(uint256,bytes)(assetType, assetInfo, overrides?) => Promise<ContractTransaction>;
    registerToken(uint256,bytes,uint256)(assetType, assetInfo, quantum, overrides?) => Promise<ContractTransaction>;
    registerTokenAdmin(newAdmin, overrides?) => Promise<ContractTransaction>;
    registerVerifier(verifier, identifier, overrides?) => Promise<ContractTransaction>;
    removeAvailabilityVerifier(verifier, overrides?) => Promise<ContractTransaction>;
    removeVerifier(verifier, overrides?) => Promise<ContractTransaction>;
    setDefaultVaultWithdrawalLock(newDefaultTime, overrides?) => Promise<ContractTransaction>;
    unFreeze(overrides?) => Promise<ContractTransaction>;
    unregisterOperator(removedOperator, overrides?) => Promise<ContractTransaction>;
    unregisterTokenAdmin(oldAdmin, overrides?) => Promise<ContractTransaction>;
    updateImplementationActivationTime(implementation, data, finalize, overrides?) => Promise<ContractTransaction>;
    updateState(publicInput, applicationData, overrides?) => Promise<ContractTransaction>;
    withdraw(ownerKey, assetType, overrides?) => Promise<ContractTransaction>;
    withdrawAndMint(ownerKey, assetType, mintingBlob, overrides?) => Promise<ContractTransaction>;
    withdrawFromVault(assetId, vaultId, quantizedAmount, overrides?) => Promise<ContractTransaction>;
    withdrawNft(ownerKey, assetType, tokenId, overrides?) => Promise<ContractTransaction>;
}

Type declaration

  • DEPOSIT_CANCEL_DELAY:function
    • DEPOSIT_CANCEL_DELAY(overrides?): Promise<[BigNumber]>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<[BigNumber]>

  • FREEZE_GRACE_PERIOD:function
    • FREEZE_GRACE_PERIOD(overrides?): Promise<[BigNumber]>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<[BigNumber]>

  • MAIN_GOVERNANCE_INFO_TAG:function
    • MAIN_GOVERNANCE_INFO_TAG(overrides?): Promise<[string]>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<[string]>

  • MAX_FORCED_ACTIONS_REQS_PER_BLOCK:function
    • MAX_FORCED_ACTIONS_REQS_PER_BLOCK(overrides?): Promise<[BigNumber]>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<[BigNumber]>

  • MAX_VERIFIER_COUNT:function
    • MAX_VERIFIER_COUNT(overrides?): Promise<[BigNumber]>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<[BigNumber]>

  • STARKEX_MAX_DEFAULT_VAULT_LOCK:function
    • STARKEX_MAX_DEFAULT_VAULT_LOCK(overrides?): Promise<[BigNumber]>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<[BigNumber]>

  • UNFREEZE_DELAY:function
    • UNFREEZE_DELAY(overrides?): Promise<[BigNumber]>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<[BigNumber]>

  • VERIFIER_REMOVAL_DELAY:function
    • VERIFIER_REMOVAL_DELAY(overrides?): Promise<[BigNumber]>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<[BigNumber]>

  • VERSION:function
    • VERSION(overrides?): Promise<[string]>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<[string]>

  • announceAvailabilityVerifierRemovalIntent:function
    • announceAvailabilityVerifierRemovalIntent(verifier, overrides?): Promise<ContractTransaction>

    • Parameters

      • verifier: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • announceVerifierRemovalIntent:function
    • announceVerifierRemovalIntent(verifier, overrides?): Promise<ContractTransaction>

    • Parameters

      • verifier: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • defaultVaultWithdrawalLock:function
    • defaultVaultWithdrawalLock(overrides?): Promise<[BigNumber]>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<[BigNumber]>

  • deposit(uint256,uint256,uint256):function
    • deposit(uint256,uint256,uint256)(starkKey, assetType, vaultId, overrides?): Promise<ContractTransaction>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • deposit(uint256,uint256,uint256,uint256):function
    • deposit(uint256,uint256,uint256,uint256)(starkKey, assetType, vaultId, quantizedAmount, overrides?): Promise<ContractTransaction>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • quantizedAmount: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • depositCancel:function
    • depositCancel(starkKey, assetId, vaultId, overrides?): Promise<ContractTransaction>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • depositERC20:function
    • depositERC20(starkKey, assetType, vaultId, quantizedAmount, overrides?): Promise<ContractTransaction>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • quantizedAmount: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • depositERC20ToVault:function
    • depositERC20ToVault(assetId, vaultId, quantizedAmount, overrides?): Promise<ContractTransaction>

    • Parameters

      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • quantizedAmount: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • depositEth:function
    • depositEth(starkKey, assetType, vaultId, overrides?): Promise<ContractTransaction>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • depositEthToVault:function
    • depositEthToVault(assetId, vaultId, overrides?): Promise<ContractTransaction>

    • Parameters

      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • depositNft:function
    • depositNft(starkKey, assetType, vaultId, tokenId, overrides?): Promise<ContractTransaction>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • tokenId: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • depositNftReclaim:function
    • depositNftReclaim(starkKey, assetType, vaultId, tokenId, overrides?): Promise<ContractTransaction>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • tokenId: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • depositReclaim:function
    • depositReclaim(starkKey, assetId, vaultId, overrides?): Promise<ContractTransaction>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • escape:function
    • escape(starkKey, vaultId, assetId, quantizedAmount, overrides?): Promise<ContractTransaction>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • assetId: PromiseOrValue<BigNumberish>
      • quantizedAmount: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • freezeRequest:function
    • freezeRequest(starkKey, vaultId, overrides?): Promise<ContractTransaction>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • fullWithdrawalRequest:function
    • fullWithdrawalRequest(starkKey, vaultId, overrides?): Promise<ContractTransaction>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • getActionCount:function
    • getActionCount(overrides?): Promise<[BigNumber]>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<[BigNumber]>

  • getActionHashByIndex:function
    • getActionHashByIndex(actionIndex, overrides?): Promise<[string]>

    • Parameters

      • actionIndex: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<[string]>

  • getAssetInfo:function
    • getAssetInfo(assetType, overrides?): Promise<[string] & {
          assetInfo: string;
      }>

    • Parameters

      • assetType: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<[string] & {
          assetInfo: string;
      }>

  • getCancellationRequest:function
    • getCancellationRequest(starkKey, assetId, vaultId, overrides?): Promise<[BigNumber] & {
          request: BigNumber;
      }>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<[BigNumber] & {
          request: BigNumber;
      }>

  • getDepositBalance:function
    • getDepositBalance(starkKey, assetId, vaultId, overrides?): Promise<[BigNumber] & {
          balance: BigNumber;
      }>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<[BigNumber] & {
          balance: BigNumber;
      }>

  • getEthKey:function
    • getEthKey(ownerKey, overrides?): Promise<[string]>

    • Parameters

      • ownerKey: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<[string]>

  • getFullWithdrawalRequest:function
    • getFullWithdrawalRequest(starkKey, vaultId, overrides?): Promise<[BigNumber] & {
          res: BigNumber;
      }>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<[BigNumber] & {
          res: BigNumber;
      }>

  • getLastBatchId:function
    • getLastBatchId(overrides?): Promise<[BigNumber] & {
          batchId: BigNumber;
      }>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<[BigNumber] & {
          batchId: BigNumber;
      }>

  • getOrderRoot:function
    • getOrderRoot(overrides?): Promise<[BigNumber] & {
          root: BigNumber;
      }>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<[BigNumber] & {
          root: BigNumber;
      }>

  • getOrderTreeHeight:function
    • getOrderTreeHeight(overrides?): Promise<[BigNumber] & {
          height: BigNumber;
      }>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<[BigNumber] & {
          height: BigNumber;
      }>

  • getQuantizedDepositBalance:function
    • getQuantizedDepositBalance(starkKey, assetId, vaultId, overrides?): Promise<[BigNumber] & {
          balance: BigNumber;
      }>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<[BigNumber] & {
          balance: BigNumber;
      }>

  • getQuantizedVaultBalance:function
    • getQuantizedVaultBalance(ethKey, assetId, vaultId, overrides?): Promise<[BigNumber]>

    • Parameters

      • ethKey: PromiseOrValue<string>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<[BigNumber]>

  • getQuantum:function
    • getQuantum(presumedAssetType, overrides?): Promise<[BigNumber] & {
          quantum: BigNumber;
      }>

    • Parameters

      • presumedAssetType: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<[BigNumber] & {
          quantum: BigNumber;
      }>

  • getRegisteredAvailabilityVerifiers:function
    • getRegisteredAvailabilityVerifiers(overrides?): Promise<[string[]] & {
          _verifers: string[];
      }>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<[string[]] & {
          _verifers: string[];
      }>

  • getRegisteredVerifiers:function
    • getRegisteredVerifiers(overrides?): Promise<[string[]] & {
          _verifers: string[];
      }>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<[string[]] & {
          _verifers: string[];
      }>

  • getSequenceNumber:function
    • getSequenceNumber(overrides?): Promise<[BigNumber] & {
          seq: BigNumber;
      }>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<[BigNumber] & {
          seq: BigNumber;
      }>

  • getVaultBalance:function
    • getVaultBalance(ethKey, assetId, vaultId, overrides?): Promise<[BigNumber]>

    • Parameters

      • ethKey: PromiseOrValue<string>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<[BigNumber]>

  • getVaultRoot:function
    • getVaultRoot(overrides?): Promise<[BigNumber] & {
          root: BigNumber;
      }>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<[BigNumber] & {
          root: BigNumber;
      }>

  • getVaultTreeHeight:function
    • getVaultTreeHeight(overrides?): Promise<[BigNumber] & {
          height: BigNumber;
      }>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<[BigNumber] & {
          height: BigNumber;
      }>

  • getVaultWithdrawalLock:function
    • getVaultWithdrawalLock(ethKey, assetId, vaultId, overrides?): Promise<[BigNumber]>

    • Parameters

      • ethKey: PromiseOrValue<string>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<[BigNumber]>

  • getWithdrawalBalance:function
    • getWithdrawalBalance(ownerKey, assetId, overrides?): Promise<[BigNumber] & {
          balance: BigNumber;
      }>

    • Parameters

      • ownerKey: PromiseOrValue<BigNumberish>
      • assetId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<[BigNumber] & {
          balance: BigNumber;
      }>

  • initialize:function
    • initialize(data, overrides?): Promise<ContractTransaction>

    • Parameters

      • data: PromiseOrValue<BytesLike>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • isAssetRegistered:function
    • isAssetRegistered(assetType, overrides?): Promise<[boolean]>

    • Parameters

      • assetType: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<[boolean]>

  • isAvailabilityVerifier:function
    • isAvailabilityVerifier(verifierAddress, overrides?): Promise<[boolean]>

    • Parameters

      • verifierAddress: PromiseOrValue<string>
      • Optional overrides: CallOverrides

      Returns Promise<[boolean]>

  • isFrozen:function
    • isFrozen(overrides?): Promise<[boolean]>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<[boolean]>

  • isOperator:function
    • isOperator(testedOperator, overrides?): Promise<[boolean]>

    • Parameters

      • testedOperator: PromiseOrValue<string>
      • Optional overrides: CallOverrides

      Returns Promise<[boolean]>

  • isStrictVaultBalancePolicy:function
    • isStrictVaultBalancePolicy(overrides?): Promise<[boolean]>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<[boolean]>

  • isTokenAdmin:function
    • isTokenAdmin(testedAdmin, overrides?): Promise<[boolean]>

    • Parameters

      • testedAdmin: PromiseOrValue<string>
      • Optional overrides: CallOverrides

      Returns Promise<[boolean]>

  • isVaultLocked:function
    • isVaultLocked(ethKey, assetId, vaultId, overrides?): Promise<[boolean]>

    • Parameters

      • ethKey: PromiseOrValue<string>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<[boolean]>

  • isVerifier:function
    • isVerifier(verifierAddress, overrides?): Promise<[boolean]>

    • Parameters

      • verifierAddress: PromiseOrValue<string>
      • Optional overrides: CallOverrides

      Returns Promise<[boolean]>

  • lockVault:function
    • lockVault(assetId, vaultId, lockTime, overrides?): Promise<ContractTransaction>

    • Parameters

      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • lockTime: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • mainAcceptGovernance:function
    • mainAcceptGovernance(overrides?): Promise<ContractTransaction>

    • Parameters

      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • mainCancelNomination:function
    • mainCancelNomination(overrides?): Promise<ContractTransaction>

    • Parameters

      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • mainIsGovernor:function
    • mainIsGovernor(testGovernor, overrides?): Promise<[boolean]>

    • Parameters

      • testGovernor: PromiseOrValue<string>
      • Optional overrides: CallOverrides

      Returns Promise<[boolean]>

  • mainNominateNewGovernor:function
    • mainNominateNewGovernor(newGovernor, overrides?): Promise<ContractTransaction>

    • Parameters

      • newGovernor: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • mainRemoveGovernor:function
    • mainRemoveGovernor(governorForRemoval, overrides?): Promise<ContractTransaction>

    • Parameters

      • governorForRemoval: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • onERC721Received:function
    • onERC721Received(arg0, arg1, arg2, arg3, overrides?): Promise<ContractTransaction>

    • Parameters

      • arg0: PromiseOrValue<string>
      • arg1: PromiseOrValue<string>
      • arg2: PromiseOrValue<BigNumberish>
      • arg3: PromiseOrValue<BytesLike>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • orderRegistryAddress:function
    • orderRegistryAddress(overrides?): Promise<[string]>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<[string]>

  • registerAndDepositERC20:function
    • registerAndDepositERC20(ethKey, starkKey, signature, assetType, vaultId, quantizedAmount, overrides?): Promise<ContractTransaction>

    • Parameters

      • ethKey: PromiseOrValue<string>
      • starkKey: PromiseOrValue<BigNumberish>
      • signature: PromiseOrValue<BytesLike>
      • assetType: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • quantizedAmount: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • registerAndDepositEth:function
    • registerAndDepositEth(ethKey, starkKey, signature, assetType, vaultId, overrides?): Promise<ContractTransaction>

    • Parameters

      • ethKey: PromiseOrValue<string>
      • starkKey: PromiseOrValue<BigNumberish>
      • signature: PromiseOrValue<BytesLike>
      • assetType: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • registerAvailabilityVerifier:function
    • registerAvailabilityVerifier(verifier, identifier, overrides?): Promise<ContractTransaction>

    • Parameters

      • verifier: PromiseOrValue<string>
      • identifier: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • registerEthAddress:function
    • registerEthAddress(ethKey, starkKey, starkSignature, overrides?): Promise<ContractTransaction>

    • Parameters

      • ethKey: PromiseOrValue<string>
      • starkKey: PromiseOrValue<BigNumberish>
      • starkSignature: PromiseOrValue<BytesLike>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • registerOperator:function
    • registerOperator(newOperator, overrides?): Promise<ContractTransaction>

    • Parameters

      • newOperator: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • registerSender:function
    • registerSender(starkKey, starkSignature, overrides?): Promise<ContractTransaction>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • starkSignature: PromiseOrValue<BytesLike>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • registerToken(uint256,bytes):function
    • registerToken(uint256,bytes)(assetType, assetInfo, overrides?): Promise<ContractTransaction>

    • Parameters

      • assetType: PromiseOrValue<BigNumberish>
      • assetInfo: PromiseOrValue<BytesLike>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • registerToken(uint256,bytes,uint256):function
    • registerToken(uint256,bytes,uint256)(assetType, assetInfo, quantum, overrides?): Promise<ContractTransaction>

    • Parameters

      • assetType: PromiseOrValue<BigNumberish>
      • assetInfo: PromiseOrValue<BytesLike>
      • quantum: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • registerTokenAdmin:function
    • registerTokenAdmin(newAdmin, overrides?): Promise<ContractTransaction>

    • Parameters

      • newAdmin: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • registerVerifier:function
    • registerVerifier(verifier, identifier, overrides?): Promise<ContractTransaction>

    • Parameters

      • verifier: PromiseOrValue<string>
      • identifier: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • removeAvailabilityVerifier:function
    • removeAvailabilityVerifier(verifier, overrides?): Promise<ContractTransaction>

    • Parameters

      • verifier: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • removeVerifier:function
    • removeVerifier(verifier, overrides?): Promise<ContractTransaction>

    • Parameters

      • verifier: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • setDefaultVaultWithdrawalLock:function
    • setDefaultVaultWithdrawalLock(newDefaultTime, overrides?): Promise<ContractTransaction>

    • Parameters

      • newDefaultTime: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • unFreeze:function
    • unFreeze(overrides?): Promise<ContractTransaction>

    • Parameters

      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • unregisterOperator:function
    • unregisterOperator(removedOperator, overrides?): Promise<ContractTransaction>

    • Parameters

      • removedOperator: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • unregisterTokenAdmin:function
    • unregisterTokenAdmin(oldAdmin, overrides?): Promise<ContractTransaction>

    • Parameters

      • oldAdmin: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • updateImplementationActivationTime:function
    • updateImplementationActivationTime(implementation, data, finalize, overrides?): Promise<ContractTransaction>

    • Parameters

      • implementation: PromiseOrValue<string>
      • data: PromiseOrValue<BytesLike>
      • finalize: PromiseOrValue<boolean>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • updateState:function
    • updateState(publicInput, applicationData, overrides?): Promise<ContractTransaction>

    • Parameters

      • publicInput: PromiseOrValue<BigNumberish>[]
      • applicationData: PromiseOrValue<BigNumberish>[]
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • withdraw:function
    • withdraw(ownerKey, assetType, overrides?): Promise<ContractTransaction>

    • Parameters

      • ownerKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • withdrawAndMint:function
    • withdrawAndMint(ownerKey, assetType, mintingBlob, overrides?): Promise<ContractTransaction>

    • Parameters

      • ownerKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • mintingBlob: PromiseOrValue<BytesLike>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • withdrawFromVault:function
    • withdrawFromVault(assetId, vaultId, quantizedAmount, overrides?): Promise<ContractTransaction>

    • Parameters

      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • quantizedAmount: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

  • withdrawNft:function
    • withdrawNft(ownerKey, assetType, tokenId, overrides?): Promise<ContractTransaction>

    • Parameters

      • ownerKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • tokenId: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<ContractTransaction>

callStatic

callStatic: {
    DEPOSIT_CANCEL_DELAY(overrides?) => Promise<BigNumber>;
    FREEZE_GRACE_PERIOD(overrides?) => Promise<BigNumber>;
    MAIN_GOVERNANCE_INFO_TAG(overrides?) => Promise<string>;
    MAX_FORCED_ACTIONS_REQS_PER_BLOCK(overrides?) => Promise<BigNumber>;
    MAX_VERIFIER_COUNT(overrides?) => Promise<BigNumber>;
    STARKEX_MAX_DEFAULT_VAULT_LOCK(overrides?) => Promise<BigNumber>;
    UNFREEZE_DELAY(overrides?) => Promise<BigNumber>;
    VERIFIER_REMOVAL_DELAY(overrides?) => Promise<BigNumber>;
    VERSION(overrides?) => Promise<string>;
    announceAvailabilityVerifierRemovalIntent(verifier, overrides?) => Promise<void>;
    announceVerifierRemovalIntent(verifier, overrides?) => Promise<void>;
    defaultVaultWithdrawalLock(overrides?) => Promise<BigNumber>;
    deposit(uint256,uint256,uint256)(starkKey, assetType, vaultId, overrides?) => Promise<void>;
    deposit(uint256,uint256,uint256,uint256)(starkKey, assetType, vaultId, quantizedAmount, overrides?) => Promise<void>;
    depositCancel(starkKey, assetId, vaultId, overrides?) => Promise<void>;
    depositERC20(starkKey, assetType, vaultId, quantizedAmount, overrides?) => Promise<void>;
    depositERC20ToVault(assetId, vaultId, quantizedAmount, overrides?) => Promise<void>;
    depositEth(starkKey, assetType, vaultId, overrides?) => Promise<void>;
    depositEthToVault(assetId, vaultId, overrides?) => Promise<void>;
    depositNft(starkKey, assetType, vaultId, tokenId, overrides?) => Promise<void>;
    depositNftReclaim(starkKey, assetType, vaultId, tokenId, overrides?) => Promise<void>;
    depositReclaim(starkKey, assetId, vaultId, overrides?) => Promise<void>;
    escape(starkKey, vaultId, assetId, quantizedAmount, overrides?) => Promise<void>;
    freezeRequest(starkKey, vaultId, overrides?) => Promise<void>;
    fullWithdrawalRequest(starkKey, vaultId, overrides?) => Promise<void>;
    getActionCount(overrides?) => Promise<BigNumber>;
    getActionHashByIndex(actionIndex, overrides?) => Promise<string>;
    getAssetInfo(assetType, overrides?) => Promise<string>;
    getCancellationRequest(starkKey, assetId, vaultId, overrides?) => Promise<BigNumber>;
    getDepositBalance(starkKey, assetId, vaultId, overrides?) => Promise<BigNumber>;
    getEthKey(ownerKey, overrides?) => Promise<string>;
    getFullWithdrawalRequest(starkKey, vaultId, overrides?) => Promise<BigNumber>;
    getLastBatchId(overrides?) => Promise<BigNumber>;
    getOrderRoot(overrides?) => Promise<BigNumber>;
    getOrderTreeHeight(overrides?) => Promise<BigNumber>;
    getQuantizedDepositBalance(starkKey, assetId, vaultId, overrides?) => Promise<BigNumber>;
    getQuantizedVaultBalance(ethKey, assetId, vaultId, overrides?) => Promise<BigNumber>;
    getQuantum(presumedAssetType, overrides?) => Promise<BigNumber>;
    getRegisteredAvailabilityVerifiers(overrides?) => Promise<string[]>;
    getRegisteredVerifiers(overrides?) => Promise<string[]>;
    getSequenceNumber(overrides?) => Promise<BigNumber>;
    getVaultBalance(ethKey, assetId, vaultId, overrides?) => Promise<BigNumber>;
    getVaultRoot(overrides?) => Promise<BigNumber>;
    getVaultTreeHeight(overrides?) => Promise<BigNumber>;
    getVaultWithdrawalLock(ethKey, assetId, vaultId, overrides?) => Promise<BigNumber>;
    getWithdrawalBalance(ownerKey, assetId, overrides?) => Promise<BigNumber>;
    initialize(data, overrides?) => Promise<void>;
    isAssetRegistered(assetType, overrides?) => Promise<boolean>;
    isAvailabilityVerifier(verifierAddress, overrides?) => Promise<boolean>;
    isFrozen(overrides?) => Promise<boolean>;
    isOperator(testedOperator, overrides?) => Promise<boolean>;
    isStrictVaultBalancePolicy(overrides?) => Promise<boolean>;
    isTokenAdmin(testedAdmin, overrides?) => Promise<boolean>;
    isVaultLocked(ethKey, assetId, vaultId, overrides?) => Promise<boolean>;
    isVerifier(verifierAddress, overrides?) => Promise<boolean>;
    lockVault(assetId, vaultId, lockTime, overrides?) => Promise<void>;
    mainAcceptGovernance(overrides?) => Promise<void>;
    mainCancelNomination(overrides?) => Promise<void>;
    mainIsGovernor(testGovernor, overrides?) => Promise<boolean>;
    mainNominateNewGovernor(newGovernor, overrides?) => Promise<void>;
    mainRemoveGovernor(governorForRemoval, overrides?) => Promise<void>;
    onERC721Received(arg0, arg1, arg2, arg3, overrides?) => Promise<string>;
    orderRegistryAddress(overrides?) => Promise<string>;
    registerAndDepositERC20(ethKey, starkKey, signature, assetType, vaultId, quantizedAmount, overrides?) => Promise<void>;
    registerAndDepositEth(ethKey, starkKey, signature, assetType, vaultId, overrides?) => Promise<void>;
    registerAvailabilityVerifier(verifier, identifier, overrides?) => Promise<void>;
    registerEthAddress(ethKey, starkKey, starkSignature, overrides?) => Promise<void>;
    registerOperator(newOperator, overrides?) => Promise<void>;
    registerSender(starkKey, starkSignature, overrides?) => Promise<void>;
    registerToken(uint256,bytes)(assetType, assetInfo, overrides?) => Promise<void>;
    registerToken(uint256,bytes,uint256)(assetType, assetInfo, quantum, overrides?) => Promise<void>;
    registerTokenAdmin(newAdmin, overrides?) => Promise<void>;
    registerVerifier(verifier, identifier, overrides?) => Promise<void>;
    removeAvailabilityVerifier(verifier, overrides?) => Promise<void>;
    removeVerifier(verifier, overrides?) => Promise<void>;
    setDefaultVaultWithdrawalLock(newDefaultTime, overrides?) => Promise<void>;
    unFreeze(overrides?) => Promise<void>;
    unregisterOperator(removedOperator, overrides?) => Promise<void>;
    unregisterTokenAdmin(oldAdmin, overrides?) => Promise<void>;
    updateImplementationActivationTime(implementation, data, finalize, overrides?) => Promise<void>;
    updateState(publicInput, applicationData, overrides?) => Promise<void>;
    withdraw(ownerKey, assetType, overrides?) => Promise<void>;
    withdrawAndMint(ownerKey, assetType, mintingBlob, overrides?) => Promise<void>;
    withdrawFromVault(assetId, vaultId, quantizedAmount, overrides?) => Promise<void>;
    withdrawNft(ownerKey, assetType, tokenId, overrides?) => Promise<void>;
}

Type declaration

  • DEPOSIT_CANCEL_DELAY:function
    • DEPOSIT_CANCEL_DELAY(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • FREEZE_GRACE_PERIOD:function
    • FREEZE_GRACE_PERIOD(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • MAIN_GOVERNANCE_INFO_TAG:function
    • MAIN_GOVERNANCE_INFO_TAG(overrides?): Promise<string>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<string>

  • MAX_FORCED_ACTIONS_REQS_PER_BLOCK:function
    • MAX_FORCED_ACTIONS_REQS_PER_BLOCK(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • MAX_VERIFIER_COUNT:function
    • MAX_VERIFIER_COUNT(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • STARKEX_MAX_DEFAULT_VAULT_LOCK:function
    • STARKEX_MAX_DEFAULT_VAULT_LOCK(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • UNFREEZE_DELAY:function
    • UNFREEZE_DELAY(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • VERIFIER_REMOVAL_DELAY:function
    • VERIFIER_REMOVAL_DELAY(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • VERSION:function
    • VERSION(overrides?): Promise<string>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<string>

  • announceAvailabilityVerifierRemovalIntent:function
    • announceAvailabilityVerifierRemovalIntent(verifier, overrides?): Promise<void>

    • Parameters

      • verifier: PromiseOrValue<string>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • announceVerifierRemovalIntent:function
    • announceVerifierRemovalIntent(verifier, overrides?): Promise<void>

    • Parameters

      • verifier: PromiseOrValue<string>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • defaultVaultWithdrawalLock:function
    • defaultVaultWithdrawalLock(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • deposit(uint256,uint256,uint256):function
    • deposit(uint256,uint256,uint256)(starkKey, assetType, vaultId, overrides?): Promise<void>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • deposit(uint256,uint256,uint256,uint256):function
    • deposit(uint256,uint256,uint256,uint256)(starkKey, assetType, vaultId, quantizedAmount, overrides?): Promise<void>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • quantizedAmount: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • depositCancel:function
    • depositCancel(starkKey, assetId, vaultId, overrides?): Promise<void>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • depositERC20:function
    • depositERC20(starkKey, assetType, vaultId, quantizedAmount, overrides?): Promise<void>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • quantizedAmount: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • depositERC20ToVault:function
    • depositERC20ToVault(assetId, vaultId, quantizedAmount, overrides?): Promise<void>

    • Parameters

      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • quantizedAmount: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • depositEth:function
    • depositEth(starkKey, assetType, vaultId, overrides?): Promise<void>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • depositEthToVault:function
    • depositEthToVault(assetId, vaultId, overrides?): Promise<void>

    • Parameters

      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • depositNft:function
    • depositNft(starkKey, assetType, vaultId, tokenId, overrides?): Promise<void>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • tokenId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • depositNftReclaim:function
    • depositNftReclaim(starkKey, assetType, vaultId, tokenId, overrides?): Promise<void>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • tokenId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • depositReclaim:function
    • depositReclaim(starkKey, assetId, vaultId, overrides?): Promise<void>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • escape:function
    • escape(starkKey, vaultId, assetId, quantizedAmount, overrides?): Promise<void>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • assetId: PromiseOrValue<BigNumberish>
      • quantizedAmount: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • freezeRequest:function
    • freezeRequest(starkKey, vaultId, overrides?): Promise<void>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • fullWithdrawalRequest:function
    • fullWithdrawalRequest(starkKey, vaultId, overrides?): Promise<void>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • getActionCount:function
    • getActionCount(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getActionHashByIndex:function
    • getActionHashByIndex(actionIndex, overrides?): Promise<string>

    • Parameters

      • actionIndex: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<string>

  • getAssetInfo:function
    • getAssetInfo(assetType, overrides?): Promise<string>

    • Parameters

      • assetType: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<string>

  • getCancellationRequest:function
    • getCancellationRequest(starkKey, assetId, vaultId, overrides?): Promise<BigNumber>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getDepositBalance:function
    • getDepositBalance(starkKey, assetId, vaultId, overrides?): Promise<BigNumber>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getEthKey:function
    • getEthKey(ownerKey, overrides?): Promise<string>

    • Parameters

      • ownerKey: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<string>

  • getFullWithdrawalRequest:function
    • getFullWithdrawalRequest(starkKey, vaultId, overrides?): Promise<BigNumber>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getLastBatchId:function
    • getLastBatchId(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getOrderRoot:function
    • getOrderRoot(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getOrderTreeHeight:function
    • getOrderTreeHeight(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getQuantizedDepositBalance:function
    • getQuantizedDepositBalance(starkKey, assetId, vaultId, overrides?): Promise<BigNumber>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getQuantizedVaultBalance:function
    • getQuantizedVaultBalance(ethKey, assetId, vaultId, overrides?): Promise<BigNumber>

    • Parameters

      • ethKey: PromiseOrValue<string>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getQuantum:function
    • getQuantum(presumedAssetType, overrides?): Promise<BigNumber>

    • Parameters

      • presumedAssetType: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getRegisteredAvailabilityVerifiers:function
    • getRegisteredAvailabilityVerifiers(overrides?): Promise<string[]>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<string[]>

  • getRegisteredVerifiers:function
    • getRegisteredVerifiers(overrides?): Promise<string[]>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<string[]>

  • getSequenceNumber:function
    • getSequenceNumber(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getVaultBalance:function
    • getVaultBalance(ethKey, assetId, vaultId, overrides?): Promise<BigNumber>

    • Parameters

      • ethKey: PromiseOrValue<string>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getVaultRoot:function
    • getVaultRoot(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getVaultTreeHeight:function
    • getVaultTreeHeight(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getVaultWithdrawalLock:function
    • getVaultWithdrawalLock(ethKey, assetId, vaultId, overrides?): Promise<BigNumber>

    • Parameters

      • ethKey: PromiseOrValue<string>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getWithdrawalBalance:function
    • getWithdrawalBalance(ownerKey, assetId, overrides?): Promise<BigNumber>

    • Parameters

      • ownerKey: PromiseOrValue<BigNumberish>
      • assetId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • initialize:function
    • initialize(data, overrides?): Promise<void>

    • Parameters

      • data: PromiseOrValue<BytesLike>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • isAssetRegistered:function
    • isAssetRegistered(assetType, overrides?): Promise<boolean>

    • Parameters

      • assetType: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<boolean>

  • isAvailabilityVerifier:function
    • isAvailabilityVerifier(verifierAddress, overrides?): Promise<boolean>

    • Parameters

      • verifierAddress: PromiseOrValue<string>
      • Optional overrides: CallOverrides

      Returns Promise<boolean>

  • isFrozen:function
    • isFrozen(overrides?): Promise<boolean>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<boolean>

  • isOperator:function
    • isOperator(testedOperator, overrides?): Promise<boolean>

    • Parameters

      • testedOperator: PromiseOrValue<string>
      • Optional overrides: CallOverrides

      Returns Promise<boolean>

  • isStrictVaultBalancePolicy:function
    • isStrictVaultBalancePolicy(overrides?): Promise<boolean>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<boolean>

  • isTokenAdmin:function
    • isTokenAdmin(testedAdmin, overrides?): Promise<boolean>

    • Parameters

      • testedAdmin: PromiseOrValue<string>
      • Optional overrides: CallOverrides

      Returns Promise<boolean>

  • isVaultLocked:function
    • isVaultLocked(ethKey, assetId, vaultId, overrides?): Promise<boolean>

    • Parameters

      • ethKey: PromiseOrValue<string>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<boolean>

  • isVerifier:function
    • isVerifier(verifierAddress, overrides?): Promise<boolean>

    • Parameters

      • verifierAddress: PromiseOrValue<string>
      • Optional overrides: CallOverrides

      Returns Promise<boolean>

  • lockVault:function
    • lockVault(assetId, vaultId, lockTime, overrides?): Promise<void>

    • Parameters

      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • lockTime: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • mainAcceptGovernance:function
    • mainAcceptGovernance(overrides?): Promise<void>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<void>

  • mainCancelNomination:function
    • mainCancelNomination(overrides?): Promise<void>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<void>

  • mainIsGovernor:function
    • mainIsGovernor(testGovernor, overrides?): Promise<boolean>

    • Parameters

      • testGovernor: PromiseOrValue<string>
      • Optional overrides: CallOverrides

      Returns Promise<boolean>

  • mainNominateNewGovernor:function
    • mainNominateNewGovernor(newGovernor, overrides?): Promise<void>

    • Parameters

      • newGovernor: PromiseOrValue<string>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • mainRemoveGovernor:function
    • mainRemoveGovernor(governorForRemoval, overrides?): Promise<void>

    • Parameters

      • governorForRemoval: PromiseOrValue<string>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • onERC721Received:function
    • onERC721Received(arg0, arg1, arg2, arg3, overrides?): Promise<string>

    • Parameters

      • arg0: PromiseOrValue<string>
      • arg1: PromiseOrValue<string>
      • arg2: PromiseOrValue<BigNumberish>
      • arg3: PromiseOrValue<BytesLike>
      • Optional overrides: CallOverrides

      Returns Promise<string>

  • orderRegistryAddress:function
    • orderRegistryAddress(overrides?): Promise<string>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<string>

  • registerAndDepositERC20:function
    • registerAndDepositERC20(ethKey, starkKey, signature, assetType, vaultId, quantizedAmount, overrides?): Promise<void>

    • Parameters

      • ethKey: PromiseOrValue<string>
      • starkKey: PromiseOrValue<BigNumberish>
      • signature: PromiseOrValue<BytesLike>
      • assetType: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • quantizedAmount: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • registerAndDepositEth:function
    • registerAndDepositEth(ethKey, starkKey, signature, assetType, vaultId, overrides?): Promise<void>

    • Parameters

      • ethKey: PromiseOrValue<string>
      • starkKey: PromiseOrValue<BigNumberish>
      • signature: PromiseOrValue<BytesLike>
      • assetType: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • registerAvailabilityVerifier:function
    • registerAvailabilityVerifier(verifier, identifier, overrides?): Promise<void>

    • Parameters

      • verifier: PromiseOrValue<string>
      • identifier: PromiseOrValue<string>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • registerEthAddress:function
    • registerEthAddress(ethKey, starkKey, starkSignature, overrides?): Promise<void>

    • Parameters

      • ethKey: PromiseOrValue<string>
      • starkKey: PromiseOrValue<BigNumberish>
      • starkSignature: PromiseOrValue<BytesLike>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • registerOperator:function
    • registerOperator(newOperator, overrides?): Promise<void>

    • Parameters

      • newOperator: PromiseOrValue<string>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • registerSender:function
    • registerSender(starkKey, starkSignature, overrides?): Promise<void>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • starkSignature: PromiseOrValue<BytesLike>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • registerToken(uint256,bytes):function
    • registerToken(uint256,bytes)(assetType, assetInfo, overrides?): Promise<void>

    • Parameters

      • assetType: PromiseOrValue<BigNumberish>
      • assetInfo: PromiseOrValue<BytesLike>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • registerToken(uint256,bytes,uint256):function
    • registerToken(uint256,bytes,uint256)(assetType, assetInfo, quantum, overrides?): Promise<void>

    • Parameters

      • assetType: PromiseOrValue<BigNumberish>
      • assetInfo: PromiseOrValue<BytesLike>
      • quantum: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • registerTokenAdmin:function
    • registerTokenAdmin(newAdmin, overrides?): Promise<void>

    • Parameters

      • newAdmin: PromiseOrValue<string>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • registerVerifier:function
    • registerVerifier(verifier, identifier, overrides?): Promise<void>

    • Parameters

      • verifier: PromiseOrValue<string>
      • identifier: PromiseOrValue<string>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • removeAvailabilityVerifier:function
    • removeAvailabilityVerifier(verifier, overrides?): Promise<void>

    • Parameters

      • verifier: PromiseOrValue<string>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • removeVerifier:function
    • removeVerifier(verifier, overrides?): Promise<void>

    • Parameters

      • verifier: PromiseOrValue<string>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • setDefaultVaultWithdrawalLock:function
    • setDefaultVaultWithdrawalLock(newDefaultTime, overrides?): Promise<void>

    • Parameters

      • newDefaultTime: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • unFreeze:function
    • unFreeze(overrides?): Promise<void>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<void>

  • unregisterOperator:function
    • unregisterOperator(removedOperator, overrides?): Promise<void>

    • Parameters

      • removedOperator: PromiseOrValue<string>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • unregisterTokenAdmin:function
    • unregisterTokenAdmin(oldAdmin, overrides?): Promise<void>

    • Parameters

      • oldAdmin: PromiseOrValue<string>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • updateImplementationActivationTime:function
    • updateImplementationActivationTime(implementation, data, finalize, overrides?): Promise<void>

    • Parameters

      • implementation: PromiseOrValue<string>
      • data: PromiseOrValue<BytesLike>
      • finalize: PromiseOrValue<boolean>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • updateState:function
    • updateState(publicInput, applicationData, overrides?): Promise<void>

    • Parameters

      • publicInput: PromiseOrValue<BigNumberish>[]
      • applicationData: PromiseOrValue<BigNumberish>[]
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • withdraw:function
    • withdraw(ownerKey, assetType, overrides?): Promise<void>

    • Parameters

      • ownerKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • withdrawAndMint:function
    • withdrawAndMint(ownerKey, assetType, mintingBlob, overrides?): Promise<void>

    • Parameters

      • ownerKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • mintingBlob: PromiseOrValue<BytesLike>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • withdrawFromVault:function
    • withdrawFromVault(assetId, vaultId, quantizedAmount, overrides?): Promise<void>

    • Parameters

      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • quantizedAmount: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • withdrawNft:function
    • withdrawNft(ownerKey, assetType, tokenId, overrides?): Promise<void>

    • Parameters

      • ownerKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • tokenId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<void>

filters

filters: {
    ImplementationActivationRescheduled(address,uint256)(implementation?, updatedActivationTime?) => ImplementationActivationRescheduledEventFilter;
    ImplementationActivationRescheduled(implementation?, updatedActivationTime?) => ImplementationActivationRescheduledEventFilter;
    LogDefaultVaultWithdrawalLockSet(uint256)(newDefaultLockTime?) => LogDefaultVaultWithdrawalLockSetEventFilter;
    LogDefaultVaultWithdrawalLockSet(newDefaultLockTime?) => LogDefaultVaultWithdrawalLockSetEventFilter;
    LogDeposit(address,uint256,uint256,uint256,uint256,uint256)(depositorEthKey?, starkKey?, vaultId?, assetType?, nonQuantizedAmount?, quantizedAmount?) => LogDepositEventFilter;
    LogDeposit(depositorEthKey?, starkKey?, vaultId?, assetType?, nonQuantizedAmount?, quantizedAmount?) => LogDepositEventFilter;
    LogDepositCancel(uint256,uint256,uint256)(starkKey?, vaultId?, assetId?) => LogDepositCancelEventFilter;
    LogDepositCancel(starkKey?, vaultId?, assetId?) => LogDepositCancelEventFilter;
    LogDepositCancelReclaimed(uint256,uint256,uint256,uint256,uint256)(starkKey?, vaultId?, assetType?, nonQuantizedAmount?, quantizedAmount?) => LogDepositCancelReclaimedEventFilter;
    LogDepositCancelReclaimed(starkKey?, vaultId?, assetType?, nonQuantizedAmount?, quantizedAmount?) => LogDepositCancelReclaimedEventFilter;
    LogDepositNftCancelReclaimed(uint256,uint256,uint256,uint256,uint256)(starkKey?, vaultId?, assetType?, tokenId?, assetId?) => LogDepositNftCancelReclaimedEventFilter;
    LogDepositNftCancelReclaimed(starkKey?, vaultId?, assetType?, tokenId?, assetId?) => LogDepositNftCancelReclaimedEventFilter;
    LogDepositToVault(address,uint256,uint256,uint256,uint256)(ethKey?, assetId?, vaultId?, nonQuantizedAmount?, quantizedAmount?) => LogDepositToVaultEventFilter;
    LogDepositToVault(ethKey?, assetId?, vaultId?, nonQuantizedAmount?, quantizedAmount?) => LogDepositToVaultEventFilter;
    LogFrozen()() => LogFrozenEventFilter;
    LogFrozen() => LogFrozenEventFilter;
    LogFullWithdrawalRequest(uint256,uint256)(starkKey?, vaultId?) => LogFullWithdrawalRequestEventFilter;
    LogFullWithdrawalRequest(starkKey?, vaultId?) => LogFullWithdrawalRequestEventFilter;
    LogMintWithdrawalPerformed(uint256,uint256,uint256,uint256,uint256)(ownerKey?, assetType?, nonQuantizedAmount?, quantizedAmount?, assetId?) => LogMintWithdrawalPerformedEventFilter;
    LogMintWithdrawalPerformed(ownerKey?, assetType?, nonQuantizedAmount?, quantizedAmount?, assetId?) => LogMintWithdrawalPerformedEventFilter;
    LogMintableWithdrawalAllowed(uint256,uint256,uint256)(ownerKey?, assetId?, quantizedAmount?) => LogMintableWithdrawalAllowedEventFilter;
    LogMintableWithdrawalAllowed(ownerKey?, assetId?, quantizedAmount?) => LogMintableWithdrawalAllowedEventFilter;
    LogNewGovernorAccepted(address)(acceptedGovernor?) => LogNewGovernorAcceptedEventFilter;
    LogNewGovernorAccepted(acceptedGovernor?) => LogNewGovernorAcceptedEventFilter;
    LogNftDeposit(address,uint256,uint256,uint256,uint256,uint256)(depositorEthKey?, starkKey?, vaultId?, assetType?, tokenId?, assetId?) => LogNftDepositEventFilter;
    LogNftDeposit(depositorEthKey?, starkKey?, vaultId?, assetType?, tokenId?, assetId?) => LogNftDepositEventFilter;
    LogNftWithdrawalAllowed(uint256,uint256)(ownerKey?, assetId?) => LogNftWithdrawalAllowedEventFilter;
    LogNftWithdrawalAllowed(ownerKey?, assetId?) => LogNftWithdrawalAllowedEventFilter;
    LogNftWithdrawalPerformed(uint256,uint256,uint256,uint256,address)(ownerKey?, assetType?, tokenId?, assetId?, recipient?) => LogNftWithdrawalPerformedEventFilter;
    LogNftWithdrawalPerformed(ownerKey?, assetType?, tokenId?, assetId?, recipient?) => LogNftWithdrawalPerformedEventFilter;
    LogNominatedGovernor(address)(nominatedGovernor?) => LogNominatedGovernorEventFilter;
    LogNominatedGovernor(nominatedGovernor?) => LogNominatedGovernorEventFilter;
    LogNominationCancelled()() => LogNominationCancelledEventFilter;
    LogNominationCancelled() => LogNominationCancelledEventFilter;
    LogOperatorAdded(address)(operator?) => LogOperatorAddedEventFilter;
    LogOperatorAdded(operator?) => LogOperatorAddedEventFilter;
    LogOperatorRemoved(address)(operator?) => LogOperatorRemovedEventFilter;
    LogOperatorRemoved(operator?) => LogOperatorRemovedEventFilter;
    LogRegistered(address,string)(entry?, entryId?) => LogRegisteredEventFilter;
    LogRegistered(entry?, entryId?) => LogRegisteredEventFilter;
    LogRemovalIntent(address,string)(entry?, entryId?) => LogRemovalIntentEventFilter;
    LogRemovalIntent(entry?, entryId?) => LogRemovalIntentEventFilter;
    LogRemoved(address,string)(entry?, entryId?) => LogRemovedEventFilter;
    LogRemoved(entry?, entryId?) => LogRemovedEventFilter;
    LogRemovedGovernor(address)(removedGovernor?) => LogRemovedGovernorEventFilter;
    LogRemovedGovernor(removedGovernor?) => LogRemovedGovernorEventFilter;
    LogRootUpdate(uint256,uint256,uint256,uint256)(sequenceNumber?, batchId?, vaultRoot?, orderRoot?) => LogRootUpdateEventFilter;
    LogRootUpdate(sequenceNumber?, batchId?, vaultRoot?, orderRoot?) => LogRootUpdateEventFilter;
    LogStateTransitionFact(bytes32)(stateTransitionFact?) => LogStateTransitionFactEventFilter;
    LogStateTransitionFact(stateTransitionFact?) => LogStateTransitionFactEventFilter;
    LogTokenAdminAdded(address)(tokenAdmin?) => LogTokenAdminAddedEventFilter;
    LogTokenAdminAdded(tokenAdmin?) => LogTokenAdminAddedEventFilter;
    LogTokenAdminRemoved(address)(tokenAdmin?) => LogTokenAdminRemovedEventFilter;
    LogTokenAdminRemoved(tokenAdmin?) => LogTokenAdminRemovedEventFilter;
    LogTokenRegistered(uint256,bytes,uint256)(assetType?, assetInfo?, quantum?) => LogTokenRegisteredEventFilter;
    LogTokenRegistered(assetType?, assetInfo?, quantum?) => LogTokenRegisteredEventFilter;
    LogUnFrozen()() => LogUnFrozenEventFilter;
    LogUnFrozen() => LogUnFrozenEventFilter;
    LogUserRegistered(address,uint256,address)(ethKey?, starkKey?, sender?) => LogUserRegisteredEventFilter;
    LogUserRegistered(ethKey?, starkKey?, sender?) => LogUserRegisteredEventFilter;
    LogVaultBalanceChangeApplied(address,uint256,uint256,int256)(ethKey?, assetId?, vaultId?, quantizedAmountChange?) => LogVaultBalanceChangeAppliedEventFilter;
    LogVaultBalanceChangeApplied(ethKey?, assetId?, vaultId?, quantizedAmountChange?) => LogVaultBalanceChangeAppliedEventFilter;
    LogVaultWithdrawalLockSet(address,uint256,uint256,uint256)(ethKey?, assetId?, vaultId?, timeRelease?) => LogVaultWithdrawalLockSetEventFilter;
    LogVaultWithdrawalLockSet(ethKey?, assetId?, vaultId?, timeRelease?) => LogVaultWithdrawalLockSetEventFilter;
    LogWithdrawalAllowed(uint256,uint256,uint256,uint256)(ownerKey?, assetType?, nonQuantizedAmount?, quantizedAmount?) => LogWithdrawalAllowedEventFilter;
    LogWithdrawalAllowed(ownerKey?, assetType?, nonQuantizedAmount?, quantizedAmount?) => LogWithdrawalAllowedEventFilter;
    LogWithdrawalFromVault(address,uint256,uint256,uint256,uint256)(ethKey?, assetId?, vaultId?, nonQuantizedAmount?, quantizedAmount?) => LogWithdrawalFromVaultEventFilter;
    LogWithdrawalFromVault(ethKey?, assetId?, vaultId?, nonQuantizedAmount?, quantizedAmount?) => LogWithdrawalFromVaultEventFilter;
    LogWithdrawalPerformed(uint256,uint256,uint256,uint256,address)(ownerKey?, assetType?, nonQuantizedAmount?, quantizedAmount?, recipient?) => LogWithdrawalPerformedEventFilter;
    LogWithdrawalPerformed(ownerKey?, assetType?, nonQuantizedAmount?, quantizedAmount?, recipient?) => LogWithdrawalPerformedEventFilter;
}

Type declaration

  • ImplementationActivationRescheduled(address,uint256):function
    • ImplementationActivationRescheduled(address,uint256)(implementation?, updatedActivationTime?): ImplementationActivationRescheduledEventFilter

    • Parameters

      • Optional implementation: null | PromiseOrValue<string>
      • Optional updatedActivationTime: null

      Returns ImplementationActivationRescheduledEventFilter

  • ImplementationActivationRescheduled:function
    • ImplementationActivationRescheduled(implementation?, updatedActivationTime?): ImplementationActivationRescheduledEventFilter

    • Parameters

      • Optional implementation: null | PromiseOrValue<string>
      • Optional updatedActivationTime: null

      Returns ImplementationActivationRescheduledEventFilter

  • LogDefaultVaultWithdrawalLockSet(uint256):function
    • LogDefaultVaultWithdrawalLockSet(uint256)(newDefaultLockTime?): LogDefaultVaultWithdrawalLockSetEventFilter

    • Parameters

      • Optional newDefaultLockTime: null

      Returns LogDefaultVaultWithdrawalLockSetEventFilter

  • LogDefaultVaultWithdrawalLockSet:function
    • LogDefaultVaultWithdrawalLockSet(newDefaultLockTime?): LogDefaultVaultWithdrawalLockSetEventFilter

    • Parameters

      • Optional newDefaultLockTime: null

      Returns LogDefaultVaultWithdrawalLockSetEventFilter

  • LogDeposit(address,uint256,uint256,uint256,uint256,uint256):function
    • LogDeposit(address,uint256,uint256,uint256,uint256,uint256)(depositorEthKey?, starkKey?, vaultId?, assetType?, nonQuantizedAmount?, quantizedAmount?): LogDepositEventFilter

    • Parameters

      • Optional depositorEthKey: null
      • Optional starkKey: null
      • Optional vaultId: null
      • Optional assetType: null
      • Optional nonQuantizedAmount: null
      • Optional quantizedAmount: null

      Returns LogDepositEventFilter

  • LogDeposit:function
    • LogDeposit(depositorEthKey?, starkKey?, vaultId?, assetType?, nonQuantizedAmount?, quantizedAmount?): LogDepositEventFilter

    • Parameters

      • Optional depositorEthKey: null
      • Optional starkKey: null
      • Optional vaultId: null
      • Optional assetType: null
      • Optional nonQuantizedAmount: null
      • Optional quantizedAmount: null

      Returns LogDepositEventFilter

  • LogDepositCancel(uint256,uint256,uint256):function
    • LogDepositCancel(uint256,uint256,uint256)(starkKey?, vaultId?, assetId?): LogDepositCancelEventFilter

    • Parameters

      • Optional starkKey: null
      • Optional vaultId: null
      • Optional assetId: null

      Returns LogDepositCancelEventFilter

  • LogDepositCancel:function
    • LogDepositCancel(starkKey?, vaultId?, assetId?): LogDepositCancelEventFilter

    • Parameters

      • Optional starkKey: null
      • Optional vaultId: null
      • Optional assetId: null

      Returns LogDepositCancelEventFilter

  • LogDepositCancelReclaimed(uint256,uint256,uint256,uint256,uint256):function
    • LogDepositCancelReclaimed(uint256,uint256,uint256,uint256,uint256)(starkKey?, vaultId?, assetType?, nonQuantizedAmount?, quantizedAmount?): LogDepositCancelReclaimedEventFilter

    • Parameters

      • Optional starkKey: null
      • Optional vaultId: null
      • Optional assetType: null
      • Optional nonQuantizedAmount: null
      • Optional quantizedAmount: null

      Returns LogDepositCancelReclaimedEventFilter

  • LogDepositCancelReclaimed:function
    • LogDepositCancelReclaimed(starkKey?, vaultId?, assetType?, nonQuantizedAmount?, quantizedAmount?): LogDepositCancelReclaimedEventFilter

    • Parameters

      • Optional starkKey: null
      • Optional vaultId: null
      • Optional assetType: null
      • Optional nonQuantizedAmount: null
      • Optional quantizedAmount: null

      Returns LogDepositCancelReclaimedEventFilter

  • LogDepositNftCancelReclaimed(uint256,uint256,uint256,uint256,uint256):function
    • LogDepositNftCancelReclaimed(uint256,uint256,uint256,uint256,uint256)(starkKey?, vaultId?, assetType?, tokenId?, assetId?): LogDepositNftCancelReclaimedEventFilter

    • Parameters

      • Optional starkKey: null
      • Optional vaultId: null
      • Optional assetType: null
      • Optional tokenId: null
      • Optional assetId: null

      Returns LogDepositNftCancelReclaimedEventFilter

  • LogDepositNftCancelReclaimed:function
    • LogDepositNftCancelReclaimed(starkKey?, vaultId?, assetType?, tokenId?, assetId?): LogDepositNftCancelReclaimedEventFilter

    • Parameters

      • Optional starkKey: null
      • Optional vaultId: null
      • Optional assetType: null
      • Optional tokenId: null
      • Optional assetId: null

      Returns LogDepositNftCancelReclaimedEventFilter

  • LogDepositToVault(address,uint256,uint256,uint256,uint256):function
    • LogDepositToVault(address,uint256,uint256,uint256,uint256)(ethKey?, assetId?, vaultId?, nonQuantizedAmount?, quantizedAmount?): LogDepositToVaultEventFilter

    • Parameters

      • Optional ethKey: null
      • Optional assetId: null
      • Optional vaultId: null
      • Optional nonQuantizedAmount: null
      • Optional quantizedAmount: null

      Returns LogDepositToVaultEventFilter

  • LogDepositToVault:function
    • LogDepositToVault(ethKey?, assetId?, vaultId?, nonQuantizedAmount?, quantizedAmount?): LogDepositToVaultEventFilter

    • Parameters

      • Optional ethKey: null
      • Optional assetId: null
      • Optional vaultId: null
      • Optional nonQuantizedAmount: null
      • Optional quantizedAmount: null

      Returns LogDepositToVaultEventFilter

  • LogFrozen():function
    • LogFrozen()(): LogFrozenEventFilter

    • Returns LogFrozenEventFilter

  • LogFrozen:function
    • LogFrozen(): LogFrozenEventFilter

    • Returns LogFrozenEventFilter

  • LogFullWithdrawalRequest(uint256,uint256):function
    • LogFullWithdrawalRequest(uint256,uint256)(starkKey?, vaultId?): LogFullWithdrawalRequestEventFilter

    • Parameters

      • Optional starkKey: null
      • Optional vaultId: null

      Returns LogFullWithdrawalRequestEventFilter

  • LogFullWithdrawalRequest:function
    • LogFullWithdrawalRequest(starkKey?, vaultId?): LogFullWithdrawalRequestEventFilter

    • Parameters

      • Optional starkKey: null
      • Optional vaultId: null

      Returns LogFullWithdrawalRequestEventFilter

  • LogMintWithdrawalPerformed(uint256,uint256,uint256,uint256,uint256):function
    • LogMintWithdrawalPerformed(uint256,uint256,uint256,uint256,uint256)(ownerKey?, assetType?, nonQuantizedAmount?, quantizedAmount?, assetId?): LogMintWithdrawalPerformedEventFilter

    • Parameters

      • Optional ownerKey: null
      • Optional assetType: null
      • Optional nonQuantizedAmount: null
      • Optional quantizedAmount: null
      • Optional assetId: null

      Returns LogMintWithdrawalPerformedEventFilter

  • LogMintWithdrawalPerformed:function
    • LogMintWithdrawalPerformed(ownerKey?, assetType?, nonQuantizedAmount?, quantizedAmount?, assetId?): LogMintWithdrawalPerformedEventFilter

    • Parameters

      • Optional ownerKey: null
      • Optional assetType: null
      • Optional nonQuantizedAmount: null
      • Optional quantizedAmount: null
      • Optional assetId: null

      Returns LogMintWithdrawalPerformedEventFilter

  • LogMintableWithdrawalAllowed(uint256,uint256,uint256):function
    • LogMintableWithdrawalAllowed(uint256,uint256,uint256)(ownerKey?, assetId?, quantizedAmount?): LogMintableWithdrawalAllowedEventFilter

    • Parameters

      • Optional ownerKey: null
      • Optional assetId: null
      • Optional quantizedAmount: null

      Returns LogMintableWithdrawalAllowedEventFilter

  • LogMintableWithdrawalAllowed:function
    • LogMintableWithdrawalAllowed(ownerKey?, assetId?, quantizedAmount?): LogMintableWithdrawalAllowedEventFilter

    • Parameters

      • Optional ownerKey: null
      • Optional assetId: null
      • Optional quantizedAmount: null

      Returns LogMintableWithdrawalAllowedEventFilter

  • LogNewGovernorAccepted(address):function
    • LogNewGovernorAccepted(address)(acceptedGovernor?): LogNewGovernorAcceptedEventFilter

    • Parameters

      • Optional acceptedGovernor: null

      Returns LogNewGovernorAcceptedEventFilter

  • LogNewGovernorAccepted:function
    • LogNewGovernorAccepted(acceptedGovernor?): LogNewGovernorAcceptedEventFilter

    • Parameters

      • Optional acceptedGovernor: null

      Returns LogNewGovernorAcceptedEventFilter

  • LogNftDeposit(address,uint256,uint256,uint256,uint256,uint256):function
    • LogNftDeposit(address,uint256,uint256,uint256,uint256,uint256)(depositorEthKey?, starkKey?, vaultId?, assetType?, tokenId?, assetId?): LogNftDepositEventFilter

    • Parameters

      • Optional depositorEthKey: null
      • Optional starkKey: null
      • Optional vaultId: null
      • Optional assetType: null
      • Optional tokenId: null
      • Optional assetId: null

      Returns LogNftDepositEventFilter

  • LogNftDeposit:function
    • LogNftDeposit(depositorEthKey?, starkKey?, vaultId?, assetType?, tokenId?, assetId?): LogNftDepositEventFilter

    • Parameters

      • Optional depositorEthKey: null
      • Optional starkKey: null
      • Optional vaultId: null
      • Optional assetType: null
      • Optional tokenId: null
      • Optional assetId: null

      Returns LogNftDepositEventFilter

  • LogNftWithdrawalAllowed(uint256,uint256):function
    • LogNftWithdrawalAllowed(uint256,uint256)(ownerKey?, assetId?): LogNftWithdrawalAllowedEventFilter

    • Parameters

      • Optional ownerKey: null
      • Optional assetId: null

      Returns LogNftWithdrawalAllowedEventFilter

  • LogNftWithdrawalAllowed:function
    • LogNftWithdrawalAllowed(ownerKey?, assetId?): LogNftWithdrawalAllowedEventFilter

    • Parameters

      • Optional ownerKey: null
      • Optional assetId: null

      Returns LogNftWithdrawalAllowedEventFilter

  • LogNftWithdrawalPerformed(uint256,uint256,uint256,uint256,address):function
    • LogNftWithdrawalPerformed(uint256,uint256,uint256,uint256,address)(ownerKey?, assetType?, tokenId?, assetId?, recipient?): LogNftWithdrawalPerformedEventFilter

    • Parameters

      • Optional ownerKey: null
      • Optional assetType: null
      • Optional tokenId: null
      • Optional assetId: null
      • Optional recipient: null

      Returns LogNftWithdrawalPerformedEventFilter

  • LogNftWithdrawalPerformed:function
    • LogNftWithdrawalPerformed(ownerKey?, assetType?, tokenId?, assetId?, recipient?): LogNftWithdrawalPerformedEventFilter

    • Parameters

      • Optional ownerKey: null
      • Optional assetType: null
      • Optional tokenId: null
      • Optional assetId: null
      • Optional recipient: null

      Returns LogNftWithdrawalPerformedEventFilter

  • LogNominatedGovernor(address):function
    • LogNominatedGovernor(address)(nominatedGovernor?): LogNominatedGovernorEventFilter

    • Parameters

      • Optional nominatedGovernor: null

      Returns LogNominatedGovernorEventFilter

  • LogNominatedGovernor:function
    • LogNominatedGovernor(nominatedGovernor?): LogNominatedGovernorEventFilter

    • Parameters

      • Optional nominatedGovernor: null

      Returns LogNominatedGovernorEventFilter

  • LogNominationCancelled():function
    • LogNominationCancelled()(): LogNominationCancelledEventFilter

    • Returns LogNominationCancelledEventFilter

  • LogNominationCancelled:function
    • LogNominationCancelled(): LogNominationCancelledEventFilter

    • Returns LogNominationCancelledEventFilter

  • LogOperatorAdded(address):function
    • LogOperatorAdded(address)(operator?): LogOperatorAddedEventFilter

    • Parameters

      • Optional operator: null

      Returns LogOperatorAddedEventFilter

  • LogOperatorAdded:function
    • LogOperatorAdded(operator?): LogOperatorAddedEventFilter

    • Parameters

      • Optional operator: null

      Returns LogOperatorAddedEventFilter

  • LogOperatorRemoved(address):function
    • LogOperatorRemoved(address)(operator?): LogOperatorRemovedEventFilter

    • Parameters

      • Optional operator: null

      Returns LogOperatorRemovedEventFilter

  • LogOperatorRemoved:function
    • LogOperatorRemoved(operator?): LogOperatorRemovedEventFilter

    • Parameters

      • Optional operator: null

      Returns LogOperatorRemovedEventFilter

  • LogRegistered(address,string):function
    • LogRegistered(address,string)(entry?, entryId?): LogRegisteredEventFilter

    • Parameters

      • Optional entry: null
      • Optional entryId: null

      Returns LogRegisteredEventFilter

  • LogRegistered:function
    • LogRegistered(entry?, entryId?): LogRegisteredEventFilter

    • Parameters

      • Optional entry: null
      • Optional entryId: null

      Returns LogRegisteredEventFilter

  • LogRemovalIntent(address,string):function
    • LogRemovalIntent(address,string)(entry?, entryId?): LogRemovalIntentEventFilter

    • Parameters

      • Optional entry: null
      • Optional entryId: null

      Returns LogRemovalIntentEventFilter

  • LogRemovalIntent:function
    • LogRemovalIntent(entry?, entryId?): LogRemovalIntentEventFilter

    • Parameters

      • Optional entry: null
      • Optional entryId: null

      Returns LogRemovalIntentEventFilter

  • LogRemoved(address,string):function
    • LogRemoved(address,string)(entry?, entryId?): LogRemovedEventFilter

    • Parameters

      • Optional entry: null
      • Optional entryId: null

      Returns LogRemovedEventFilter

  • LogRemoved:function
    • LogRemoved(entry?, entryId?): LogRemovedEventFilter

    • Parameters

      • Optional entry: null
      • Optional entryId: null

      Returns LogRemovedEventFilter

  • LogRemovedGovernor(address):function
    • LogRemovedGovernor(address)(removedGovernor?): LogRemovedGovernorEventFilter

    • Parameters

      • Optional removedGovernor: null

      Returns LogRemovedGovernorEventFilter

  • LogRemovedGovernor:function
    • LogRemovedGovernor(removedGovernor?): LogRemovedGovernorEventFilter

    • Parameters

      • Optional removedGovernor: null

      Returns LogRemovedGovernorEventFilter

  • LogRootUpdate(uint256,uint256,uint256,uint256):function
    • LogRootUpdate(uint256,uint256,uint256,uint256)(sequenceNumber?, batchId?, vaultRoot?, orderRoot?): LogRootUpdateEventFilter

    • Parameters

      • Optional sequenceNumber: null
      • Optional batchId: null
      • Optional vaultRoot: null
      • Optional orderRoot: null

      Returns LogRootUpdateEventFilter

  • LogRootUpdate:function
    • LogRootUpdate(sequenceNumber?, batchId?, vaultRoot?, orderRoot?): LogRootUpdateEventFilter

    • Parameters

      • Optional sequenceNumber: null
      • Optional batchId: null
      • Optional vaultRoot: null
      • Optional orderRoot: null

      Returns LogRootUpdateEventFilter

  • LogStateTransitionFact(bytes32):function
    • LogStateTransitionFact(bytes32)(stateTransitionFact?): LogStateTransitionFactEventFilter

    • Parameters

      • Optional stateTransitionFact: null

      Returns LogStateTransitionFactEventFilter

  • LogStateTransitionFact:function
    • LogStateTransitionFact(stateTransitionFact?): LogStateTransitionFactEventFilter

    • Parameters

      • Optional stateTransitionFact: null

      Returns LogStateTransitionFactEventFilter

  • LogTokenAdminAdded(address):function
    • LogTokenAdminAdded(address)(tokenAdmin?): LogTokenAdminAddedEventFilter

    • Parameters

      • Optional tokenAdmin: null

      Returns LogTokenAdminAddedEventFilter

  • LogTokenAdminAdded:function
    • LogTokenAdminAdded(tokenAdmin?): LogTokenAdminAddedEventFilter

    • Parameters

      • Optional tokenAdmin: null

      Returns LogTokenAdminAddedEventFilter

  • LogTokenAdminRemoved(address):function
    • LogTokenAdminRemoved(address)(tokenAdmin?): LogTokenAdminRemovedEventFilter

    • Parameters

      • Optional tokenAdmin: null

      Returns LogTokenAdminRemovedEventFilter

  • LogTokenAdminRemoved:function
    • LogTokenAdminRemoved(tokenAdmin?): LogTokenAdminRemovedEventFilter

    • Parameters

      • Optional tokenAdmin: null

      Returns LogTokenAdminRemovedEventFilter

  • LogTokenRegistered(uint256,bytes,uint256):function
    • LogTokenRegistered(uint256,bytes,uint256)(assetType?, assetInfo?, quantum?): LogTokenRegisteredEventFilter

    • Parameters

      • Optional assetType: null
      • Optional assetInfo: null
      • Optional quantum: null

      Returns LogTokenRegisteredEventFilter

  • LogTokenRegistered:function
    • LogTokenRegistered(assetType?, assetInfo?, quantum?): LogTokenRegisteredEventFilter

    • Parameters

      • Optional assetType: null
      • Optional assetInfo: null
      • Optional quantum: null

      Returns LogTokenRegisteredEventFilter

  • LogUnFrozen():function
    • LogUnFrozen()(): LogUnFrozenEventFilter

    • Returns LogUnFrozenEventFilter

  • LogUnFrozen:function
    • LogUnFrozen(): LogUnFrozenEventFilter

    • Returns LogUnFrozenEventFilter

  • LogUserRegistered(address,uint256,address):function
    • LogUserRegistered(address,uint256,address)(ethKey?, starkKey?, sender?): LogUserRegisteredEventFilter

    • Parameters

      • Optional ethKey: null
      • Optional starkKey: null
      • Optional sender: null

      Returns LogUserRegisteredEventFilter

  • LogUserRegistered:function
    • LogUserRegistered(ethKey?, starkKey?, sender?): LogUserRegisteredEventFilter

    • Parameters

      • Optional ethKey: null
      • Optional starkKey: null
      • Optional sender: null

      Returns LogUserRegisteredEventFilter

  • LogVaultBalanceChangeApplied(address,uint256,uint256,int256):function
    • LogVaultBalanceChangeApplied(address,uint256,uint256,int256)(ethKey?, assetId?, vaultId?, quantizedAmountChange?): LogVaultBalanceChangeAppliedEventFilter

    • Parameters

      • Optional ethKey: null
      • Optional assetId: null
      • Optional vaultId: null
      • Optional quantizedAmountChange: null

      Returns LogVaultBalanceChangeAppliedEventFilter

  • LogVaultBalanceChangeApplied:function
    • LogVaultBalanceChangeApplied(ethKey?, assetId?, vaultId?, quantizedAmountChange?): LogVaultBalanceChangeAppliedEventFilter

    • Parameters

      • Optional ethKey: null
      • Optional assetId: null
      • Optional vaultId: null
      • Optional quantizedAmountChange: null

      Returns LogVaultBalanceChangeAppliedEventFilter

  • LogVaultWithdrawalLockSet(address,uint256,uint256,uint256):function
    • LogVaultWithdrawalLockSet(address,uint256,uint256,uint256)(ethKey?, assetId?, vaultId?, timeRelease?): LogVaultWithdrawalLockSetEventFilter

    • Parameters

      • Optional ethKey: null
      • Optional assetId: null
      • Optional vaultId: null
      • Optional timeRelease: null

      Returns LogVaultWithdrawalLockSetEventFilter

  • LogVaultWithdrawalLockSet:function
    • LogVaultWithdrawalLockSet(ethKey?, assetId?, vaultId?, timeRelease?): LogVaultWithdrawalLockSetEventFilter

    • Parameters

      • Optional ethKey: null
      • Optional assetId: null
      • Optional vaultId: null
      • Optional timeRelease: null

      Returns LogVaultWithdrawalLockSetEventFilter

  • LogWithdrawalAllowed(uint256,uint256,uint256,uint256):function
    • LogWithdrawalAllowed(uint256,uint256,uint256,uint256)(ownerKey?, assetType?, nonQuantizedAmount?, quantizedAmount?): LogWithdrawalAllowedEventFilter

    • Parameters

      • Optional ownerKey: null
      • Optional assetType: null
      • Optional nonQuantizedAmount: null
      • Optional quantizedAmount: null

      Returns LogWithdrawalAllowedEventFilter

  • LogWithdrawalAllowed:function
    • LogWithdrawalAllowed(ownerKey?, assetType?, nonQuantizedAmount?, quantizedAmount?): LogWithdrawalAllowedEventFilter

    • Parameters

      • Optional ownerKey: null
      • Optional assetType: null
      • Optional nonQuantizedAmount: null
      • Optional quantizedAmount: null

      Returns LogWithdrawalAllowedEventFilter

  • LogWithdrawalFromVault(address,uint256,uint256,uint256,uint256):function
    • LogWithdrawalFromVault(address,uint256,uint256,uint256,uint256)(ethKey?, assetId?, vaultId?, nonQuantizedAmount?, quantizedAmount?): LogWithdrawalFromVaultEventFilter

    • Parameters

      • Optional ethKey: null
      • Optional assetId: null
      • Optional vaultId: null
      • Optional nonQuantizedAmount: null
      • Optional quantizedAmount: null

      Returns LogWithdrawalFromVaultEventFilter

  • LogWithdrawalFromVault:function
    • LogWithdrawalFromVault(ethKey?, assetId?, vaultId?, nonQuantizedAmount?, quantizedAmount?): LogWithdrawalFromVaultEventFilter

    • Parameters

      • Optional ethKey: null
      • Optional assetId: null
      • Optional vaultId: null
      • Optional nonQuantizedAmount: null
      • Optional quantizedAmount: null

      Returns LogWithdrawalFromVaultEventFilter

  • LogWithdrawalPerformed(uint256,uint256,uint256,uint256,address):function
    • LogWithdrawalPerformed(uint256,uint256,uint256,uint256,address)(ownerKey?, assetType?, nonQuantizedAmount?, quantizedAmount?, recipient?): LogWithdrawalPerformedEventFilter

    • Parameters

      • Optional ownerKey: null
      • Optional assetType: null
      • Optional nonQuantizedAmount: null
      • Optional quantizedAmount: null
      • Optional recipient: null

      Returns LogWithdrawalPerformedEventFilter

  • LogWithdrawalPerformed:function
    • LogWithdrawalPerformed(ownerKey?, assetType?, nonQuantizedAmount?, quantizedAmount?, recipient?): LogWithdrawalPerformedEventFilter

    • Parameters

      • Optional ownerKey: null
      • Optional assetType: null
      • Optional nonQuantizedAmount: null
      • Optional quantizedAmount: null
      • Optional recipient: null

      Returns LogWithdrawalPerformedEventFilter

estimateGas

estimateGas: {
    DEPOSIT_CANCEL_DELAY(overrides?) => Promise<BigNumber>;
    FREEZE_GRACE_PERIOD(overrides?) => Promise<BigNumber>;
    MAIN_GOVERNANCE_INFO_TAG(overrides?) => Promise<BigNumber>;
    MAX_FORCED_ACTIONS_REQS_PER_BLOCK(overrides?) => Promise<BigNumber>;
    MAX_VERIFIER_COUNT(overrides?) => Promise<BigNumber>;
    STARKEX_MAX_DEFAULT_VAULT_LOCK(overrides?) => Promise<BigNumber>;
    UNFREEZE_DELAY(overrides?) => Promise<BigNumber>;
    VERIFIER_REMOVAL_DELAY(overrides?) => Promise<BigNumber>;
    VERSION(overrides?) => Promise<BigNumber>;
    announceAvailabilityVerifierRemovalIntent(verifier, overrides?) => Promise<BigNumber>;
    announceVerifierRemovalIntent(verifier, overrides?) => Promise<BigNumber>;
    defaultVaultWithdrawalLock(overrides?) => Promise<BigNumber>;
    deposit(uint256,uint256,uint256)(starkKey, assetType, vaultId, overrides?) => Promise<BigNumber>;
    deposit(uint256,uint256,uint256,uint256)(starkKey, assetType, vaultId, quantizedAmount, overrides?) => Promise<BigNumber>;
    depositCancel(starkKey, assetId, vaultId, overrides?) => Promise<BigNumber>;
    depositERC20(starkKey, assetType, vaultId, quantizedAmount, overrides?) => Promise<BigNumber>;
    depositERC20ToVault(assetId, vaultId, quantizedAmount, overrides?) => Promise<BigNumber>;
    depositEth(starkKey, assetType, vaultId, overrides?) => Promise<BigNumber>;
    depositEthToVault(assetId, vaultId, overrides?) => Promise<BigNumber>;
    depositNft(starkKey, assetType, vaultId, tokenId, overrides?) => Promise<BigNumber>;
    depositNftReclaim(starkKey, assetType, vaultId, tokenId, overrides?) => Promise<BigNumber>;
    depositReclaim(starkKey, assetId, vaultId, overrides?) => Promise<BigNumber>;
    escape(starkKey, vaultId, assetId, quantizedAmount, overrides?) => Promise<BigNumber>;
    freezeRequest(starkKey, vaultId, overrides?) => Promise<BigNumber>;
    fullWithdrawalRequest(starkKey, vaultId, overrides?) => Promise<BigNumber>;
    getActionCount(overrides?) => Promise<BigNumber>;
    getActionHashByIndex(actionIndex, overrides?) => Promise<BigNumber>;
    getAssetInfo(assetType, overrides?) => Promise<BigNumber>;
    getCancellationRequest(starkKey, assetId, vaultId, overrides?) => Promise<BigNumber>;
    getDepositBalance(starkKey, assetId, vaultId, overrides?) => Promise<BigNumber>;
    getEthKey(ownerKey, overrides?) => Promise<BigNumber>;
    getFullWithdrawalRequest(starkKey, vaultId, overrides?) => Promise<BigNumber>;
    getLastBatchId(overrides?) => Promise<BigNumber>;
    getOrderRoot(overrides?) => Promise<BigNumber>;
    getOrderTreeHeight(overrides?) => Promise<BigNumber>;
    getQuantizedDepositBalance(starkKey, assetId, vaultId, overrides?) => Promise<BigNumber>;
    getQuantizedVaultBalance(ethKey, assetId, vaultId, overrides?) => Promise<BigNumber>;
    getQuantum(presumedAssetType, overrides?) => Promise<BigNumber>;
    getRegisteredAvailabilityVerifiers(overrides?) => Promise<BigNumber>;
    getRegisteredVerifiers(overrides?) => Promise<BigNumber>;
    getSequenceNumber(overrides?) => Promise<BigNumber>;
    getVaultBalance(ethKey, assetId, vaultId, overrides?) => Promise<BigNumber>;
    getVaultRoot(overrides?) => Promise<BigNumber>;
    getVaultTreeHeight(overrides?) => Promise<BigNumber>;
    getVaultWithdrawalLock(ethKey, assetId, vaultId, overrides?) => Promise<BigNumber>;
    getWithdrawalBalance(ownerKey, assetId, overrides?) => Promise<BigNumber>;
    initialize(data, overrides?) => Promise<BigNumber>;
    isAssetRegistered(assetType, overrides?) => Promise<BigNumber>;
    isAvailabilityVerifier(verifierAddress, overrides?) => Promise<BigNumber>;
    isFrozen(overrides?) => Promise<BigNumber>;
    isOperator(testedOperator, overrides?) => Promise<BigNumber>;
    isStrictVaultBalancePolicy(overrides?) => Promise<BigNumber>;
    isTokenAdmin(testedAdmin, overrides?) => Promise<BigNumber>;
    isVaultLocked(ethKey, assetId, vaultId, overrides?) => Promise<BigNumber>;
    isVerifier(verifierAddress, overrides?) => Promise<BigNumber>;
    lockVault(assetId, vaultId, lockTime, overrides?) => Promise<BigNumber>;
    mainAcceptGovernance(overrides?) => Promise<BigNumber>;
    mainCancelNomination(overrides?) => Promise<BigNumber>;
    mainIsGovernor(testGovernor, overrides?) => Promise<BigNumber>;
    mainNominateNewGovernor(newGovernor, overrides?) => Promise<BigNumber>;
    mainRemoveGovernor(governorForRemoval, overrides?) => Promise<BigNumber>;
    onERC721Received(arg0, arg1, arg2, arg3, overrides?) => Promise<BigNumber>;
    orderRegistryAddress(overrides?) => Promise<BigNumber>;
    registerAndDepositERC20(ethKey, starkKey, signature, assetType, vaultId, quantizedAmount, overrides?) => Promise<BigNumber>;
    registerAndDepositEth(ethKey, starkKey, signature, assetType, vaultId, overrides?) => Promise<BigNumber>;
    registerAvailabilityVerifier(verifier, identifier, overrides?) => Promise<BigNumber>;
    registerEthAddress(ethKey, starkKey, starkSignature, overrides?) => Promise<BigNumber>;
    registerOperator(newOperator, overrides?) => Promise<BigNumber>;
    registerSender(starkKey, starkSignature, overrides?) => Promise<BigNumber>;
    registerToken(uint256,bytes)(assetType, assetInfo, overrides?) => Promise<BigNumber>;
    registerToken(uint256,bytes,uint256)(assetType, assetInfo, quantum, overrides?) => Promise<BigNumber>;
    registerTokenAdmin(newAdmin, overrides?) => Promise<BigNumber>;
    registerVerifier(verifier, identifier, overrides?) => Promise<BigNumber>;
    removeAvailabilityVerifier(verifier, overrides?) => Promise<BigNumber>;
    removeVerifier(verifier, overrides?) => Promise<BigNumber>;
    setDefaultVaultWithdrawalLock(newDefaultTime, overrides?) => Promise<BigNumber>;
    unFreeze(overrides?) => Promise<BigNumber>;
    unregisterOperator(removedOperator, overrides?) => Promise<BigNumber>;
    unregisterTokenAdmin(oldAdmin, overrides?) => Promise<BigNumber>;
    updateImplementationActivationTime(implementation, data, finalize, overrides?) => Promise<BigNumber>;
    updateState(publicInput, applicationData, overrides?) => Promise<BigNumber>;
    withdraw(ownerKey, assetType, overrides?) => Promise<BigNumber>;
    withdrawAndMint(ownerKey, assetType, mintingBlob, overrides?) => Promise<BigNumber>;
    withdrawFromVault(assetId, vaultId, quantizedAmount, overrides?) => Promise<BigNumber>;
    withdrawNft(ownerKey, assetType, tokenId, overrides?) => Promise<BigNumber>;
}

Type declaration

  • DEPOSIT_CANCEL_DELAY:function
    • DEPOSIT_CANCEL_DELAY(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • FREEZE_GRACE_PERIOD:function
    • FREEZE_GRACE_PERIOD(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • MAIN_GOVERNANCE_INFO_TAG:function
    • MAIN_GOVERNANCE_INFO_TAG(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • MAX_FORCED_ACTIONS_REQS_PER_BLOCK:function
    • MAX_FORCED_ACTIONS_REQS_PER_BLOCK(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • MAX_VERIFIER_COUNT:function
    • MAX_VERIFIER_COUNT(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • STARKEX_MAX_DEFAULT_VAULT_LOCK:function
    • STARKEX_MAX_DEFAULT_VAULT_LOCK(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • UNFREEZE_DELAY:function
    • UNFREEZE_DELAY(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • VERIFIER_REMOVAL_DELAY:function
    • VERIFIER_REMOVAL_DELAY(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • VERSION:function
    • VERSION(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • announceAvailabilityVerifierRemovalIntent:function
    • announceAvailabilityVerifierRemovalIntent(verifier, overrides?): Promise<BigNumber>

    • Parameters

      • verifier: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • announceVerifierRemovalIntent:function
    • announceVerifierRemovalIntent(verifier, overrides?): Promise<BigNumber>

    • Parameters

      • verifier: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • defaultVaultWithdrawalLock:function
    • defaultVaultWithdrawalLock(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • deposit(uint256,uint256,uint256):function
    • deposit(uint256,uint256,uint256)(starkKey, assetType, vaultId, overrides?): Promise<BigNumber>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • deposit(uint256,uint256,uint256,uint256):function
    • deposit(uint256,uint256,uint256,uint256)(starkKey, assetType, vaultId, quantizedAmount, overrides?): Promise<BigNumber>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • quantizedAmount: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • depositCancel:function
    • depositCancel(starkKey, assetId, vaultId, overrides?): Promise<BigNumber>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • depositERC20:function
    • depositERC20(starkKey, assetType, vaultId, quantizedAmount, overrides?): Promise<BigNumber>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • quantizedAmount: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • depositERC20ToVault:function
    • depositERC20ToVault(assetId, vaultId, quantizedAmount, overrides?): Promise<BigNumber>

    • Parameters

      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • quantizedAmount: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • depositEth:function
    • depositEth(starkKey, assetType, vaultId, overrides?): Promise<BigNumber>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • depositEthToVault:function
    • depositEthToVault(assetId, vaultId, overrides?): Promise<BigNumber>

    • Parameters

      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • depositNft:function
    • depositNft(starkKey, assetType, vaultId, tokenId, overrides?): Promise<BigNumber>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • tokenId: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • depositNftReclaim:function
    • depositNftReclaim(starkKey, assetType, vaultId, tokenId, overrides?): Promise<BigNumber>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • tokenId: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • depositReclaim:function
    • depositReclaim(starkKey, assetId, vaultId, overrides?): Promise<BigNumber>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • escape:function
    • escape(starkKey, vaultId, assetId, quantizedAmount, overrides?): Promise<BigNumber>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • assetId: PromiseOrValue<BigNumberish>
      • quantizedAmount: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • freezeRequest:function
    • freezeRequest(starkKey, vaultId, overrides?): Promise<BigNumber>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • fullWithdrawalRequest:function
    • fullWithdrawalRequest(starkKey, vaultId, overrides?): Promise<BigNumber>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • getActionCount:function
    • getActionCount(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getActionHashByIndex:function
    • getActionHashByIndex(actionIndex, overrides?): Promise<BigNumber>

    • Parameters

      • actionIndex: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getAssetInfo:function
    • getAssetInfo(assetType, overrides?): Promise<BigNumber>

    • Parameters

      • assetType: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getCancellationRequest:function
    • getCancellationRequest(starkKey, assetId, vaultId, overrides?): Promise<BigNumber>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getDepositBalance:function
    • getDepositBalance(starkKey, assetId, vaultId, overrides?): Promise<BigNumber>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getEthKey:function
    • getEthKey(ownerKey, overrides?): Promise<BigNumber>

    • Parameters

      • ownerKey: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getFullWithdrawalRequest:function
    • getFullWithdrawalRequest(starkKey, vaultId, overrides?): Promise<BigNumber>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getLastBatchId:function
    • getLastBatchId(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getOrderRoot:function
    • getOrderRoot(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getOrderTreeHeight:function
    • getOrderTreeHeight(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getQuantizedDepositBalance:function
    • getQuantizedDepositBalance(starkKey, assetId, vaultId, overrides?): Promise<BigNumber>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getQuantizedVaultBalance:function
    • getQuantizedVaultBalance(ethKey, assetId, vaultId, overrides?): Promise<BigNumber>

    • Parameters

      • ethKey: PromiseOrValue<string>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getQuantum:function
    • getQuantum(presumedAssetType, overrides?): Promise<BigNumber>

    • Parameters

      • presumedAssetType: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getRegisteredAvailabilityVerifiers:function
    • getRegisteredAvailabilityVerifiers(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getRegisteredVerifiers:function
    • getRegisteredVerifiers(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getSequenceNumber:function
    • getSequenceNumber(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getVaultBalance:function
    • getVaultBalance(ethKey, assetId, vaultId, overrides?): Promise<BigNumber>

    • Parameters

      • ethKey: PromiseOrValue<string>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getVaultRoot:function
    • getVaultRoot(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getVaultTreeHeight:function
    • getVaultTreeHeight(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getVaultWithdrawalLock:function
    • getVaultWithdrawalLock(ethKey, assetId, vaultId, overrides?): Promise<BigNumber>

    • Parameters

      • ethKey: PromiseOrValue<string>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getWithdrawalBalance:function
    • getWithdrawalBalance(ownerKey, assetId, overrides?): Promise<BigNumber>

    • Parameters

      • ownerKey: PromiseOrValue<BigNumberish>
      • assetId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • initialize:function
    • initialize(data, overrides?): Promise<BigNumber>

    • Parameters

      • data: PromiseOrValue<BytesLike>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • isAssetRegistered:function
    • isAssetRegistered(assetType, overrides?): Promise<BigNumber>

    • Parameters

      • assetType: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • isAvailabilityVerifier:function
    • isAvailabilityVerifier(verifierAddress, overrides?): Promise<BigNumber>

    • Parameters

      • verifierAddress: PromiseOrValue<string>
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • isFrozen:function
    • isFrozen(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • isOperator:function
    • isOperator(testedOperator, overrides?): Promise<BigNumber>

    • Parameters

      • testedOperator: PromiseOrValue<string>
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • isStrictVaultBalancePolicy:function
    • isStrictVaultBalancePolicy(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • isTokenAdmin:function
    • isTokenAdmin(testedAdmin, overrides?): Promise<BigNumber>

    • Parameters

      • testedAdmin: PromiseOrValue<string>
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • isVaultLocked:function
    • isVaultLocked(ethKey, assetId, vaultId, overrides?): Promise<BigNumber>

    • Parameters

      • ethKey: PromiseOrValue<string>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • isVerifier:function
    • isVerifier(verifierAddress, overrides?): Promise<BigNumber>

    • Parameters

      • verifierAddress: PromiseOrValue<string>
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • lockVault:function
    • lockVault(assetId, vaultId, lockTime, overrides?): Promise<BigNumber>

    • Parameters

      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • lockTime: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • mainAcceptGovernance:function
    • mainAcceptGovernance(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • mainCancelNomination:function
    • mainCancelNomination(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • mainIsGovernor:function
    • mainIsGovernor(testGovernor, overrides?): Promise<BigNumber>

    • Parameters

      • testGovernor: PromiseOrValue<string>
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • mainNominateNewGovernor:function
    • mainNominateNewGovernor(newGovernor, overrides?): Promise<BigNumber>

    • Parameters

      • newGovernor: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • mainRemoveGovernor:function
    • mainRemoveGovernor(governorForRemoval, overrides?): Promise<BigNumber>

    • Parameters

      • governorForRemoval: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • onERC721Received:function
    • onERC721Received(arg0, arg1, arg2, arg3, overrides?): Promise<BigNumber>

    • Parameters

      • arg0: PromiseOrValue<string>
      • arg1: PromiseOrValue<string>
      • arg2: PromiseOrValue<BigNumberish>
      • arg3: PromiseOrValue<BytesLike>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • orderRegistryAddress:function
    • orderRegistryAddress(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • registerAndDepositERC20:function
    • registerAndDepositERC20(ethKey, starkKey, signature, assetType, vaultId, quantizedAmount, overrides?): Promise<BigNumber>

    • Parameters

      • ethKey: PromiseOrValue<string>
      • starkKey: PromiseOrValue<BigNumberish>
      • signature: PromiseOrValue<BytesLike>
      • assetType: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • quantizedAmount: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • registerAndDepositEth:function
    • registerAndDepositEth(ethKey, starkKey, signature, assetType, vaultId, overrides?): Promise<BigNumber>

    • Parameters

      • ethKey: PromiseOrValue<string>
      • starkKey: PromiseOrValue<BigNumberish>
      • signature: PromiseOrValue<BytesLike>
      • assetType: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • registerAvailabilityVerifier:function
    • registerAvailabilityVerifier(verifier, identifier, overrides?): Promise<BigNumber>

    • Parameters

      • verifier: PromiseOrValue<string>
      • identifier: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • registerEthAddress:function
    • registerEthAddress(ethKey, starkKey, starkSignature, overrides?): Promise<BigNumber>

    • Parameters

      • ethKey: PromiseOrValue<string>
      • starkKey: PromiseOrValue<BigNumberish>
      • starkSignature: PromiseOrValue<BytesLike>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • registerOperator:function
    • registerOperator(newOperator, overrides?): Promise<BigNumber>

    • Parameters

      • newOperator: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • registerSender:function
    • registerSender(starkKey, starkSignature, overrides?): Promise<BigNumber>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • starkSignature: PromiseOrValue<BytesLike>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • registerToken(uint256,bytes):function
    • registerToken(uint256,bytes)(assetType, assetInfo, overrides?): Promise<BigNumber>

    • Parameters

      • assetType: PromiseOrValue<BigNumberish>
      • assetInfo: PromiseOrValue<BytesLike>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • registerToken(uint256,bytes,uint256):function
    • registerToken(uint256,bytes,uint256)(assetType, assetInfo, quantum, overrides?): Promise<BigNumber>

    • Parameters

      • assetType: PromiseOrValue<BigNumberish>
      • assetInfo: PromiseOrValue<BytesLike>
      • quantum: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • registerTokenAdmin:function
    • registerTokenAdmin(newAdmin, overrides?): Promise<BigNumber>

    • Parameters

      • newAdmin: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • registerVerifier:function
    • registerVerifier(verifier, identifier, overrides?): Promise<BigNumber>

    • Parameters

      • verifier: PromiseOrValue<string>
      • identifier: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • removeAvailabilityVerifier:function
    • removeAvailabilityVerifier(verifier, overrides?): Promise<BigNumber>

    • Parameters

      • verifier: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • removeVerifier:function
    • removeVerifier(verifier, overrides?): Promise<BigNumber>

    • Parameters

      • verifier: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • setDefaultVaultWithdrawalLock:function
    • setDefaultVaultWithdrawalLock(newDefaultTime, overrides?): Promise<BigNumber>

    • Parameters

      • newDefaultTime: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • unFreeze:function
    • unFreeze(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • unregisterOperator:function
    • unregisterOperator(removedOperator, overrides?): Promise<BigNumber>

    • Parameters

      • removedOperator: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • unregisterTokenAdmin:function
    • unregisterTokenAdmin(oldAdmin, overrides?): Promise<BigNumber>

    • Parameters

      • oldAdmin: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • updateImplementationActivationTime:function
    • updateImplementationActivationTime(implementation, data, finalize, overrides?): Promise<BigNumber>

    • Parameters

      • implementation: PromiseOrValue<string>
      • data: PromiseOrValue<BytesLike>
      • finalize: PromiseOrValue<boolean>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • updateState:function
    • updateState(publicInput, applicationData, overrides?): Promise<BigNumber>

    • Parameters

      • publicInput: PromiseOrValue<BigNumberish>[]
      • applicationData: PromiseOrValue<BigNumberish>[]
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • withdraw:function
    • withdraw(ownerKey, assetType, overrides?): Promise<BigNumber>

    • Parameters

      • ownerKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • withdrawAndMint:function
    • withdrawAndMint(ownerKey, assetType, mintingBlob, overrides?): Promise<BigNumber>

    • Parameters

      • ownerKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • mintingBlob: PromiseOrValue<BytesLike>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • withdrawFromVault:function
    • withdrawFromVault(assetId, vaultId, quantizedAmount, overrides?): Promise<BigNumber>

    • Parameters

      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • quantizedAmount: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

  • withdrawNft:function
    • withdrawNft(ownerKey, assetType, tokenId, overrides?): Promise<BigNumber>

    • Parameters

      • ownerKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • tokenId: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<BigNumber>

populateTransaction

populateTransaction: {
    DEPOSIT_CANCEL_DELAY(overrides?) => Promise<PopulatedTransaction>;
    FREEZE_GRACE_PERIOD(overrides?) => Promise<PopulatedTransaction>;
    MAIN_GOVERNANCE_INFO_TAG(overrides?) => Promise<PopulatedTransaction>;
    MAX_FORCED_ACTIONS_REQS_PER_BLOCK(overrides?) => Promise<PopulatedTransaction>;
    MAX_VERIFIER_COUNT(overrides?) => Promise<PopulatedTransaction>;
    STARKEX_MAX_DEFAULT_VAULT_LOCK(overrides?) => Promise<PopulatedTransaction>;
    UNFREEZE_DELAY(overrides?) => Promise<PopulatedTransaction>;
    VERIFIER_REMOVAL_DELAY(overrides?) => Promise<PopulatedTransaction>;
    VERSION(overrides?) => Promise<PopulatedTransaction>;
    announceAvailabilityVerifierRemovalIntent(verifier, overrides?) => Promise<PopulatedTransaction>;
    announceVerifierRemovalIntent(verifier, overrides?) => Promise<PopulatedTransaction>;
    defaultVaultWithdrawalLock(overrides?) => Promise<PopulatedTransaction>;
    deposit(uint256,uint256,uint256)(starkKey, assetType, vaultId, overrides?) => Promise<PopulatedTransaction>;
    deposit(uint256,uint256,uint256,uint256)(starkKey, assetType, vaultId, quantizedAmount, overrides?) => Promise<PopulatedTransaction>;
    depositCancel(starkKey, assetId, vaultId, overrides?) => Promise<PopulatedTransaction>;
    depositERC20(starkKey, assetType, vaultId, quantizedAmount, overrides?) => Promise<PopulatedTransaction>;
    depositERC20ToVault(assetId, vaultId, quantizedAmount, overrides?) => Promise<PopulatedTransaction>;
    depositEth(starkKey, assetType, vaultId, overrides?) => Promise<PopulatedTransaction>;
    depositEthToVault(assetId, vaultId, overrides?) => Promise<PopulatedTransaction>;
    depositNft(starkKey, assetType, vaultId, tokenId, overrides?) => Promise<PopulatedTransaction>;
    depositNftReclaim(starkKey, assetType, vaultId, tokenId, overrides?) => Promise<PopulatedTransaction>;
    depositReclaim(starkKey, assetId, vaultId, overrides?) => Promise<PopulatedTransaction>;
    escape(starkKey, vaultId, assetId, quantizedAmount, overrides?) => Promise<PopulatedTransaction>;
    freezeRequest(starkKey, vaultId, overrides?) => Promise<PopulatedTransaction>;
    fullWithdrawalRequest(starkKey, vaultId, overrides?) => Promise<PopulatedTransaction>;
    getActionCount(overrides?) => Promise<PopulatedTransaction>;
    getActionHashByIndex(actionIndex, overrides?) => Promise<PopulatedTransaction>;
    getAssetInfo(assetType, overrides?) => Promise<PopulatedTransaction>;
    getCancellationRequest(starkKey, assetId, vaultId, overrides?) => Promise<PopulatedTransaction>;
    getDepositBalance(starkKey, assetId, vaultId, overrides?) => Promise<PopulatedTransaction>;
    getEthKey(ownerKey, overrides?) => Promise<PopulatedTransaction>;
    getFullWithdrawalRequest(starkKey, vaultId, overrides?) => Promise<PopulatedTransaction>;
    getLastBatchId(overrides?) => Promise<PopulatedTransaction>;
    getOrderRoot(overrides?) => Promise<PopulatedTransaction>;
    getOrderTreeHeight(overrides?) => Promise<PopulatedTransaction>;
    getQuantizedDepositBalance(starkKey, assetId, vaultId, overrides?) => Promise<PopulatedTransaction>;
    getQuantizedVaultBalance(ethKey, assetId, vaultId, overrides?) => Promise<PopulatedTransaction>;
    getQuantum(presumedAssetType, overrides?) => Promise<PopulatedTransaction>;
    getRegisteredAvailabilityVerifiers(overrides?) => Promise<PopulatedTransaction>;
    getRegisteredVerifiers(overrides?) => Promise<PopulatedTransaction>;
    getSequenceNumber(overrides?) => Promise<PopulatedTransaction>;
    getVaultBalance(ethKey, assetId, vaultId, overrides?) => Promise<PopulatedTransaction>;
    getVaultRoot(overrides?) => Promise<PopulatedTransaction>;
    getVaultTreeHeight(overrides?) => Promise<PopulatedTransaction>;
    getVaultWithdrawalLock(ethKey, assetId, vaultId, overrides?) => Promise<PopulatedTransaction>;
    getWithdrawalBalance(ownerKey, assetId, overrides?) => Promise<PopulatedTransaction>;
    initialize(data, overrides?) => Promise<PopulatedTransaction>;
    isAssetRegistered(assetType, overrides?) => Promise<PopulatedTransaction>;
    isAvailabilityVerifier(verifierAddress, overrides?) => Promise<PopulatedTransaction>;
    isFrozen(overrides?) => Promise<PopulatedTransaction>;
    isOperator(testedOperator, overrides?) => Promise<PopulatedTransaction>;
    isStrictVaultBalancePolicy(overrides?) => Promise<PopulatedTransaction>;
    isTokenAdmin(testedAdmin, overrides?) => Promise<PopulatedTransaction>;
    isVaultLocked(ethKey, assetId, vaultId, overrides?) => Promise<PopulatedTransaction>;
    isVerifier(verifierAddress, overrides?) => Promise<PopulatedTransaction>;
    lockVault(assetId, vaultId, lockTime, overrides?) => Promise<PopulatedTransaction>;
    mainAcceptGovernance(overrides?) => Promise<PopulatedTransaction>;
    mainCancelNomination(overrides?) => Promise<PopulatedTransaction>;
    mainIsGovernor(testGovernor, overrides?) => Promise<PopulatedTransaction>;
    mainNominateNewGovernor(newGovernor, overrides?) => Promise<PopulatedTransaction>;
    mainRemoveGovernor(governorForRemoval, overrides?) => Promise<PopulatedTransaction>;
    onERC721Received(arg0, arg1, arg2, arg3, overrides?) => Promise<PopulatedTransaction>;
    orderRegistryAddress(overrides?) => Promise<PopulatedTransaction>;
    registerAndDepositERC20(ethKey, starkKey, signature, assetType, vaultId, quantizedAmount, overrides?) => Promise<PopulatedTransaction>;
    registerAndDepositEth(ethKey, starkKey, signature, assetType, vaultId, overrides?) => Promise<PopulatedTransaction>;
    registerAvailabilityVerifier(verifier, identifier, overrides?) => Promise<PopulatedTransaction>;
    registerEthAddress(ethKey, starkKey, starkSignature, overrides?) => Promise<PopulatedTransaction>;
    registerOperator(newOperator, overrides?) => Promise<PopulatedTransaction>;
    registerSender(starkKey, starkSignature, overrides?) => Promise<PopulatedTransaction>;
    registerToken(uint256,bytes)(assetType, assetInfo, overrides?) => Promise<PopulatedTransaction>;
    registerToken(uint256,bytes,uint256)(assetType, assetInfo, quantum, overrides?) => Promise<PopulatedTransaction>;
    registerTokenAdmin(newAdmin, overrides?) => Promise<PopulatedTransaction>;
    registerVerifier(verifier, identifier, overrides?) => Promise<PopulatedTransaction>;
    removeAvailabilityVerifier(verifier, overrides?) => Promise<PopulatedTransaction>;
    removeVerifier(verifier, overrides?) => Promise<PopulatedTransaction>;
    setDefaultVaultWithdrawalLock(newDefaultTime, overrides?) => Promise<PopulatedTransaction>;
    unFreeze(overrides?) => Promise<PopulatedTransaction>;
    unregisterOperator(removedOperator, overrides?) => Promise<PopulatedTransaction>;
    unregisterTokenAdmin(oldAdmin, overrides?) => Promise<PopulatedTransaction>;
    updateImplementationActivationTime(implementation, data, finalize, overrides?) => Promise<PopulatedTransaction>;
    updateState(publicInput, applicationData, overrides?) => Promise<PopulatedTransaction>;
    withdraw(ownerKey, assetType, overrides?) => Promise<PopulatedTransaction>;
    withdrawAndMint(ownerKey, assetType, mintingBlob, overrides?) => Promise<PopulatedTransaction>;
    withdrawFromVault(assetId, vaultId, quantizedAmount, overrides?) => Promise<PopulatedTransaction>;
    withdrawNft(ownerKey, assetType, tokenId, overrides?) => Promise<PopulatedTransaction>;
}

Type declaration

  • DEPOSIT_CANCEL_DELAY:function
    • DEPOSIT_CANCEL_DELAY(overrides?): Promise<PopulatedTransaction>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • FREEZE_GRACE_PERIOD:function
    • FREEZE_GRACE_PERIOD(overrides?): Promise<PopulatedTransaction>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • MAIN_GOVERNANCE_INFO_TAG:function
    • MAIN_GOVERNANCE_INFO_TAG(overrides?): Promise<PopulatedTransaction>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • MAX_FORCED_ACTIONS_REQS_PER_BLOCK:function
    • MAX_FORCED_ACTIONS_REQS_PER_BLOCK(overrides?): Promise<PopulatedTransaction>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • MAX_VERIFIER_COUNT:function
    • MAX_VERIFIER_COUNT(overrides?): Promise<PopulatedTransaction>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • STARKEX_MAX_DEFAULT_VAULT_LOCK:function
    • STARKEX_MAX_DEFAULT_VAULT_LOCK(overrides?): Promise<PopulatedTransaction>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • UNFREEZE_DELAY:function
    • UNFREEZE_DELAY(overrides?): Promise<PopulatedTransaction>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • VERIFIER_REMOVAL_DELAY:function
    • VERIFIER_REMOVAL_DELAY(overrides?): Promise<PopulatedTransaction>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • VERSION:function
    • VERSION(overrides?): Promise<PopulatedTransaction>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • announceAvailabilityVerifierRemovalIntent:function
    • announceAvailabilityVerifierRemovalIntent(verifier, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • verifier: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • announceVerifierRemovalIntent:function
    • announceVerifierRemovalIntent(verifier, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • verifier: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • defaultVaultWithdrawalLock:function
    • defaultVaultWithdrawalLock(overrides?): Promise<PopulatedTransaction>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • deposit(uint256,uint256,uint256):function
    • deposit(uint256,uint256,uint256)(starkKey, assetType, vaultId, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • deposit(uint256,uint256,uint256,uint256):function
    • deposit(uint256,uint256,uint256,uint256)(starkKey, assetType, vaultId, quantizedAmount, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • quantizedAmount: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • depositCancel:function
    • depositCancel(starkKey, assetId, vaultId, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • depositERC20:function
    • depositERC20(starkKey, assetType, vaultId, quantizedAmount, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • quantizedAmount: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • depositERC20ToVault:function
    • depositERC20ToVault(assetId, vaultId, quantizedAmount, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • quantizedAmount: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • depositEth:function
    • depositEth(starkKey, assetType, vaultId, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • depositEthToVault:function
    • depositEthToVault(assetId, vaultId, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • depositNft:function
    • depositNft(starkKey, assetType, vaultId, tokenId, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • tokenId: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • depositNftReclaim:function
    • depositNftReclaim(starkKey, assetType, vaultId, tokenId, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • tokenId: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • depositReclaim:function
    • depositReclaim(starkKey, assetId, vaultId, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • escape:function
    • escape(starkKey, vaultId, assetId, quantizedAmount, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • assetId: PromiseOrValue<BigNumberish>
      • quantizedAmount: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • freezeRequest:function
    • freezeRequest(starkKey, vaultId, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • fullWithdrawalRequest:function
    • fullWithdrawalRequest(starkKey, vaultId, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • getActionCount:function
    • getActionCount(overrides?): Promise<PopulatedTransaction>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • getActionHashByIndex:function
    • getActionHashByIndex(actionIndex, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • actionIndex: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • getAssetInfo:function
    • getAssetInfo(assetType, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • assetType: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • getCancellationRequest:function
    • getCancellationRequest(starkKey, assetId, vaultId, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • getDepositBalance:function
    • getDepositBalance(starkKey, assetId, vaultId, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • getEthKey:function
    • getEthKey(ownerKey, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • ownerKey: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • getFullWithdrawalRequest:function
    • getFullWithdrawalRequest(starkKey, vaultId, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • getLastBatchId:function
    • getLastBatchId(overrides?): Promise<PopulatedTransaction>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • getOrderRoot:function
    • getOrderRoot(overrides?): Promise<PopulatedTransaction>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • getOrderTreeHeight:function
    • getOrderTreeHeight(overrides?): Promise<PopulatedTransaction>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • getQuantizedDepositBalance:function
    • getQuantizedDepositBalance(starkKey, assetId, vaultId, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • getQuantizedVaultBalance:function
    • getQuantizedVaultBalance(ethKey, assetId, vaultId, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • ethKey: PromiseOrValue<string>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • getQuantum:function
    • getQuantum(presumedAssetType, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • presumedAssetType: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • getRegisteredAvailabilityVerifiers:function
    • getRegisteredAvailabilityVerifiers(overrides?): Promise<PopulatedTransaction>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • getRegisteredVerifiers:function
    • getRegisteredVerifiers(overrides?): Promise<PopulatedTransaction>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • getSequenceNumber:function
    • getSequenceNumber(overrides?): Promise<PopulatedTransaction>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • getVaultBalance:function
    • getVaultBalance(ethKey, assetId, vaultId, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • ethKey: PromiseOrValue<string>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • getVaultRoot:function
    • getVaultRoot(overrides?): Promise<PopulatedTransaction>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • getVaultTreeHeight:function
    • getVaultTreeHeight(overrides?): Promise<PopulatedTransaction>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • getVaultWithdrawalLock:function
    • getVaultWithdrawalLock(ethKey, assetId, vaultId, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • ethKey: PromiseOrValue<string>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • getWithdrawalBalance:function
    • getWithdrawalBalance(ownerKey, assetId, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • ownerKey: PromiseOrValue<BigNumberish>
      • assetId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • initialize:function
    • initialize(data, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • data: PromiseOrValue<BytesLike>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • isAssetRegistered:function
    • isAssetRegistered(assetType, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • assetType: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • isAvailabilityVerifier:function
    • isAvailabilityVerifier(verifierAddress, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • verifierAddress: PromiseOrValue<string>
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • isFrozen:function
    • isFrozen(overrides?): Promise<PopulatedTransaction>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • isOperator:function
    • isOperator(testedOperator, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • testedOperator: PromiseOrValue<string>
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • isStrictVaultBalancePolicy:function
    • isStrictVaultBalancePolicy(overrides?): Promise<PopulatedTransaction>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • isTokenAdmin:function
    • isTokenAdmin(testedAdmin, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • testedAdmin: PromiseOrValue<string>
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • isVaultLocked:function
    • isVaultLocked(ethKey, assetId, vaultId, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • ethKey: PromiseOrValue<string>
      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • isVerifier:function
    • isVerifier(verifierAddress, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • verifierAddress: PromiseOrValue<string>
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • lockVault:function
    • lockVault(assetId, vaultId, lockTime, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • lockTime: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • mainAcceptGovernance:function
    • mainAcceptGovernance(overrides?): Promise<PopulatedTransaction>

    • Parameters

      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • mainCancelNomination:function
    • mainCancelNomination(overrides?): Promise<PopulatedTransaction>

    • Parameters

      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • mainIsGovernor:function
    • mainIsGovernor(testGovernor, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • testGovernor: PromiseOrValue<string>
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • mainNominateNewGovernor:function
    • mainNominateNewGovernor(newGovernor, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • newGovernor: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • mainRemoveGovernor:function
    • mainRemoveGovernor(governorForRemoval, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • governorForRemoval: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • onERC721Received:function
    • onERC721Received(arg0, arg1, arg2, arg3, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • arg0: PromiseOrValue<string>
      • arg1: PromiseOrValue<string>
      • arg2: PromiseOrValue<BigNumberish>
      • arg3: PromiseOrValue<BytesLike>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • orderRegistryAddress:function
    • orderRegistryAddress(overrides?): Promise<PopulatedTransaction>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • registerAndDepositERC20:function
    • registerAndDepositERC20(ethKey, starkKey, signature, assetType, vaultId, quantizedAmount, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • ethKey: PromiseOrValue<string>
      • starkKey: PromiseOrValue<BigNumberish>
      • signature: PromiseOrValue<BytesLike>
      • assetType: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • quantizedAmount: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • registerAndDepositEth:function
    • registerAndDepositEth(ethKey, starkKey, signature, assetType, vaultId, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • ethKey: PromiseOrValue<string>
      • starkKey: PromiseOrValue<BigNumberish>
      • signature: PromiseOrValue<BytesLike>
      • assetType: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • Optional overrides: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • registerAvailabilityVerifier:function
    • registerAvailabilityVerifier(verifier, identifier, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • verifier: PromiseOrValue<string>
      • identifier: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • registerEthAddress:function
    • registerEthAddress(ethKey, starkKey, starkSignature, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • ethKey: PromiseOrValue<string>
      • starkKey: PromiseOrValue<BigNumberish>
      • starkSignature: PromiseOrValue<BytesLike>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • registerOperator:function
    • registerOperator(newOperator, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • newOperator: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • registerSender:function
    • registerSender(starkKey, starkSignature, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • starkKey: PromiseOrValue<BigNumberish>
      • starkSignature: PromiseOrValue<BytesLike>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • registerToken(uint256,bytes):function
    • registerToken(uint256,bytes)(assetType, assetInfo, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • assetType: PromiseOrValue<BigNumberish>
      • assetInfo: PromiseOrValue<BytesLike>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • registerToken(uint256,bytes,uint256):function
    • registerToken(uint256,bytes,uint256)(assetType, assetInfo, quantum, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • assetType: PromiseOrValue<BigNumberish>
      • assetInfo: PromiseOrValue<BytesLike>
      • quantum: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • registerTokenAdmin:function
    • registerTokenAdmin(newAdmin, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • newAdmin: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • registerVerifier:function
    • registerVerifier(verifier, identifier, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • verifier: PromiseOrValue<string>
      • identifier: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • removeAvailabilityVerifier:function
    • removeAvailabilityVerifier(verifier, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • verifier: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • removeVerifier:function
    • removeVerifier(verifier, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • verifier: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • setDefaultVaultWithdrawalLock:function
    • setDefaultVaultWithdrawalLock(newDefaultTime, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • newDefaultTime: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • unFreeze:function
    • unFreeze(overrides?): Promise<PopulatedTransaction>

    • Parameters

      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • unregisterOperator:function
    • unregisterOperator(removedOperator, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • removedOperator: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • unregisterTokenAdmin:function
    • unregisterTokenAdmin(oldAdmin, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • oldAdmin: PromiseOrValue<string>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • updateImplementationActivationTime:function
    • updateImplementationActivationTime(implementation, data, finalize, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • implementation: PromiseOrValue<string>
      • data: PromiseOrValue<BytesLike>
      • finalize: PromiseOrValue<boolean>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • updateState:function
    • updateState(publicInput, applicationData, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • publicInput: PromiseOrValue<BigNumberish>[]
      • applicationData: PromiseOrValue<BigNumberish>[]
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • withdraw:function
    • withdraw(ownerKey, assetType, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • ownerKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • withdrawAndMint:function
    • withdrawAndMint(ownerKey, assetType, mintingBlob, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • ownerKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • mintingBlob: PromiseOrValue<BytesLike>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • withdrawFromVault:function
    • withdrawFromVault(assetId, vaultId, quantizedAmount, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • assetId: PromiseOrValue<BigNumberish>
      • vaultId: PromiseOrValue<BigNumberish>
      • quantizedAmount: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

  • withdrawNft:function
    • withdrawNft(ownerKey, assetType, tokenId, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • ownerKey: PromiseOrValue<BigNumberish>
      • assetType: PromiseOrValue<BigNumberish>
      • tokenId: PromiseOrValue<BigNumberish>
      • Optional overrides: Overrides & {
            from?: PromiseOrValue<string>;
        }

      Returns Promise<PopulatedTransaction>

Readonly address

address: string

Readonly signer

signer: x.EthSigner

Readonly provider

provider: Provider

Readonly resolvedAddress

resolvedAddress: Promise<string>

Readonly deployTransaction

deployTransaction: x.TransactionResponse

_deployedPromise

_deployedPromise: Promise<Contract>

_runningEvents

_runningEvents: {
    [eventTag: string]: RunningEvent;
}

Type declaration

  • [eventTag: string]: RunningEvent

_wrappedEmits

_wrappedEmits: {
    [eventTag: string]: ((...args) => void);
}

Type declaration

  • [eventTag: string]: ((...args) => void)
      • (...args): void

      • Parameters

        • Rest ...args: any[]

        Returns void

Methods

connect

attach

deployed

queryFilter

  • Type Parameters

    • TEvent extends TypedEvent<any, any, TEvent>

    Parameters

    • event: TypedEventFilter<TEvent>
    • Optional fromBlockOrBlockhash: string | number
    • Optional toBlock: string | number

    Returns Promise<TEvent[]>

listeners

  • Type Parameters

    • TEvent extends TypedEvent<any, any, TEvent>

    Parameters

    • Optional eventFilter: TypedEventFilter<TEvent>

    Returns TypedListener<TEvent>[]

  • Parameters

    • Optional eventName: string

    Returns Listener[]

removeAllListeners

  • Type Parameters

    • TEvent extends TypedEvent<any, any, TEvent>

    Parameters

    • eventFilter: TypedEventFilter<TEvent>

    Returns x.Contracts.CoreV4Contract

  • Parameters

    • Optional eventName: string

    Returns x.Contracts.CoreV4Contract

DEPOSIT_CANCEL_DELAY

  • Parameters

    • Optional overrides: CallOverrides

    Returns Promise<BigNumber>

FREEZE_GRACE_PERIOD

  • Parameters

    • Optional overrides: CallOverrides

    Returns Promise<BigNumber>

MAIN_GOVERNANCE_INFO_TAG

  • Parameters

    • Optional overrides: CallOverrides

    Returns Promise<string>

MAX_FORCED_ACTIONS_REQS_PER_BLOCK

  • Parameters

    • Optional overrides: CallOverrides

    Returns Promise<BigNumber>

MAX_VERIFIER_COUNT

  • Parameters

    • Optional overrides: CallOverrides

    Returns Promise<BigNumber>

STARKEX_MAX_DEFAULT_VAULT_LOCK

  • Parameters

    • Optional overrides: CallOverrides

    Returns Promise<BigNumber>

UNFREEZE_DELAY

  • Parameters

    • Optional overrides: CallOverrides

    Returns Promise<BigNumber>

VERIFIER_REMOVAL_DELAY

  • Parameters

    • Optional overrides: CallOverrides

    Returns Promise<BigNumber>

VERSION

  • Parameters

    • Optional overrides: CallOverrides

    Returns Promise<string>

announceAvailabilityVerifierRemovalIntent

  • Parameters

    • verifier: PromiseOrValue<string>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

announceVerifierRemovalIntent

  • Parameters

    • verifier: PromiseOrValue<string>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

defaultVaultWithdrawalLock

  • Parameters

    • Optional overrides: CallOverrides

    Returns Promise<BigNumber>

deposit(uint256,uint256,uint256)

  • deposit(uint256,uint256,uint256)(starkKey, assetType, vaultId, overrides?): Promise<ContractTransaction>

  • Parameters

    • starkKey: PromiseOrValue<BigNumberish>
    • assetType: PromiseOrValue<BigNumberish>
    • vaultId: PromiseOrValue<BigNumberish>
    • Optional overrides: PayableOverrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

deposit(uint256,uint256,uint256,uint256)

  • deposit(uint256,uint256,uint256,uint256)(starkKey, assetType, vaultId, quantizedAmount, overrides?): Promise<ContractTransaction>

  • Parameters

    • starkKey: PromiseOrValue<BigNumberish>
    • assetType: PromiseOrValue<BigNumberish>
    • vaultId: PromiseOrValue<BigNumberish>
    • quantizedAmount: PromiseOrValue<BigNumberish>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

depositCancel

  • Parameters

    • starkKey: PromiseOrValue<BigNumberish>
    • assetId: PromiseOrValue<BigNumberish>
    • vaultId: PromiseOrValue<BigNumberish>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

depositERC20

  • Parameters

    • starkKey: PromiseOrValue<BigNumberish>
    • assetType: PromiseOrValue<BigNumberish>
    • vaultId: PromiseOrValue<BigNumberish>
    • quantizedAmount: PromiseOrValue<BigNumberish>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

depositERC20ToVault

  • Parameters

    • assetId: PromiseOrValue<BigNumberish>
    • vaultId: PromiseOrValue<BigNumberish>
    • quantizedAmount: PromiseOrValue<BigNumberish>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

depositEth

  • Parameters

    • starkKey: PromiseOrValue<BigNumberish>
    • assetType: PromiseOrValue<BigNumberish>
    • vaultId: PromiseOrValue<BigNumberish>
    • Optional overrides: PayableOverrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

depositEthToVault

  • Parameters

    • assetId: PromiseOrValue<BigNumberish>
    • vaultId: PromiseOrValue<BigNumberish>
    • Optional overrides: PayableOverrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

depositNft

  • Parameters

    • starkKey: PromiseOrValue<BigNumberish>
    • assetType: PromiseOrValue<BigNumberish>
    • vaultId: PromiseOrValue<BigNumberish>
    • tokenId: PromiseOrValue<BigNumberish>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

depositNftReclaim

  • Parameters

    • starkKey: PromiseOrValue<BigNumberish>
    • assetType: PromiseOrValue<BigNumberish>
    • vaultId: PromiseOrValue<BigNumberish>
    • tokenId: PromiseOrValue<BigNumberish>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

depositReclaim

  • Parameters

    • starkKey: PromiseOrValue<BigNumberish>
    • assetId: PromiseOrValue<BigNumberish>
    • vaultId: PromiseOrValue<BigNumberish>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

escape

  • Parameters

    • starkKey: PromiseOrValue<BigNumberish>
    • vaultId: PromiseOrValue<BigNumberish>
    • assetId: PromiseOrValue<BigNumberish>
    • quantizedAmount: PromiseOrValue<BigNumberish>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

freezeRequest

  • Parameters

    • starkKey: PromiseOrValue<BigNumberish>
    • vaultId: PromiseOrValue<BigNumberish>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

fullWithdrawalRequest

  • Parameters

    • starkKey: PromiseOrValue<BigNumberish>
    • vaultId: PromiseOrValue<BigNumberish>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

getActionCount

  • Parameters

    • Optional overrides: CallOverrides

    Returns Promise<BigNumber>

getActionHashByIndex

  • Parameters

    • actionIndex: PromiseOrValue<BigNumberish>
    • Optional overrides: CallOverrides

    Returns Promise<string>

getAssetInfo

  • Parameters

    • assetType: PromiseOrValue<BigNumberish>
    • Optional overrides: CallOverrides

    Returns Promise<string>

getCancellationRequest

  • Parameters

    • starkKey: PromiseOrValue<BigNumberish>
    • assetId: PromiseOrValue<BigNumberish>
    • vaultId: PromiseOrValue<BigNumberish>
    • Optional overrides: CallOverrides

    Returns Promise<BigNumber>

getDepositBalance

  • Parameters

    • starkKey: PromiseOrValue<BigNumberish>
    • assetId: PromiseOrValue<BigNumberish>
    • vaultId: PromiseOrValue<BigNumberish>
    • Optional overrides: CallOverrides

    Returns Promise<BigNumber>

getEthKey

  • Parameters

    • ownerKey: PromiseOrValue<BigNumberish>
    • Optional overrides: CallOverrides

    Returns Promise<string>

getFullWithdrawalRequest

  • Parameters

    • starkKey: PromiseOrValue<BigNumberish>
    • vaultId: PromiseOrValue<BigNumberish>
    • Optional overrides: CallOverrides

    Returns Promise<BigNumber>

getLastBatchId

  • Parameters

    • Optional overrides: CallOverrides

    Returns Promise<BigNumber>

getOrderRoot

  • Parameters

    • Optional overrides: CallOverrides

    Returns Promise<BigNumber>

getOrderTreeHeight

  • Parameters

    • Optional overrides: CallOverrides

    Returns Promise<BigNumber>

getQuantizedDepositBalance

  • Parameters

    • starkKey: PromiseOrValue<BigNumberish>
    • assetId: PromiseOrValue<BigNumberish>
    • vaultId: PromiseOrValue<BigNumberish>
    • Optional overrides: CallOverrides

    Returns Promise<BigNumber>

getQuantizedVaultBalance

  • Parameters

    • ethKey: PromiseOrValue<string>
    • assetId: PromiseOrValue<BigNumberish>
    • vaultId: PromiseOrValue<BigNumberish>
    • Optional overrides: CallOverrides

    Returns Promise<BigNumber>

getQuantum

  • Parameters

    • presumedAssetType: PromiseOrValue<BigNumberish>
    • Optional overrides: CallOverrides

    Returns Promise<BigNumber>

getRegisteredAvailabilityVerifiers

  • Parameters

    • Optional overrides: CallOverrides

    Returns Promise<string[]>

getRegisteredVerifiers

  • Parameters

    • Optional overrides: CallOverrides

    Returns Promise<string[]>

getSequenceNumber

  • Parameters

    • Optional overrides: CallOverrides

    Returns Promise<BigNumber>

getVaultBalance

  • Parameters

    • ethKey: PromiseOrValue<string>
    • assetId: PromiseOrValue<BigNumberish>
    • vaultId: PromiseOrValue<BigNumberish>
    • Optional overrides: CallOverrides

    Returns Promise<BigNumber>

getVaultRoot

  • Parameters

    • Optional overrides: CallOverrides

    Returns Promise<BigNumber>

getVaultTreeHeight

  • Parameters

    • Optional overrides: CallOverrides

    Returns Promise<BigNumber>

getVaultWithdrawalLock

  • Parameters

    • ethKey: PromiseOrValue<string>
    • assetId: PromiseOrValue<BigNumberish>
    • vaultId: PromiseOrValue<BigNumberish>
    • Optional overrides: CallOverrides

    Returns Promise<BigNumber>

getWithdrawalBalance

  • Parameters

    • ownerKey: PromiseOrValue<BigNumberish>
    • assetId: PromiseOrValue<BigNumberish>
    • Optional overrides: CallOverrides

    Returns Promise<BigNumber>

initialize

  • Parameters

    • data: PromiseOrValue<BytesLike>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

isAssetRegistered

  • Parameters

    • assetType: PromiseOrValue<BigNumberish>
    • Optional overrides: CallOverrides

    Returns Promise<boolean>

isAvailabilityVerifier

  • Parameters

    • verifierAddress: PromiseOrValue<string>
    • Optional overrides: CallOverrides

    Returns Promise<boolean>

isFrozen

  • Parameters

    • Optional overrides: CallOverrides

    Returns Promise<boolean>

isOperator

  • Parameters

    • testedOperator: PromiseOrValue<string>
    • Optional overrides: CallOverrides

    Returns Promise<boolean>

isStrictVaultBalancePolicy

  • Parameters

    • Optional overrides: CallOverrides

    Returns Promise<boolean>

isTokenAdmin

  • Parameters

    • testedAdmin: PromiseOrValue<string>
    • Optional overrides: CallOverrides

    Returns Promise<boolean>

isVaultLocked

  • Parameters

    • ethKey: PromiseOrValue<string>
    • assetId: PromiseOrValue<BigNumberish>
    • vaultId: PromiseOrValue<BigNumberish>
    • Optional overrides: CallOverrides

    Returns Promise<boolean>

isVerifier

  • Parameters

    • verifierAddress: PromiseOrValue<string>
    • Optional overrides: CallOverrides

    Returns Promise<boolean>

lockVault

  • Parameters

    • assetId: PromiseOrValue<BigNumberish>
    • vaultId: PromiseOrValue<BigNumberish>
    • lockTime: PromiseOrValue<BigNumberish>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

mainAcceptGovernance

  • Parameters

    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

mainCancelNomination

  • Parameters

    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

mainIsGovernor

  • Parameters

    • testGovernor: PromiseOrValue<string>
    • Optional overrides: CallOverrides

    Returns Promise<boolean>

mainNominateNewGovernor

  • Parameters

    • newGovernor: PromiseOrValue<string>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

mainRemoveGovernor

  • Parameters

    • governorForRemoval: PromiseOrValue<string>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

onERC721Received

  • Parameters

    • arg0: PromiseOrValue<string>
    • arg1: PromiseOrValue<string>
    • arg2: PromiseOrValue<BigNumberish>
    • arg3: PromiseOrValue<BytesLike>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

orderRegistryAddress

  • Parameters

    • Optional overrides: CallOverrides

    Returns Promise<string>

registerAndDepositERC20

  • Parameters

    • ethKey: PromiseOrValue<string>
    • starkKey: PromiseOrValue<BigNumberish>
    • signature: PromiseOrValue<BytesLike>
    • assetType: PromiseOrValue<BigNumberish>
    • vaultId: PromiseOrValue<BigNumberish>
    • quantizedAmount: PromiseOrValue<BigNumberish>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

registerAndDepositEth

  • Parameters

    • ethKey: PromiseOrValue<string>
    • starkKey: PromiseOrValue<BigNumberish>
    • signature: PromiseOrValue<BytesLike>
    • assetType: PromiseOrValue<BigNumberish>
    • vaultId: PromiseOrValue<BigNumberish>
    • Optional overrides: PayableOverrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

registerAvailabilityVerifier

  • Parameters

    • verifier: PromiseOrValue<string>
    • identifier: PromiseOrValue<string>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

registerEthAddress

  • Parameters

    • ethKey: PromiseOrValue<string>
    • starkKey: PromiseOrValue<BigNumberish>
    • starkSignature: PromiseOrValue<BytesLike>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

registerOperator

  • Parameters

    • newOperator: PromiseOrValue<string>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

registerSender

  • Parameters

    • starkKey: PromiseOrValue<BigNumberish>
    • starkSignature: PromiseOrValue<BytesLike>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

registerToken(uint256,bytes)

  • registerToken(uint256,bytes)(assetType, assetInfo, overrides?): Promise<ContractTransaction>

  • Parameters

    • assetType: PromiseOrValue<BigNumberish>
    • assetInfo: PromiseOrValue<BytesLike>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

registerToken(uint256,bytes,uint256)

  • registerToken(uint256,bytes,uint256)(assetType, assetInfo, quantum, overrides?): Promise<ContractTransaction>

  • Parameters

    • assetType: PromiseOrValue<BigNumberish>
    • assetInfo: PromiseOrValue<BytesLike>
    • quantum: PromiseOrValue<BigNumberish>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

registerTokenAdmin

  • Parameters

    • newAdmin: PromiseOrValue<string>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

registerVerifier

  • Parameters

    • verifier: PromiseOrValue<string>
    • identifier: PromiseOrValue<string>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

removeAvailabilityVerifier

  • Parameters

    • verifier: PromiseOrValue<string>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

removeVerifier

  • Parameters

    • verifier: PromiseOrValue<string>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

setDefaultVaultWithdrawalLock

  • Parameters

    • newDefaultTime: PromiseOrValue<BigNumberish>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

unFreeze

  • Parameters

    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

unregisterOperator

  • Parameters

    • removedOperator: PromiseOrValue<string>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

unregisterTokenAdmin

  • Parameters

    • oldAdmin: PromiseOrValue<string>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

updateImplementationActivationTime

  • Parameters

    • implementation: PromiseOrValue<string>
    • data: PromiseOrValue<BytesLike>
    • finalize: PromiseOrValue<boolean>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

updateState

  • Parameters

    • publicInput: PromiseOrValue<BigNumberish>[]
    • applicationData: PromiseOrValue<BigNumberish>[]
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

withdraw

  • Parameters

    • ownerKey: PromiseOrValue<BigNumberish>
    • assetType: PromiseOrValue<BigNumberish>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

withdrawAndMint

  • Parameters

    • ownerKey: PromiseOrValue<BigNumberish>
    • assetType: PromiseOrValue<BigNumberish>
    • mintingBlob: PromiseOrValue<BytesLike>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

withdrawFromVault

  • Parameters

    • assetId: PromiseOrValue<BigNumberish>
    • vaultId: PromiseOrValue<BigNumberish>
    • quantizedAmount: PromiseOrValue<BigNumberish>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

withdrawNft

  • Parameters

    • ownerKey: PromiseOrValue<BigNumberish>
    • assetType: PromiseOrValue<BigNumberish>
    • tokenId: PromiseOrValue<BigNumberish>
    • Optional overrides: Overrides & {
          from?: PromiseOrValue<string>;
      }

    Returns Promise<ContractTransaction>

_deployed

  • _deployed(blockTag?): Promise<Contract>

  • Parameters

    • Optional blockTag: BlockTag

    Returns Promise<Contract>

fallback

  • Parameters

    • Optional overrides: TransactionRequest

    Returns Promise<x.TransactionResponse>

_checkRunningEvents

  • _checkRunningEvents(runningEvent): void

  • Parameters

    • runningEvent: RunningEvent

    Returns void

_wrapEvent

  • _wrapEvent(runningEvent, log, listener): Event

  • Parameters

    • runningEvent: RunningEvent
    • log: Log
    • listener: Listener

    Returns Event

emit

  • Parameters

    • eventName: string | EventFilter
    • Rest ...args: any[]

    Returns boolean

listenerCount

  • Parameters

    • Optional eventName: string | EventFilter

    Returns number

Settings

Member Visibility

Theme

On This Page

Generated using TypeDoc