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, mnemonic, or entropy (array of random numbers). It provides functionality to sign/verify transactions offline.

example
// Derive a wallet from a bip38 Mnemonic
const wallet = Wallet.fromMnemonic(
  'jewel insect retreat jump claim horse second chef west gossip bone frown exotic embark laundry'
)
console.log(wallet)
// Wallet {
// publicKey: '02348F89E9A6A3615BA317F8474A3F51D66221562D3CA32BFA8D21348FF67012B2',
// privateKey: '00A8F2E77FC0E05890C1B5088AFE0ECF9D96466A4419B897B1AB383E336E1735A2',
// classicAddress: 'rwZiksrExmVkR64pf87Jor4cYbmff47SUm',
// seed: undefined
// }.

// Derive a wallet from a base58 encoded seed.
const seedWallet = Wallet.fromSeed('ssZkdwURFMBXenJPbrpE14b6noJSu')
console.log(seedWallet)
// Wallet {
// publicKey: '02FE9932A9C4AA2AC9F0ED0F2B89302DE7C2C95F91D782DA3CF06E64E1C1216449',
// privateKey: '00445D0A16DD05EFAF6D5AF45E6B8A6DE4170D93C0627021A0B8E705786CBCCFF7',
// classicAddress: 'rG88FVLjvYiQaGftSa1cKuE2qNx7aK5ivo',
// seed: 'ssZkdwURFMBXenJPbrpE14b6noJSu'
// }.

// Sign a JSON Transaction
 const signed = seedWallet.signTransaction({
     TransactionType: 'Payment',
     Account: 'rG88FVLjvYiQaGftSa1cKuE2qNx7aK5ivo'
     ...........
}).

console.log(signed)
// '1200007321......B01BE1DFF3'.
console.log(decode(signed))
// {
//   TransactionType: 'Payment',
//   SigningPubKey: '02FE9932A9C4AA2AC9F0ED0F2B89302DE7C2C95F91D782DA3CF06E64E1C1216449',
//   TxnSignature: '3045022100AAD......5B631ABD21171B61B07D304',
//   Account: 'rG88FVLjvYiQaGftSa1cKuE2qNx7aK5ivo'
//   ...........
// }

Hierarchy

  • Wallet

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

  • new Wallet(publicKey: string, privateKey: string, opts?: { masterAddress?: string; seed?: string }): Wallet

  • Creates a new Wallet.

    Parameters

    • publicKey: string

      The public key for the account.

    • privateKey: string

      The private key used for signing transactions for the account.

    • opts: { masterAddress?: string; seed?: string } = {}

      (Optional) Options to initialize a Wallet.

      • Optional masterAddress?: string

        Include if a Wallet uses a Regular Key Pair. It must be the master address of the account.

      • Optional seed?: string

        The seed used to derive the account keys.

    Returns Wallet

Properties

Readonly classicAddress

classicAddress: string

Readonly privateKey

privateKey: string

Readonly publicKey

publicKey: string

Optional Readonly seed

seed?: string

Static fromSecret

fromSecret: (seed: string, opts?: { algorithm?: ECDSA; masterAddress?: string }) => Wallet = Wallet.fromSeed

Type declaration

    • (seed: string, opts?: { algorithm?: ECDSA; masterAddress?: string }): Wallet

    • Derives a wallet from a seed.

      Parameters

      • seed: string

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

      • opts: { algorithm?: ECDSA; masterAddress?: string } = {}

        (Optional) Options to derive a Wallet.

        • Optional algorithm?: ECDSA

          The digital signature algorithm to generate an address for.

        • Optional masterAddress?: string

          Include if a Wallet uses a Regular Key Pair. It must be the master address of the account.

      Returns Wallet

      A Wallet derived from a seed.

Accessors

address

  • get address(): string

Methods

Private checkTxSerialization

  • checkTxSerialization(serialized: string, tx: Transaction): void

  • Decode a serialized transaction, remove the fields that are added during the signing process, and verify that it matches the transaction prior to signing. This gives the user a sanity check to ensure that what they try to encode matches the message that will be recieved by rippled.

    throws

    A ValidationError if the transaction does not have a TxnSignature/Signers property, or if the serialized Transaction desn't match the original transaction.

    Parameters

    • serialized: string

      A signed and serialized transaction.

    • tx: Transaction

      The transaction prior to signing.

    Returns void

getXAddress

  • getXAddress(tag?: number | false, isTestnet?: boolean): string

  • Gets an X-address in Testnet/Mainnet format.

    Parameters

    • tag: number | false = false

      A tag to be included within the X-address.

    • isTestnet: boolean = false

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

    Returns string

    An X-address.

sign

  • sign(transaction: Transaction, multisign?: string | boolean): { hash: string; tx_blob: string }

  • Signs a transaction offline.

    throws

    ValidationError if the transaction is already signed or does not encode/decode to same result.

    Parameters

    • transaction: Transaction

      A transaction to be signed offline.

    • Optional multisign: string | boolean

      Specify true/false to use multisign or actual address (classic/x-address) to make multisign tx request.

    Returns { hash: string; tx_blob: string }

    A signed transaction.

    • hash: string
    • tx_blob: string

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, opts?: { algorithm?: ECDSA; masterAddress?: string }): Wallet

  • Derive a Wallet from a seed.

    Parameters

    • seed: string

      The seed used to derive the wallet.

    • opts: { algorithm?: ECDSA; masterAddress?: string } = {}

      (Optional) Options to derive a Wallet.

      • Optional algorithm?: ECDSA

        The digital signature algorithm to generate an address for.

      • Optional masterAddress?: string

        Include if a Wallet uses a Regular Key Pair. It must be the master address of the account.

    Returns Wallet

    A Wallet derived from the seed.

Static fromEntropy

  • fromEntropy(entropy: Uint8Array | number[], opts?: { algorithm?: ECDSA; masterAddress?: string }): Wallet

  • Derives a wallet from an entropy (array of random numbers).

    Parameters

    • entropy: Uint8Array | number[]

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

    • opts: { algorithm?: ECDSA; masterAddress?: string } = {}

      (Optional) Options to derive a Wallet.

      • Optional algorithm?: ECDSA

        The digital signature algorithm to generate an address for.

      • Optional masterAddress?: string

        Include if a Wallet uses a Regular Key Pair. It must be the master address of the account.

    Returns Wallet

    A Wallet derived from an entropy.

Static fromMnemonic

  • fromMnemonic(mnemonic: string, opts?: { derivationPath?: string; masterAddress?: string }): Wallet

  • Derives a wallet from a mnemonic.

    throws

    ValidationError if unable to derive private key from mnemonic input.

    Parameters

    • mnemonic: string

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

    • opts: { derivationPath?: string; masterAddress?: string } = {}

      (Optional) Options to derive a Wallet.

      • Optional derivationPath?: string

        The path to derive a keypair (publicKey/privateKey) used for mnemonic-to-seed conversion.

      • Optional masterAddress?: string

        Include if a Wallet uses a Regular Key Pair. It must be the master address of the account.

    Returns Wallet

    A Wallet derived from a mnemonic.

Static fromSeed

  • fromSeed(seed: string, opts?: { algorithm?: ECDSA; masterAddress?: string }): Wallet

  • Derives a wallet from a seed.

    Parameters

    • seed: string

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

    • opts: { algorithm?: ECDSA; masterAddress?: string } = {}

      (Optional) Options to derive a Wallet.

      • Optional algorithm?: ECDSA

        The digital signature algorithm to generate an address for.

      • Optional masterAddress?: string

        Include if a Wallet uses a Regular Key Pair. It must be the master address of the account.

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

      The digital signature algorithm to generate an address for.

    Returns Wallet

    A new Wallet derived from a generated seed.

Generated using TypeDoc