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<Contracts.CoreV4Contract>

on

on: OnEvent<Contracts.CoreV4Contract>

once

once: OnEvent<Contracts.CoreV4Contract>

removeListener

removeListener: OnEvent<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
  • FREEZE_GRACE_PERIOD:function
  • MAIN_GOVERNANCE_INFO_TAG:function
  • MAX_FORCED_ACTIONS_REQS_PER_BLOCK:function
  • MAX_VERIFIER_COUNT:function
  • STARKEX_MAX_DEFAULT_VAULT_LOCK:function
  • UNFREEZE_DELAY:function
  • VERIFIER_REMOVAL_DELAY:function
  • VERSION:function
  • 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
  • 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
  • getActionHashByIndex:function
  • 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
  • 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
  • getOrderRoot:function
  • getOrderTreeHeight:function
  • 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
  • getRegisteredVerifiers:function
  • getSequenceNumber:function
  • 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
  • getVaultTreeHeight:function
  • 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
  • isAssetRegistered:function
  • isAvailabilityVerifier:function
  • isFrozen:function
  • isOperator:function
  • isStrictVaultBalancePolicy:function
  • isTokenAdmin:function
  • 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
  • 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
  • mainCancelNomination:function
  • mainIsGovernor:function
  • 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
  • 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
  • setDefaultVaultWithdrawalLock:function
    • setDefaultVaultWithdrawalLock(newDefaultTime, overrides?): Promise<ContractTransaction>

    • Parameters

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

      Returns Promise<ContractTransaction>

  • unFreeze:function
  • 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
  • FREEZE_GRACE_PERIOD:function
  • MAIN_GOVERNANCE_INFO_TAG:function
  • MAX_FORCED_ACTIONS_REQS_PER_BLOCK:function
  • MAX_VERIFIER_COUNT:function
  • STARKEX_MAX_DEFAULT_VAULT_LOCK:function
  • UNFREEZE_DELAY:function
  • VERIFIER_REMOVAL_DELAY:function
  • VERSION:function
  • announceAvailabilityVerifierRemovalIntent:function
  • announceVerifierRemovalIntent:function
  • defaultVaultWithdrawalLock:function
  • 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
  • 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
  • fullWithdrawalRequest:function
  • getActionCount:function
  • getActionHashByIndex:function
  • getAssetInfo:function
  • 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
  • getFullWithdrawalRequest:function
    • getFullWithdrawalRequest(starkKey, vaultId, overrides?): Promise<BigNumber>

    • Parameters

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

      Returns Promise<BigNumber>

  • getLastBatchId:function
  • getOrderRoot:function
  • getOrderTreeHeight:function
  • 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
  • getRegisteredAvailabilityVerifiers:function
  • getRegisteredVerifiers:function
  • getSequenceNumber:function
  • 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
  • getVaultTreeHeight:function
  • 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
  • initialize:function
  • isAssetRegistered:function
  • isAvailabilityVerifier:function
  • isFrozen:function
  • isOperator:function
  • isStrictVaultBalancePolicy:function
  • isTokenAdmin:function
  • 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
  • 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
  • mainCancelNomination:function
  • mainIsGovernor:function
  • mainNominateNewGovernor:function
  • mainRemoveGovernor:function
  • 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
  • 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
  • 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
  • registerSender:function
  • registerToken(uint256,bytes):function
  • 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
  • registerVerifier:function
  • removeAvailabilityVerifier:function
  • removeVerifier:function
  • setDefaultVaultWithdrawalLock:function
  • unFreeze:function
  • unregisterOperator:function
  • unregisterTokenAdmin:function
  • 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
  • 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:function
  • 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:function
  • 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:function
  • LogFullWithdrawalRequest(uint256,uint256):function
  • LogFullWithdrawalRequest:function
  • 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:function
  • 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:function
  • 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:function
  • LogNominationCancelled():function
  • LogNominationCancelled:function
  • LogOperatorAdded(address):function
  • LogOperatorAdded:function
  • LogOperatorRemoved(address):function
  • LogOperatorRemoved:function
  • LogRegistered(address,string):function
  • LogRegistered:function
  • LogRemovalIntent(address,string):function
  • LogRemovalIntent:function
  • LogRemoved(address,string):function
  • LogRemoved:function
  • LogRemovedGovernor(address):function
  • LogRemovedGovernor:function
  • 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:function
  • LogTokenAdminAdded(address):function
  • LogTokenAdminAdded:function
  • LogTokenAdminRemoved(address):function
  • LogTokenAdminRemoved:function
  • 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
  • LogUnFrozen():function
  • LogUnFrozen:function
  • LogUserRegistered(address,uint256,address):function
  • LogUserRegistered:function
  • 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
  • FREEZE_GRACE_PERIOD:function
  • MAIN_GOVERNANCE_INFO_TAG:function
  • MAX_FORCED_ACTIONS_REQS_PER_BLOCK:function
  • MAX_VERIFIER_COUNT:function
  • STARKEX_MAX_DEFAULT_VAULT_LOCK:function
  • UNFREEZE_DELAY:function
  • VERIFIER_REMOVAL_DELAY:function
  • VERSION:function
  • announceAvailabilityVerifierRemovalIntent:function
    • announceAvailabilityVerifierRemovalIntent(verifier, overrides?): Promise<BigNumber>

    • Parameters

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

      Returns Promise<BigNumber>

  • announceVerifierRemovalIntent:function
  • defaultVaultWithdrawalLock:function
  • 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
  • getActionHashByIndex:function
  • getAssetInfo:function
  • 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
  • getFullWithdrawalRequest:function
    • getFullWithdrawalRequest(starkKey, vaultId, overrides?): Promise<BigNumber>

    • Parameters

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

      Returns Promise<BigNumber>

  • getLastBatchId:function
  • getOrderRoot:function
  • getOrderTreeHeight:function
  • 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
  • getRegisteredAvailabilityVerifiers:function
  • getRegisteredVerifiers:function
  • getSequenceNumber:function
  • 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
  • getVaultTreeHeight:function
  • 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
  • initialize:function
  • isAssetRegistered:function
  • isAvailabilityVerifier:function
  • isFrozen:function
  • isOperator:function
  • isStrictVaultBalancePolicy:function
  • isTokenAdmin:function
  • 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
  • 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
  • mainCancelNomination:function
  • mainIsGovernor:function
  • mainNominateNewGovernor:function
  • 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
  • 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
  • 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
  • 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
  • removeVerifier:function
  • setDefaultVaultWithdrawalLock:function
    • setDefaultVaultWithdrawalLock(newDefaultTime, overrides?): Promise<BigNumber>

    • Parameters

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

      Returns Promise<BigNumber>

  • unFreeze:function
  • unregisterOperator:function
  • unregisterTokenAdmin:function
  • 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
  • FREEZE_GRACE_PERIOD:function
  • MAIN_GOVERNANCE_INFO_TAG:function
  • MAX_FORCED_ACTIONS_REQS_PER_BLOCK:function
  • MAX_VERIFIER_COUNT:function
  • STARKEX_MAX_DEFAULT_VAULT_LOCK:function
  • UNFREEZE_DELAY:function
  • VERIFIER_REMOVAL_DELAY:function
  • VERSION:function
  • 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
  • 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
  • getActionHashByIndex:function
  • getAssetInfo:function
  • 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
  • getFullWithdrawalRequest:function
    • getFullWithdrawalRequest(starkKey, vaultId, overrides?): Promise<PopulatedTransaction>

    • Parameters

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

      Returns Promise<PopulatedTransaction>

  • getLastBatchId:function
  • getOrderRoot:function
  • getOrderTreeHeight:function
  • 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
  • getRegisteredAvailabilityVerifiers:function
  • getRegisteredVerifiers:function
  • getSequenceNumber:function
  • 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
  • getVaultTreeHeight:function
  • 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
  • isAssetRegistered:function
  • isAvailabilityVerifier:function
  • isFrozen:function
  • isOperator:function
  • isStrictVaultBalancePolicy:function
  • isTokenAdmin:function
  • 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
  • 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
  • mainCancelNomination:function
  • mainIsGovernor:function
  • 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
  • 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
  • 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: EthSigner

Readonly provider

provider: Provider

Readonly resolvedAddress

resolvedAddress: Promise<string>

Readonly deployTransaction

deployTransaction: 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

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

  • 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

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

getActionHashByIndex

getAssetInfo

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

getFullWithdrawalRequest

  • Parameters

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

    Returns Promise<BigNumber>

getLastBatchId

getOrderRoot

getOrderTreeHeight

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

getRegisteredAvailabilityVerifiers

getRegisteredVerifiers

getSequenceNumber

getVaultBalance

  • Parameters

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

    Returns Promise<BigNumber>

getVaultRoot

getVaultTreeHeight

getVaultWithdrawalLock

  • Parameters

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

    Returns Promise<BigNumber>

getWithdrawalBalance

initialize

isAssetRegistered

isAvailabilityVerifier

isFrozen

isOperator

isStrictVaultBalancePolicy

isTokenAdmin

isVaultLocked

  • Parameters

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

    Returns Promise<boolean>

isVerifier

lockVault

  • Parameters

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

    Returns Promise<ContractTransaction>

mainAcceptGovernance

mainCancelNomination

mainIsGovernor

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

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

setDefaultVaultWithdrawalLock

  • Parameters

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

    Returns Promise<ContractTransaction>

unFreeze

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<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