Class Erdstall

Hierarchy

  • BaseContract
    • Erdstall

Constructors

constructor

Properties

_deployedPromise _runningEvents _wrappedEmits address callStatic deployTransaction estimateGas filters functions interface populateTransaction provider resolvedAddress signer

Methods

_checkRunningEvents _deployed _wrapEvent attach bigBang challenge challengeDeposit challenges connect deployed deposit deposits emit encodeBalanceProof ensureFrozen epochDuration fallback frozenEpoch listenerCount listeners numChallenges off on once owner queryFilter registerToken registerTokenType removeAllListeners removeListener renounceOwnership respondChallenge tee tokenHolders tokenTypes transferOwnership verifyBalance withdraw withdrawFrozen withdrawFrozenDeposit withdrawn getContractAddress getInterface isIndexed

Constructors

constructor

  • Parameters

    • addressOrName: string
    • contractInterface: ContractInterface
    • Optional signerOrProvider: Signer | Provider

    Returns Erdstall

Properties

_deployedPromise

_deployedPromise: Promise<Contract>

_runningEvents

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

Type declaration

  • [eventTag: string]: RunningEvent

_wrappedEmits

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

Type declaration

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

      • Parameters

        • Rest ...args: any[]

        Returns void

Readonly address

address: string

callStatic

callStatic: {
    bigBang(overrides?: CallOverrides): Promise<BigNumber>;
    challenge(balance: {
        account: string;
        epoch: BigNumberish;
        exit: boolean;
        tokens: {
            token: string;
            value: BytesLike;
        }[];
    }, sig: BytesLike, overrides?: CallOverrides): Promise<void>;
    challengeDeposit(overrides?: CallOverrides): Promise<void>;
    challenges(arg0: BigNumberish, arg1: string, overrides?: CallOverrides): Promise<boolean>;
    deposit(depositor: string, token: string, value: BytesLike, overrides?: CallOverrides): Promise<void>;
    deposits(arg0: BigNumberish, arg1: string, arg2: BigNumberish, overrides?: CallOverrides): Promise<[string, string] & {
        token: string;
        value: string;
    }>;
    encodeBalanceProof(balance: {
        account: string;
        epoch: BigNumberish;
        exit: boolean;
        tokens: {
            token: string;
            value: BytesLike;
        }[];
    }, overrides?: CallOverrides): Promise<string>;
    ensureFrozen(overrides?: CallOverrides): Promise<void>;
    epochDuration(overrides?: CallOverrides): Promise<BigNumber>;
    frozenEpoch(overrides?: CallOverrides): Promise<BigNumber>;
    numChallenges(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
    owner(overrides?: CallOverrides): Promise<string>;
    registerToken(token: string, holder: string, overrides?: CallOverrides): Promise<void>;
    registerTokenType(holder: string, tokenType: string, overrides?: CallOverrides): Promise<void>;
    renounceOwnership(overrides?: CallOverrides): Promise<void>;
    respondChallenge(balance: {
        account: string;
        epoch: BigNumberish;
        exit: boolean;
        tokens: {
            token: string;
            value: BytesLike;
        }[];
    }, sig: BytesLike, overrides?: CallOverrides): Promise<void>;
    tee(overrides?: CallOverrides): Promise<string>;
    tokenHolders(arg0: string, overrides?: CallOverrides): Promise<string>;
    tokenTypes(arg0: string, overrides?: CallOverrides): Promise<string>;
    transferOwnership(newOwner: string, overrides?: CallOverrides): Promise<void>;
    verifyBalance(balance: {
        account: string;
        epoch: BigNumberish;
        exit: boolean;
        tokens: {
            token: string;
            value: BytesLike;
        }[];
    }, sig: BytesLike, overrides?: CallOverrides): Promise<void>;
    withdraw(balance: {
        account: string;
        epoch: BigNumberish;
        exit: boolean;
        tokens: {
            token: string;
            value: BytesLike;
        }[];
    }, sig: BytesLike, overrides?: CallOverrides): Promise<void>;
    withdrawFrozen(balance: {
        account: string;
        epoch: BigNumberish;
        exit: boolean;
        tokens: {
            token: string;
            value: BytesLike;
        }[];
    }, sig: BytesLike, overrides?: CallOverrides): Promise<void>;
    withdrawFrozenDeposit(overrides?: CallOverrides): Promise<void>;
    withdrawn(arg0: BigNumberish, arg1: string, overrides?: CallOverrides): Promise<boolean>;
}

Type declaration

  • bigBang:function
  • challenge:function
    • challenge(balance: {
          account: string;
          epoch: BigNumberish;
          exit: boolean;
          tokens: {
              token: string;
              value: BytesLike;
          }[];
      }, sig: BytesLike, overrides?: CallOverrides): Promise<void>

    • Parameters

      • balance: {
            account: string;
            epoch: BigNumberish;
            exit: boolean;
            tokens: {
                token: string;
                value: BytesLike;
            }[];
        }
        • account: string
        • epoch: BigNumberish
        • exit: boolean
        • tokens: {
              token: string;
              value: BytesLike;
          }[]
      • sig: BytesLike
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • challengeDeposit:function
  • challenges:function
    • challenges(arg0: BigNumberish, arg1: string, overrides?: CallOverrides): Promise<boolean>

    • Parameters

      • arg0: BigNumberish
      • arg1: string
      • Optional overrides: CallOverrides

      Returns Promise<boolean>

  • deposit:function
    • deposit(depositor: string, token: string, value: BytesLike, overrides?: CallOverrides): Promise<void>

    • Parameters

      • depositor: string
      • token: string
      • value: BytesLike
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • deposits:function
    • deposits(arg0: BigNumberish, arg1: string, arg2: BigNumberish, overrides?: CallOverrides): Promise<[string, string] & {
          token: string;
          value: string;
      }>

    • Parameters

      • arg0: BigNumberish
      • arg1: string
      • arg2: BigNumberish
      • Optional overrides: CallOverrides

      Returns Promise<[string, string] & {
          token: string;
          value: string;
      }>

  • encodeBalanceProof:function
    • encodeBalanceProof(balance: {
          account: string;
          epoch: BigNumberish;
          exit: boolean;
          tokens: {
              token: string;
              value: BytesLike;
          }[];
      }, overrides?: CallOverrides): Promise<string>

    • Parameters

      • balance: {
            account: string;
            epoch: BigNumberish;
            exit: boolean;
            tokens: {
                token: string;
                value: BytesLike;
            }[];
        }
        • account: string
        • epoch: BigNumberish
        • exit: boolean
        • tokens: {
              token: string;
              value: BytesLike;
          }[]
      • Optional overrides: CallOverrides

      Returns Promise<string>

  • ensureFrozen:function
  • epochDuration:function
  • frozenEpoch:function
  • numChallenges:function
    • numChallenges(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>

    • Parameters

      • arg0: BigNumberish
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • owner:function
  • registerToken:function
    • registerToken(token: string, holder: string, overrides?: CallOverrides): Promise<void>

    • Parameters

      • token: string
      • holder: string
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • registerTokenType:function
    • registerTokenType(holder: string, tokenType: string, overrides?: CallOverrides): Promise<void>

    • Parameters

      • holder: string
      • tokenType: string
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • renounceOwnership:function
  • respondChallenge:function
    • respondChallenge(balance: {
          account: string;
          epoch: BigNumberish;
          exit: boolean;
          tokens: {
              token: string;
              value: BytesLike;
          }[];
      }, sig: BytesLike, overrides?: CallOverrides): Promise<void>

    • Parameters

      • balance: {
            account: string;
            epoch: BigNumberish;
            exit: boolean;
            tokens: {
                token: string;
                value: BytesLike;
            }[];
        }
        • account: string
        • epoch: BigNumberish
        • exit: boolean
        • tokens: {
              token: string;
              value: BytesLike;
          }[]
      • sig: BytesLike
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • tee:function
  • tokenHolders:function
  • tokenTypes:function
  • transferOwnership:function
  • verifyBalance:function
    • verifyBalance(balance: {
          account: string;
          epoch: BigNumberish;
          exit: boolean;
          tokens: {
              token: string;
              value: BytesLike;
          }[];
      }, sig: BytesLike, overrides?: CallOverrides): Promise<void>

    • Parameters

      • balance: {
            account: string;
            epoch: BigNumberish;
            exit: boolean;
            tokens: {
                token: string;
                value: BytesLike;
            }[];
        }
        • account: string
        • epoch: BigNumberish
        • exit: boolean
        • tokens: {
              token: string;
              value: BytesLike;
          }[]
      • sig: BytesLike
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • withdraw:function
    • withdraw(balance: {
          account: string;
          epoch: BigNumberish;
          exit: boolean;
          tokens: {
              token: string;
              value: BytesLike;
          }[];
      }, sig: BytesLike, overrides?: CallOverrides): Promise<void>

    • Parameters

      • balance: {
            account: string;
            epoch: BigNumberish;
            exit: boolean;
            tokens: {
                token: string;
                value: BytesLike;
            }[];
        }
        • account: string
        • epoch: BigNumberish
        • exit: boolean
        • tokens: {
              token: string;
              value: BytesLike;
          }[]
      • sig: BytesLike
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • withdrawFrozen:function
    • withdrawFrozen(balance: {
          account: string;
          epoch: BigNumberish;
          exit: boolean;
          tokens: {
              token: string;
              value: BytesLike;
          }[];
      }, sig: BytesLike, overrides?: CallOverrides): Promise<void>

    • Parameters

      • balance: {
            account: string;
            epoch: BigNumberish;
            exit: boolean;
            tokens: {
                token: string;
                value: BytesLike;
            }[];
        }
        • account: string
        • epoch: BigNumberish
        • exit: boolean
        • tokens: {
              token: string;
              value: BytesLike;
          }[]
      • sig: BytesLike
      • Optional overrides: CallOverrides

      Returns Promise<void>

  • withdrawFrozenDeposit:function
  • withdrawn:function
    • withdrawn(arg0: BigNumberish, arg1: string, overrides?: CallOverrides): Promise<boolean>

    • Parameters

      • arg0: BigNumberish
      • arg1: string
      • Optional overrides: CallOverrides

      Returns Promise<boolean>

Readonly deployTransaction

deployTransaction: TransactionResponse

estimateGas

estimateGas: {
    bigBang(overrides?: CallOverrides): Promise<BigNumber>;
    challenge(balance: {
        account: string;
        epoch: BigNumberish;
        exit: boolean;
        tokens: {
            token: string;
            value: BytesLike;
        }[];
    }, sig: BytesLike, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<BigNumber>;
    challengeDeposit(overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<BigNumber>;
    challenges(arg0: BigNumberish, arg1: string, overrides?: CallOverrides): Promise<BigNumber>;
    deposit(depositor: string, token: string, value: BytesLike, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<BigNumber>;
    deposits(arg0: BigNumberish, arg1: string, arg2: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
    encodeBalanceProof(balance: {
        account: string;
        epoch: BigNumberish;
        exit: boolean;
        tokens: {
            token: string;
            value: BytesLike;
        }[];
    }, overrides?: CallOverrides): Promise<BigNumber>;
    ensureFrozen(overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<BigNumber>;
    epochDuration(overrides?: CallOverrides): Promise<BigNumber>;
    frozenEpoch(overrides?: CallOverrides): Promise<BigNumber>;
    numChallenges(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
    owner(overrides?: CallOverrides): Promise<BigNumber>;
    registerToken(token: string, holder: string, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<BigNumber>;
    registerTokenType(holder: string, tokenType: string, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<BigNumber>;
    renounceOwnership(overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<BigNumber>;
    respondChallenge(balance: {
        account: string;
        epoch: BigNumberish;
        exit: boolean;
        tokens: {
            token: string;
            value: BytesLike;
        }[];
    }, sig: BytesLike, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<BigNumber>;
    tee(overrides?: CallOverrides): Promise<BigNumber>;
    tokenHolders(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
    tokenTypes(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
    transferOwnership(newOwner: string, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<BigNumber>;
    verifyBalance(balance: {
        account: string;
        epoch: BigNumberish;
        exit: boolean;
        tokens: {
            token: string;
            value: BytesLike;
        }[];
    }, sig: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
    withdraw(balance: {
        account: string;
        epoch: BigNumberish;
        exit: boolean;
        tokens: {
            token: string;
            value: BytesLike;
        }[];
    }, sig: BytesLike, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<BigNumber>;
    withdrawFrozen(balance: {
        account: string;
        epoch: BigNumberish;
        exit: boolean;
        tokens: {
            token: string;
            value: BytesLike;
        }[];
    }, sig: BytesLike, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<BigNumber>;
    withdrawFrozenDeposit(overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<BigNumber>;
    withdrawn(arg0: BigNumberish, arg1: string, overrides?: CallOverrides): Promise<BigNumber>;
}

Type declaration

  • bigBang:function
  • challenge:function
    • challenge(balance: {
          account: string;
          epoch: BigNumberish;
          exit: boolean;
          tokens: {
              token: string;
              value: BytesLike;
          }[];
      }, sig: BytesLike, overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<BigNumber>

    • Parameters

      • balance: {
            account: string;
            epoch: BigNumberish;
            exit: boolean;
            tokens: {
                token: string;
                value: BytesLike;
            }[];
        }
        • account: string
        • epoch: BigNumberish
        • exit: boolean
        • tokens: {
              token: string;
              value: BytesLike;
          }[]
      • sig: BytesLike
      • Optional overrides: Overrides & {
            from?: string | Promise<string>;
        }

      Returns Promise<BigNumber>

  • challengeDeposit:function
    • challengeDeposit(overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<BigNumber>

    • Parameters

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

      Returns Promise<BigNumber>

  • challenges:function
    • challenges(arg0: BigNumberish, arg1: string, overrides?: CallOverrides): Promise<BigNumber>

    • Parameters

      • arg0: BigNumberish
      • arg1: string
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • deposit:function
    • deposit(depositor: string, token: string, value: BytesLike, overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<BigNumber>

    • Parameters

      • depositor: string
      • token: string
      • value: BytesLike
      • Optional overrides: Overrides & {
            from?: string | Promise<string>;
        }

      Returns Promise<BigNumber>

  • deposits:function
    • deposits(arg0: BigNumberish, arg1: string, arg2: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>

    • Parameters

      • arg0: BigNumberish
      • arg1: string
      • arg2: BigNumberish
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • encodeBalanceProof:function
    • encodeBalanceProof(balance: {
          account: string;
          epoch: BigNumberish;
          exit: boolean;
          tokens: {
              token: string;
              value: BytesLike;
          }[];
      }, overrides?: CallOverrides): Promise<BigNumber>

    • Parameters

      • balance: {
            account: string;
            epoch: BigNumberish;
            exit: boolean;
            tokens: {
                token: string;
                value: BytesLike;
            }[];
        }
        • account: string
        • epoch: BigNumberish
        • exit: boolean
        • tokens: {
              token: string;
              value: BytesLike;
          }[]
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • ensureFrozen:function
    • ensureFrozen(overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<BigNumber>

    • Parameters

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

      Returns Promise<BigNumber>

  • epochDuration:function
  • frozenEpoch:function
  • numChallenges:function
    • numChallenges(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>

    • Parameters

      • arg0: BigNumberish
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • owner:function
  • registerToken:function
    • registerToken(token: string, holder: string, overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<BigNumber>

    • Parameters

      • token: string
      • holder: string
      • Optional overrides: Overrides & {
            from?: string | Promise<string>;
        }

      Returns Promise<BigNumber>

  • registerTokenType:function
    • registerTokenType(holder: string, tokenType: string, overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<BigNumber>

    • Parameters

      • holder: string
      • tokenType: string
      • Optional overrides: Overrides & {
            from?: string | Promise<string>;
        }

      Returns Promise<BigNumber>

  • renounceOwnership:function
    • renounceOwnership(overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<BigNumber>

    • Parameters

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

      Returns Promise<BigNumber>

  • respondChallenge:function
    • respondChallenge(balance: {
          account: string;
          epoch: BigNumberish;
          exit: boolean;
          tokens: {
              token: string;
              value: BytesLike;
          }[];
      }, sig: BytesLike, overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<BigNumber>

    • Parameters

      • balance: {
            account: string;
            epoch: BigNumberish;
            exit: boolean;
            tokens: {
                token: string;
                value: BytesLike;
            }[];
        }
        • account: string
        • epoch: BigNumberish
        • exit: boolean
        • tokens: {
              token: string;
              value: BytesLike;
          }[]
      • sig: BytesLike
      • Optional overrides: Overrides & {
            from?: string | Promise<string>;
        }

      Returns Promise<BigNumber>

  • tee:function
  • tokenHolders:function
  • tokenTypes:function
  • transferOwnership:function
    • transferOwnership(newOwner: string, overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<BigNumber>

    • Parameters

      • newOwner: string
      • Optional overrides: Overrides & {
            from?: string | Promise<string>;
        }

      Returns Promise<BigNumber>

  • verifyBalance:function
    • verifyBalance(balance: {
          account: string;
          epoch: BigNumberish;
          exit: boolean;
          tokens: {
              token: string;
              value: BytesLike;
          }[];
      }, sig: BytesLike, overrides?: CallOverrides): Promise<BigNumber>

    • Parameters

      • balance: {
            account: string;
            epoch: BigNumberish;
            exit: boolean;
            tokens: {
                token: string;
                value: BytesLike;
            }[];
        }
        • account: string
        • epoch: BigNumberish
        • exit: boolean
        • tokens: {
              token: string;
              value: BytesLike;
          }[]
      • sig: BytesLike
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • withdraw:function
    • withdraw(balance: {
          account: string;
          epoch: BigNumberish;
          exit: boolean;
          tokens: {
              token: string;
              value: BytesLike;
          }[];
      }, sig: BytesLike, overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<BigNumber>

    • Parameters

      • balance: {
            account: string;
            epoch: BigNumberish;
            exit: boolean;
            tokens: {
                token: string;
                value: BytesLike;
            }[];
        }
        • account: string
        • epoch: BigNumberish
        • exit: boolean
        • tokens: {
              token: string;
              value: BytesLike;
          }[]
      • sig: BytesLike
      • Optional overrides: Overrides & {
            from?: string | Promise<string>;
        }

      Returns Promise<BigNumber>

  • withdrawFrozen:function
    • withdrawFrozen(balance: {
          account: string;
          epoch: BigNumberish;
          exit: boolean;
          tokens: {
              token: string;
              value: BytesLike;
          }[];
      }, sig: BytesLike, overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<BigNumber>

    • Parameters

      • balance: {
            account: string;
            epoch: BigNumberish;
            exit: boolean;
            tokens: {
                token: string;
                value: BytesLike;
            }[];
        }
        • account: string
        • epoch: BigNumberish
        • exit: boolean
        • tokens: {
              token: string;
              value: BytesLike;
          }[]
      • sig: BytesLike
      • Optional overrides: Overrides & {
            from?: string | Promise<string>;
        }

      Returns Promise<BigNumber>

  • withdrawFrozenDeposit:function
    • withdrawFrozenDeposit(overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<BigNumber>

    • Parameters

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

      Returns Promise<BigNumber>

  • withdrawn:function
    • withdrawn(arg0: BigNumberish, arg1: string, overrides?: CallOverrides): Promise<BigNumber>

    • Parameters

      • arg0: BigNumberish
      • arg1: string
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

filters

filters: {
    ChallengeResponded(epoch?: null | BigNumberish, account?: null | string, tokens?: null, sig?: null): TypedEventFilter<[BigNumber, string, ([string, string] & {
        token: string;
        value: string;
    })[], string], {
        account: string;
        epoch: BigNumber;
        sig: string;
        tokens: ([string, string] & {
            token: string;
            value: string;
        })[];
    }>;
    Challenged(epoch?: null | BigNumberish, account?: null | string): TypedEventFilter<[BigNumber, string], {
        account: string;
        epoch: BigNumber;
    }>;
    Deposited(epoch?: null | BigNumberish, account?: null | string, token?: null, value?: null): TypedEventFilter<[BigNumber, string, string, string], {
        account: string;
        epoch: BigNumber;
        token: string;
        value: string;
    }>;
    Frozen(epoch?: null | BigNumberish): TypedEventFilter<[BigNumber], {
        epoch: BigNumber;
    }>;
    OwnershipTransferred(previousOwner?: null | string, newOwner?: null | string): TypedEventFilter<[string, string], {
        newOwner: string;
        previousOwner: string;
    }>;
    TokenRegistered(token?: null | string, tokenType?: null, tokenHolder?: null): TypedEventFilter<[string, string, string], {
        token: string;
        tokenHolder: string;
        tokenType: string;
    }>;
    TokenTypeRegistered(tokenType?: null, tokenHolder?: null): TypedEventFilter<[string, string], {
        tokenHolder: string;
        tokenType: string;
    }>;
    WithdrawalException(epoch?: null | BigNumberish, account?: null | string, token?: null | string, value?: null, error?: null): TypedEventFilter<[BigNumber, string, string, string, string], {
        account: string;
        epoch: BigNumber;
        error: string;
        token: string;
        value: string;
    }>;
    Withdrawn(epoch?: null | BigNumberish, account?: null | string, tokens?: null): TypedEventFilter<[BigNumber, string, ([string, string] & {
        token: string;
        value: string;
    })[]], {
        account: string;
        epoch: BigNumber;
        tokens: ([string, string] & {
            token: string;
            value: string;
        })[];
    }>;
}

Type declaration

  • ChallengeResponded:function
    • ChallengeResponded(epoch?: null | BigNumberish, account?: null | string, tokens?: null, sig?: null): TypedEventFilter<[BigNumber, string, ([string, string] & {
          token: string;
          value: string;
      })[], string], {
          account: string;
          epoch: BigNumber;
          sig: string;
          tokens: ([string, string] & {
              token: string;
              value: string;
          })[];
      }>

    • Parameters

      • Optional epoch: null | BigNumberish
      • Optional account: null | string
      • Optional tokens: null
      • Optional sig: null

      Returns TypedEventFilter<[BigNumber, string, ([string, string] & {
          token: string;
          value: string;
      })[], string], {
          account: string;
          epoch: BigNumber;
          sig: string;
          tokens: ([string, string] & {
              token: string;
              value: string;
          })[];
      }>

  • Challenged:function
    • Challenged(epoch?: null | BigNumberish, account?: null | string): TypedEventFilter<[BigNumber, string], {
          account: string;
          epoch: BigNumber;
      }>

    • Parameters

      • Optional epoch: null | BigNumberish
      • Optional account: null | string

      Returns TypedEventFilter<[BigNumber, string], {
          account: string;
          epoch: BigNumber;
      }>

  • Deposited:function
    • Deposited(epoch?: null | BigNumberish, account?: null | string, token?: null, value?: null): TypedEventFilter<[BigNumber, string, string, string], {
          account: string;
          epoch: BigNumber;
          token: string;
          value: string;
      }>

    • Parameters

      • Optional epoch: null | BigNumberish
      • Optional account: null | string
      • Optional token: null
      • Optional value: null

      Returns TypedEventFilter<[BigNumber, string, string, string], {
          account: string;
          epoch: BigNumber;
          token: string;
          value: string;
      }>

  • Frozen:function
    • Frozen(epoch?: null | BigNumberish): TypedEventFilter<[BigNumber], {
          epoch: BigNumber;
      }>

    • Parameters

      • Optional epoch: null | BigNumberish

      Returns TypedEventFilter<[BigNumber], {
          epoch: BigNumber;
      }>

  • OwnershipTransferred:function
    • OwnershipTransferred(previousOwner?: null | string, newOwner?: null | string): TypedEventFilter<[string, string], {
          newOwner: string;
          previousOwner: string;
      }>

    • Parameters

      • Optional previousOwner: null | string
      • Optional newOwner: null | string

      Returns TypedEventFilter<[string, string], {
          newOwner: string;
          previousOwner: string;
      }>

  • TokenRegistered:function
    • TokenRegistered(token?: null | string, tokenType?: null, tokenHolder?: null): TypedEventFilter<[string, string, string], {
          token: string;
          tokenHolder: string;
          tokenType: string;
      }>

    • Parameters

      • Optional token: null | string
      • Optional tokenType: null
      • Optional tokenHolder: null

      Returns TypedEventFilter<[string, string, string], {
          token: string;
          tokenHolder: string;
          tokenType: string;
      }>

  • TokenTypeRegistered:function
    • TokenTypeRegistered(tokenType?: null, tokenHolder?: null): TypedEventFilter<[string, string], {
          tokenHolder: string;
          tokenType: string;
      }>

    • Parameters

      • Optional tokenType: null
      • Optional tokenHolder: null

      Returns TypedEventFilter<[string, string], {
          tokenHolder: string;
          tokenType: string;
      }>

  • WithdrawalException:function
    • WithdrawalException(epoch?: null | BigNumberish, account?: null | string, token?: null | string, value?: null, error?: null): TypedEventFilter<[BigNumber, string, string, string, string], {
          account: string;
          epoch: BigNumber;
          error: string;
          token: string;
          value: string;
      }>

    • Parameters

      • Optional epoch: null | BigNumberish
      • Optional account: null | string
      • Optional token: null | string
      • Optional value: null
      • Optional error: null

      Returns TypedEventFilter<[BigNumber, string, string, string, string], {
          account: string;
          epoch: BigNumber;
          error: string;
          token: string;
          value: string;
      }>

  • Withdrawn:function
    • Withdrawn(epoch?: null | BigNumberish, account?: null | string, tokens?: null): TypedEventFilter<[BigNumber, string, ([string, string] & {
          token: string;
          value: string;
      })[]], {
          account: string;
          epoch: BigNumber;
          tokens: ([string, string] & {
              token: string;
              value: string;
          })[];
      }>

    • Parameters

      • Optional epoch: null | BigNumberish
      • Optional account: null | string
      • Optional tokens: null

      Returns TypedEventFilter<[BigNumber, string, ([string, string] & {
          token: string;
          value: string;
      })[]], {
          account: string;
          epoch: BigNumber;
          tokens: ([string, string] & {
              token: string;
              value: string;
          })[];
      }>

functions

functions: {
    bigBang(overrides?: CallOverrides): Promise<[BigNumber]>;
    challenge(balance: {
        account: string;
        epoch: BigNumberish;
        exit: boolean;
        tokens: {
            token: string;
            value: BytesLike;
        }[];
    }, sig: BytesLike, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    challengeDeposit(overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    challenges(arg0: BigNumberish, arg1: string, overrides?: CallOverrides): Promise<[boolean]>;
    deposit(depositor: string, token: string, value: BytesLike, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    deposits(arg0: BigNumberish, arg1: string, arg2: BigNumberish, overrides?: CallOverrides): Promise<[string, string] & {
        token: string;
        value: string;
    }>;
    encodeBalanceProof(balance: {
        account: string;
        epoch: BigNumberish;
        exit: boolean;
        tokens: {
            token: string;
            value: BytesLike;
        }[];
    }, overrides?: CallOverrides): Promise<[string]>;
    ensureFrozen(overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    epochDuration(overrides?: CallOverrides): Promise<[BigNumber]>;
    frozenEpoch(overrides?: CallOverrides): Promise<[BigNumber]>;
    numChallenges(arg0: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber]>;
    owner(overrides?: CallOverrides): Promise<[string]>;
    registerToken(token: string, holder: string, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    registerTokenType(holder: string, tokenType: string, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    renounceOwnership(overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    respondChallenge(balance: {
        account: string;
        epoch: BigNumberish;
        exit: boolean;
        tokens: {
            token: string;
            value: BytesLike;
        }[];
    }, sig: BytesLike, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    tee(overrides?: CallOverrides): Promise<[string]>;
    tokenHolders(arg0: string, overrides?: CallOverrides): Promise<[string]>;
    tokenTypes(arg0: string, overrides?: CallOverrides): Promise<[string]>;
    transferOwnership(newOwner: string, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    verifyBalance(balance: {
        account: string;
        epoch: BigNumberish;
        exit: boolean;
        tokens: {
            token: string;
            value: BytesLike;
        }[];
    }, sig: BytesLike, overrides?: CallOverrides): Promise<[void]>;
    withdraw(balance: {
        account: string;
        epoch: BigNumberish;
        exit: boolean;
        tokens: {
            token: string;
            value: BytesLike;
        }[];
    }, sig: BytesLike, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    withdrawFrozen(balance: {
        account: string;
        epoch: BigNumberish;
        exit: boolean;
        tokens: {
            token: string;
            value: BytesLike;
        }[];
    }, sig: BytesLike, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    withdrawFrozenDeposit(overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    withdrawn(arg0: BigNumberish, arg1: string, overrides?: CallOverrides): Promise<[boolean]>;
}

Type declaration

  • bigBang:function
  • challenge:function
    • challenge(balance: {
          account: string;
          epoch: BigNumberish;
          exit: boolean;
          tokens: {
              token: string;
              value: BytesLike;
          }[];
      }, sig: BytesLike, overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<ContractTransaction>

    • Parameters

      • balance: {
            account: string;
            epoch: BigNumberish;
            exit: boolean;
            tokens: {
                token: string;
                value: BytesLike;
            }[];
        }
        • account: string
        • epoch: BigNumberish
        • exit: boolean
        • tokens: {
              token: string;
              value: BytesLike;
          }[]
      • sig: BytesLike
      • Optional overrides: Overrides & {
            from?: string | Promise<string>;
        }

      Returns Promise<ContractTransaction>

  • challengeDeposit:function
    • challengeDeposit(overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<ContractTransaction>

    • Parameters

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

      Returns Promise<ContractTransaction>

  • challenges:function
    • challenges(arg0: BigNumberish, arg1: string, overrides?: CallOverrides): Promise<[boolean]>

    • Parameters

      • arg0: BigNumberish
      • arg1: string
      • Optional overrides: CallOverrides

      Returns Promise<[boolean]>

  • deposit:function
    • deposit(depositor: string, token: string, value: BytesLike, overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<ContractTransaction>

    • Parameters

      • depositor: string
      • token: string
      • value: BytesLike
      • Optional overrides: Overrides & {
            from?: string | Promise<string>;
        }

      Returns Promise<ContractTransaction>

  • deposits:function
    • deposits(arg0: BigNumberish, arg1: string, arg2: BigNumberish, overrides?: CallOverrides): Promise<[string, string] & {
          token: string;
          value: string;
      }>

    • Parameters

      • arg0: BigNumberish
      • arg1: string
      • arg2: BigNumberish
      • Optional overrides: CallOverrides

      Returns Promise<[string, string] & {
          token: string;
          value: string;
      }>

  • encodeBalanceProof:function
    • encodeBalanceProof(balance: {
          account: string;
          epoch: BigNumberish;
          exit: boolean;
          tokens: {
              token: string;
              value: BytesLike;
          }[];
      }, overrides?: CallOverrides): Promise<[string]>

    • Parameters

      • balance: {
            account: string;
            epoch: BigNumberish;
            exit: boolean;
            tokens: {
                token: string;
                value: BytesLike;
            }[];
        }
        • account: string
        • epoch: BigNumberish
        • exit: boolean
        • tokens: {
              token: string;
              value: BytesLike;
          }[]
      • Optional overrides: CallOverrides

      Returns Promise<[string]>

  • ensureFrozen:function
    • ensureFrozen(overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<ContractTransaction>

    • Parameters

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

      Returns Promise<ContractTransaction>

  • epochDuration:function
  • frozenEpoch:function
  • numChallenges:function
    • numChallenges(arg0: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber]>

    • Parameters

      • arg0: BigNumberish
      • Optional overrides: CallOverrides

      Returns Promise<[BigNumber]>

  • owner:function
  • registerToken:function
    • registerToken(token: string, holder: string, overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<ContractTransaction>

    • Parameters

      • token: string
      • holder: string
      • Optional overrides: Overrides & {
            from?: string | Promise<string>;
        }

      Returns Promise<ContractTransaction>

  • registerTokenType:function
    • registerTokenType(holder: string, tokenType: string, overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<ContractTransaction>

    • Parameters

      • holder: string
      • tokenType: string
      • Optional overrides: Overrides & {
            from?: string | Promise<string>;
        }

      Returns Promise<ContractTransaction>

  • renounceOwnership:function
    • renounceOwnership(overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<ContractTransaction>

    • Parameters

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

      Returns Promise<ContractTransaction>

  • respondChallenge:function
    • respondChallenge(balance: {
          account: string;
          epoch: BigNumberish;
          exit: boolean;
          tokens: {
              token: string;
              value: BytesLike;
          }[];
      }, sig: BytesLike, overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<ContractTransaction>

    • Parameters

      • balance: {
            account: string;
            epoch: BigNumberish;
            exit: boolean;
            tokens: {
                token: string;
                value: BytesLike;
            }[];
        }
        • account: string
        • epoch: BigNumberish
        • exit: boolean
        • tokens: {
              token: string;
              value: BytesLike;
          }[]
      • sig: BytesLike
      • Optional overrides: Overrides & {
            from?: string | Promise<string>;
        }

      Returns Promise<ContractTransaction>

  • tee:function
  • tokenHolders:function
  • tokenTypes:function
  • transferOwnership:function
    • transferOwnership(newOwner: string, overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<ContractTransaction>

    • Parameters

      • newOwner: string
      • Optional overrides: Overrides & {
            from?: string | Promise<string>;
        }

      Returns Promise<ContractTransaction>

  • verifyBalance:function
    • verifyBalance(balance: {
          account: string;
          epoch: BigNumberish;
          exit: boolean;
          tokens: {
              token: string;
              value: BytesLike;
          }[];
      }, sig: BytesLike, overrides?: CallOverrides): Promise<[void]>

    • Parameters

      • balance: {
            account: string;
            epoch: BigNumberish;
            exit: boolean;
            tokens: {
                token: string;
                value: BytesLike;
            }[];
        }
        • account: string
        • epoch: BigNumberish
        • exit: boolean
        • tokens: {
              token: string;
              value: BytesLike;
          }[]
      • sig: BytesLike
      • Optional overrides: CallOverrides

      Returns Promise<[void]>

  • withdraw:function
    • withdraw(balance: {
          account: string;
          epoch: BigNumberish;
          exit: boolean;
          tokens: {
              token: string;
              value: BytesLike;
          }[];
      }, sig: BytesLike, overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<ContractTransaction>

    • Parameters

      • balance: {
            account: string;
            epoch: BigNumberish;
            exit: boolean;
            tokens: {
                token: string;
                value: BytesLike;
            }[];
        }
        • account: string
        • epoch: BigNumberish
        • exit: boolean
        • tokens: {
              token: string;
              value: BytesLike;
          }[]
      • sig: BytesLike
      • Optional overrides: Overrides & {
            from?: string | Promise<string>;
        }

      Returns Promise<ContractTransaction>

  • withdrawFrozen:function
    • withdrawFrozen(balance: {
          account: string;
          epoch: BigNumberish;
          exit: boolean;
          tokens: {
              token: string;
              value: BytesLike;
          }[];
      }, sig: BytesLike, overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<ContractTransaction>

    • Parameters

      • balance: {
            account: string;
            epoch: BigNumberish;
            exit: boolean;
            tokens: {
                token: string;
                value: BytesLike;
            }[];
        }
        • account: string
        • epoch: BigNumberish
        • exit: boolean
        • tokens: {
              token: string;
              value: BytesLike;
          }[]
      • sig: BytesLike
      • Optional overrides: Overrides & {
            from?: string | Promise<string>;
        }

      Returns Promise<ContractTransaction>

  • withdrawFrozenDeposit:function
    • withdrawFrozenDeposit(overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<ContractTransaction>

    • Parameters

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

      Returns Promise<ContractTransaction>

  • withdrawn:function
    • withdrawn(arg0: BigNumberish, arg1: string, overrides?: CallOverrides): Promise<[boolean]>

    • Parameters

      • arg0: BigNumberish
      • arg1: string
      • Optional overrides: CallOverrides

      Returns Promise<[boolean]>

interface

interface: ErdstallInterface

populateTransaction

populateTransaction: {
    bigBang(overrides?: CallOverrides): Promise<PopulatedTransaction>;
    challenge(balance: {
        account: string;
        epoch: BigNumberish;
        exit: boolean;
        tokens: {
            token: string;
            value: BytesLike;
        }[];
    }, sig: BytesLike, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<PopulatedTransaction>;
    challengeDeposit(overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<PopulatedTransaction>;
    challenges(arg0: BigNumberish, arg1: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
    deposit(depositor: string, token: string, value: BytesLike, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<PopulatedTransaction>;
    deposits(arg0: BigNumberish, arg1: string, arg2: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
    encodeBalanceProof(balance: {
        account: string;
        epoch: BigNumberish;
        exit: boolean;
        tokens: {
            token: string;
            value: BytesLike;
        }[];
    }, overrides?: CallOverrides): Promise<PopulatedTransaction>;
    ensureFrozen(overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<PopulatedTransaction>;
    epochDuration(overrides?: CallOverrides): Promise<PopulatedTransaction>;
    frozenEpoch(overrides?: CallOverrides): Promise<PopulatedTransaction>;
    numChallenges(arg0: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
    owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
    registerToken(token: string, holder: string, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<PopulatedTransaction>;
    registerTokenType(holder: string, tokenType: string, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<PopulatedTransaction>;
    renounceOwnership(overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<PopulatedTransaction>;
    respondChallenge(balance: {
        account: string;
        epoch: BigNumberish;
        exit: boolean;
        tokens: {
            token: string;
            value: BytesLike;
        }[];
    }, sig: BytesLike, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<PopulatedTransaction>;
    tee(overrides?: CallOverrides): Promise<PopulatedTransaction>;
    tokenHolders(arg0: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
    tokenTypes(arg0: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
    transferOwnership(newOwner: string, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<PopulatedTransaction>;
    verifyBalance(balance: {
        account: string;
        epoch: BigNumberish;
        exit: boolean;
        tokens: {
            token: string;
            value: BytesLike;
        }[];
    }, sig: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
    withdraw(balance: {
        account: string;
        epoch: BigNumberish;
        exit: boolean;
        tokens: {
            token: string;
            value: BytesLike;
        }[];
    }, sig: BytesLike, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<PopulatedTransaction>;
    withdrawFrozen(balance: {
        account: string;
        epoch: BigNumberish;
        exit: boolean;
        tokens: {
            token: string;
            value: BytesLike;
        }[];
    }, sig: BytesLike, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<PopulatedTransaction>;
    withdrawFrozenDeposit(overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<PopulatedTransaction>;
    withdrawn(arg0: BigNumberish, arg1: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
}

Type declaration

  • bigBang:function
  • challenge:function
    • challenge(balance: {
          account: string;
          epoch: BigNumberish;
          exit: boolean;
          tokens: {
              token: string;
              value: BytesLike;
          }[];
      }, sig: BytesLike, overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<PopulatedTransaction>

    • Parameters

      • balance: {
            account: string;
            epoch: BigNumberish;
            exit: boolean;
            tokens: {
                token: string;
                value: BytesLike;
            }[];
        }
        • account: string
        • epoch: BigNumberish
        • exit: boolean
        • tokens: {
              token: string;
              value: BytesLike;
          }[]
      • sig: BytesLike
      • Optional overrides: Overrides & {
            from?: string | Promise<string>;
        }

      Returns Promise<PopulatedTransaction>

  • challengeDeposit:function
    • challengeDeposit(overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<PopulatedTransaction>

    • Parameters

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

      Returns Promise<PopulatedTransaction>

  • challenges:function
    • challenges(arg0: BigNumberish, arg1: string, overrides?: CallOverrides): Promise<PopulatedTransaction>

    • Parameters

      • arg0: BigNumberish
      • arg1: string
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • deposit:function
    • deposit(depositor: string, token: string, value: BytesLike, overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<PopulatedTransaction>

    • Parameters

      • depositor: string
      • token: string
      • value: BytesLike
      • Optional overrides: Overrides & {
            from?: string | Promise<string>;
        }

      Returns Promise<PopulatedTransaction>

  • deposits:function
    • deposits(arg0: BigNumberish, arg1: string, arg2: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>

    • Parameters

      • arg0: BigNumberish
      • arg1: string
      • arg2: BigNumberish
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • encodeBalanceProof:function
    • encodeBalanceProof(balance: {
          account: string;
          epoch: BigNumberish;
          exit: boolean;
          tokens: {
              token: string;
              value: BytesLike;
          }[];
      }, overrides?: CallOverrides): Promise<PopulatedTransaction>

    • Parameters

      • balance: {
            account: string;
            epoch: BigNumberish;
            exit: boolean;
            tokens: {
                token: string;
                value: BytesLike;
            }[];
        }
        • account: string
        • epoch: BigNumberish
        • exit: boolean
        • tokens: {
              token: string;
              value: BytesLike;
          }[]
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • ensureFrozen:function
    • ensureFrozen(overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<PopulatedTransaction>

    • Parameters

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

      Returns Promise<PopulatedTransaction>

  • epochDuration:function
  • frozenEpoch:function
  • numChallenges:function
    • numChallenges(arg0: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>

    • Parameters

      • arg0: BigNumberish
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • owner:function
  • registerToken:function
    • registerToken(token: string, holder: string, overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<PopulatedTransaction>

    • Parameters

      • token: string
      • holder: string
      • Optional overrides: Overrides & {
            from?: string | Promise<string>;
        }

      Returns Promise<PopulatedTransaction>

  • registerTokenType:function
    • registerTokenType(holder: string, tokenType: string, overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<PopulatedTransaction>

    • Parameters

      • holder: string
      • tokenType: string
      • Optional overrides: Overrides & {
            from?: string | Promise<string>;
        }

      Returns Promise<PopulatedTransaction>

  • renounceOwnership:function
    • renounceOwnership(overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<PopulatedTransaction>

    • Parameters

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

      Returns Promise<PopulatedTransaction>

  • respondChallenge:function
    • respondChallenge(balance: {
          account: string;
          epoch: BigNumberish;
          exit: boolean;
          tokens: {
              token: string;
              value: BytesLike;
          }[];
      }, sig: BytesLike, overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<PopulatedTransaction>

    • Parameters

      • balance: {
            account: string;
            epoch: BigNumberish;
            exit: boolean;
            tokens: {
                token: string;
                value: BytesLike;
            }[];
        }
        • account: string
        • epoch: BigNumberish
        • exit: boolean
        • tokens: {
              token: string;
              value: BytesLike;
          }[]
      • sig: BytesLike
      • Optional overrides: Overrides & {
            from?: string | Promise<string>;
        }

      Returns Promise<PopulatedTransaction>

  • tee:function
  • tokenHolders:function
    • tokenHolders(arg0: string, overrides?: CallOverrides): Promise<PopulatedTransaction>

    • Parameters

      • arg0: string
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • tokenTypes:function
    • tokenTypes(arg0: string, overrides?: CallOverrides): Promise<PopulatedTransaction>

    • Parameters

      • arg0: string
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • transferOwnership:function
    • transferOwnership(newOwner: string, overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<PopulatedTransaction>

    • Parameters

      • newOwner: string
      • Optional overrides: Overrides & {
            from?: string | Promise<string>;
        }

      Returns Promise<PopulatedTransaction>

  • verifyBalance:function
    • verifyBalance(balance: {
          account: string;
          epoch: BigNumberish;
          exit: boolean;
          tokens: {
              token: string;
              value: BytesLike;
          }[];
      }, sig: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>

    • Parameters

      • balance: {
            account: string;
            epoch: BigNumberish;
            exit: boolean;
            tokens: {
                token: string;
                value: BytesLike;
            }[];
        }
        • account: string
        • epoch: BigNumberish
        • exit: boolean
        • tokens: {
              token: string;
              value: BytesLike;
          }[]
      • sig: BytesLike
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • withdraw:function
    • withdraw(balance: {
          account: string;
          epoch: BigNumberish;
          exit: boolean;
          tokens: {
              token: string;
              value: BytesLike;
          }[];
      }, sig: BytesLike, overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<PopulatedTransaction>

    • Parameters

      • balance: {
            account: string;
            epoch: BigNumberish;
            exit: boolean;
            tokens: {
                token: string;
                value: BytesLike;
            }[];
        }
        • account: string
        • epoch: BigNumberish
        • exit: boolean
        • tokens: {
              token: string;
              value: BytesLike;
          }[]
      • sig: BytesLike
      • Optional overrides: Overrides & {
            from?: string | Promise<string>;
        }

      Returns Promise<PopulatedTransaction>

  • withdrawFrozen:function
    • withdrawFrozen(balance: {
          account: string;
          epoch: BigNumberish;
          exit: boolean;
          tokens: {
              token: string;
              value: BytesLike;
          }[];
      }, sig: BytesLike, overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<PopulatedTransaction>

    • Parameters

      • balance: {
            account: string;
            epoch: BigNumberish;
            exit: boolean;
            tokens: {
                token: string;
                value: BytesLike;
            }[];
        }
        • account: string
        • epoch: BigNumberish
        • exit: boolean
        • tokens: {
              token: string;
              value: BytesLike;
          }[]
      • sig: BytesLike
      • Optional overrides: Overrides & {
            from?: string | Promise<string>;
        }

      Returns Promise<PopulatedTransaction>

  • withdrawFrozenDeposit:function
    • withdrawFrozenDeposit(overrides?: Overrides & {
          from?: string | Promise<string>;
      }): Promise<PopulatedTransaction>

    • Parameters

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

      Returns Promise<PopulatedTransaction>

  • withdrawn:function
    • withdrawn(arg0: BigNumberish, arg1: string, overrides?: CallOverrides): Promise<PopulatedTransaction>

    • Parameters

      • arg0: BigNumberish
      • arg1: string
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

Readonly provider

provider: Provider

Readonly resolvedAddress

resolvedAddress: Promise<string>

Readonly signer

signer: Signer

Methods

_checkRunningEvents

  • _checkRunningEvents(runningEvent: RunningEvent): void

  • Parameters

    • runningEvent: RunningEvent

    Returns void

_deployed

  • _deployed(blockTag?: BlockTag): Promise<Contract>

  • Parameters

    • Optional blockTag: BlockTag

    Returns Promise<Contract>

_wrapEvent

  • _wrapEvent(runningEvent: RunningEvent, log: Log, listener: Listener): Event

  • Parameters

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

    Returns Event

attach

bigBang

challenge

  • Parameters

    • balance: {
          account: string;
          epoch: BigNumberish;
          exit: boolean;
          tokens: {
              token: string;
              value: BytesLike;
          }[];
      }
      • account: string
      • epoch: BigNumberish
      • exit: boolean
      • tokens: {
            token: string;
            value: BytesLike;
        }[]
    • sig: BytesLike
    • Optional overrides: Overrides & {
          from?: string | Promise<string>;
      }

    Returns Promise<ContractTransaction>

challengeDeposit

  • Parameters

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

    Returns Promise<ContractTransaction>

challenges

  • Parameters

    • arg0: BigNumberish
    • arg1: string
    • Optional overrides: CallOverrides

    Returns Promise<boolean>

connect

deployed

deposit

  • Parameters

    • depositor: string
    • token: string
    • value: BytesLike
    • Optional overrides: Overrides & {
          from?: string | Promise<string>;
      }

    Returns Promise<ContractTransaction>

deposits

  • Parameters

    • arg0: BigNumberish
    • arg1: string
    • arg2: BigNumberish
    • Optional overrides: CallOverrides

    Returns Promise<[string, string] & {
        token: string;
        value: string;
    }>

emit

  • Parameters

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

    Returns boolean

encodeBalanceProof

  • Parameters

    • balance: {
          account: string;
          epoch: BigNumberish;
          exit: boolean;
          tokens: {
              token: string;
              value: BytesLike;
          }[];
      }
      • account: string
      • epoch: BigNumberish
      • exit: boolean
      • tokens: {
            token: string;
            value: BytesLike;
        }[]
    • Optional overrides: CallOverrides

    Returns Promise<string>

ensureFrozen

  • Parameters

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

    Returns Promise<ContractTransaction>

epochDuration

fallback

  • Parameters

    • Optional overrides: TransactionRequest

    Returns Promise<TransactionResponse>

frozenEpoch

listenerCount

  • Parameters

    • Optional eventName: string | EventFilter

    Returns number

listeners

  • Type Parameters

    • EventArgsArray extends any[]

    • EventArgsObject

    Parameters

    • Optional eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>

    Returns TypedListener<EventArgsArray, EventArgsObject>[]

  • Parameters

    • Optional eventName: string

    Returns Listener[]

numChallenges

  • Parameters

    • arg0: BigNumberish
    • Optional overrides: CallOverrides

    Returns Promise<BigNumber>

off

  • Type Parameters

    • EventArgsArray extends any[]

    • EventArgsObject

    Parameters

    • eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>
    • listener: TypedListener<EventArgsArray, EventArgsObject>

    Returns Erdstall

  • Parameters

    • eventName: string
    • listener: Listener

    Returns Erdstall

on

  • Type Parameters

    • EventArgsArray extends any[]

    • EventArgsObject

    Parameters

    • eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>
    • listener: TypedListener<EventArgsArray, EventArgsObject>

    Returns Erdstall

  • Parameters

    • eventName: string
    • listener: Listener

    Returns Erdstall

once

  • Type Parameters

    • EventArgsArray extends any[]

    • EventArgsObject

    Parameters

    • eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>
    • listener: TypedListener<EventArgsArray, EventArgsObject>

    Returns Erdstall

  • Parameters

    • eventName: string
    • listener: Listener

    Returns Erdstall

owner

queryFilter

  • Type Parameters

    • EventArgsArray extends any[]

    • EventArgsObject

    Parameters

    • event: TypedEventFilter<EventArgsArray, EventArgsObject>
    • Optional fromBlockOrBlockhash: string | number
    • Optional toBlock: string | number

    Returns Promise<TypedEvent<EventArgsArray & EventArgsObject>[]>

registerToken

  • Parameters

    • token: string
    • holder: string
    • Optional overrides: Overrides & {
          from?: string | Promise<string>;
      }

    Returns Promise<ContractTransaction>

registerTokenType

  • Parameters

    • holder: string
    • tokenType: string
    • Optional overrides: Overrides & {
          from?: string | Promise<string>;
      }

    Returns Promise<ContractTransaction>

removeAllListeners

removeListener

  • Type Parameters

    • EventArgsArray extends any[]

    • EventArgsObject

    Parameters

    • eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>
    • listener: TypedListener<EventArgsArray, EventArgsObject>

    Returns Erdstall

  • Parameters

    • eventName: string
    • listener: Listener

    Returns Erdstall

renounceOwnership

  • Parameters

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

    Returns Promise<ContractTransaction>

respondChallenge

  • Parameters

    • balance: {
          account: string;
          epoch: BigNumberish;
          exit: boolean;
          tokens: {
              token: string;
              value: BytesLike;
          }[];
      }
      • account: string
      • epoch: BigNumberish
      • exit: boolean
      • tokens: {
            token: string;
            value: BytesLike;
        }[]
    • sig: BytesLike
    • Optional overrides: Overrides & {
          from?: string | Promise<string>;
      }

    Returns Promise<ContractTransaction>

tee

tokenHolders

tokenTypes

transferOwnership

  • Parameters

    • newOwner: string
    • Optional overrides: Overrides & {
          from?: string | Promise<string>;
      }

    Returns Promise<ContractTransaction>

verifyBalance

  • Parameters

    • balance: {
          account: string;
          epoch: BigNumberish;
          exit: boolean;
          tokens: {
              token: string;
              value: BytesLike;
          }[];
      }
      • account: string
      • epoch: BigNumberish
      • exit: boolean
      • tokens: {
            token: string;
            value: BytesLike;
        }[]
    • sig: BytesLike
    • Optional overrides: CallOverrides

    Returns Promise<void>

withdraw

  • Parameters

    • balance: {
          account: string;
          epoch: BigNumberish;
          exit: boolean;
          tokens: {
              token: string;
              value: BytesLike;
          }[];
      }
      • account: string
      • epoch: BigNumberish
      • exit: boolean
      • tokens: {
            token: string;
            value: BytesLike;
        }[]
    • sig: BytesLike
    • Optional overrides: Overrides & {
          from?: string | Promise<string>;
      }

    Returns Promise<ContractTransaction>

withdrawFrozen

  • Parameters

    • balance: {
          account: string;
          epoch: BigNumberish;
          exit: boolean;
          tokens: {
              token: string;
              value: BytesLike;
          }[];
      }
      • account: string
      • epoch: BigNumberish
      • exit: boolean
      • tokens: {
            token: string;
            value: BytesLike;
        }[]
    • sig: BytesLike
    • Optional overrides: Overrides & {
          from?: string | Promise<string>;
      }

    Returns Promise<ContractTransaction>

withdrawFrozenDeposit

  • Parameters

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

    Returns Promise<ContractTransaction>

withdrawn

  • Parameters

    • arg0: BigNumberish
    • arg1: string
    • Optional overrides: CallOverrides

    Returns Promise<boolean>

Static getContractAddress

  • Parameters

    • transaction: {
          from: string;
          nonce: BigNumberish;
      }
      • from: string
      • nonce: BigNumberish

    Returns string

Static getInterface

  • Parameters

    • contractInterface: ContractInterface

    Returns Interface

Static isIndexed

  • Parameters

    • value: any

    Returns value is Indexed

Settings

Member Visibility

Theme

Generated using TypeDoc