Options
All
  • Public
  • Public/Protected
  • All
Menu

Class Wallet

A utility for deriving a wallet composed of a keypair (publicKey/privateKey). A wallet can be derived from either a seed, mnemnoic, or entropy (array of random numbers). It provides functionality to sign/verify transactions offline.

Hierarchy

  • Wallet

Index

Constructors

constructor

  • new Wallet(publicKey: string, privateKey: string, seed?: string): Wallet

Properties

Readonly classicAddress

classicAddress: string

Readonly privateKey

privateKey: string

Readonly publicKey

publicKey: string

Optional Readonly seed

seed: string

Static Private Readonly defaultAlgorithm

defaultAlgorithm: ECDSA = ...

Static Private Readonly defaultDerivationPath

defaultDerivationPath: string = "m/44'/144'/0'/0/0"

Methods

getXAddress

  • getXAddress(tag: number, test?: boolean): string
  • Gets an X-address in Testnet/Mainnet format.

    Parameters

    • tag: number

      A tag to be included within the X-address.

    • test: boolean = false

      A boolean to indicate if X-address should be in Testnet (true) or Mainnet (false) format.

    Returns string

    An X-address.

signTransaction

  • signTransaction(transaction: any, options?: SignOptions): SignedTransaction
  • Signs a transaction offline.

    Parameters

    • transaction: any

      A transaction to be signed offline.

    • options: SignOptions = ...

      Options to include for signing.

    Returns SignedTransaction

    A signed transaction.

verifyTransaction

  • verifyTransaction(signedTransaction: string): boolean
  • Verifies a signed transaction offline.

    Parameters

    • signedTransaction: string

      A signed transaction (hex string of signTransaction result) to be verified offline.

    Returns boolean

    Returns true if a signedTransaction is valid.

Static Private deriveWallet

  • deriveWallet(seed: string, algorithm?: ECDSA): Wallet

Static fromEntropy

  • fromEntropy(entropy: number[] | Uint8Array, algorithm?: ECDSA): Wallet
  • Derives a wallet from an entropy (array of random numbers).

    Parameters

    • entropy: number[] | Uint8Array

      An array of random numbers to generate a seed used to derive a wallet.

    • algorithm: ECDSA = ...

      The digital signature algorithm to generate an address for.

    Returns Wallet

    A Wallet derived from an entropy.

Static fromMnemonic

  • fromMnemonic(mnemonic: string, derivationPath?: string): Wallet
  • Derives a wallet from a mnemonic.

    Parameters

    • mnemonic: string

      A string consisting of words (whitespace delimited) used to derive a wallet.

    • derivationPath: string = ...

      The path to derive a keypair (publicKey/privateKey) from a seed (that was converted from a mnemonic).

    Returns Wallet

    A Wallet derived from a mnemonic.

Static fromSeed

  • fromSeed(seed: string, algorithm?: ECDSA): Wallet
  • Derives a wallet from a seed.

    Parameters

    • seed: string

      A string used to generate a keypair (publicKey/privateKey) to derive a wallet.

    • algorithm: ECDSA = ...

      The digital signature algorithm to generate an address for.

    Returns Wallet

    A Wallet derived from a seed.

Static generate

  • generate(algorithm?: ECDSA): Wallet
  • Generates a new Wallet using a generated seed.

    Parameters

    • algorithm: ECDSA = ...

      The digital signature algorithm to generate an address for.

    Returns Wallet

    A new Wallet derived from a generated seed.

Static Private hexFromBuffer

  • hexFromBuffer(buffer: Buffer): string

Generated using TypeDoc