Class CashuWallet

constructor

• new CashuWallet(mint, keys?, mnemonicOrSeed?): CashuWallet

• Parameters

  • mint: CashuMint

    Cashu mint instance is used to make api calls

  • Optional keys: MintKeys

    public keys from the mint

  • Optional mnemonicOrSeed: string | Uint8Array

    mnemonic phrase or Seed to initial derivation key for this wallets deterministic secrets. When the mnemonic is provided, the seed will be derived from it. This can lead to poor performance, in which case the seed should be directly provided

  Returns CashuWallet

mint

keys

• get keys(): MintKeys

• Returns MintKeys

• set keys(keys): void

• Parameters

  • keys: MintKeys

  Returns void

keysetId

• get keysetId(): string

• Returns string

checkProofsSpent

• checkProofsSpent<T>(proofs): Promise<T[]>

• returns proofs that are already spent (use for keeping wallet state clean)

  Type Parameters

  • T extends {
        secret: string;
    }

  Parameters

  • proofs: T[]

    (only the 'secret' field is required)

  Returns Promise<T[]>

createPaymentPayload

• createPaymentPayload(invoice, proofs): PaymentPayload

• Parameters

  • invoice: string

  • proofs: Proof[]

  Returns PaymentPayload

getFee

• getFee(invoice): Promise<number>

• Estimate fees for a given LN invoice

  Parameters

  • invoice: string

    LN invoice that needs to get a fee estimate

  Returns Promise<number>

  estimated Fee

payLnInvoice

• payLnInvoice(invoice, proofsToSend, feeReserve?, counter?): Promise<PayLnInvoiceResponse>

• Executes a payment of an invoice on the Lightning network. The combined amount of Proofs has to match the payment amount including fees.

  Parameters

  • invoice: string

  • proofsToSend: Proof[]

    the exact amount to send including fees

  • Optional feeReserve: number

  • Optional counter: number

  Returns Promise<PayLnInvoiceResponse>

payLnInvoiceWithToken

• payLnInvoiceWithToken(invoice, token, counter?): Promise<PayLnInvoiceResponse>

• Use a cashu token to pay an ln invoice

  Parameters

  • invoice: string

    Lightning invoice

  • token: string

    cashu token

  • Optional counter: number

  Returns Promise<PayLnInvoiceResponse>

receive

• receive(token, preference?, counter?): Promise<ReceiveResponse>

• Receive an encoded or raw Cashu token

  Parameters

  • token: string | Token

    Cashu token

  • Optional preference: AmountPreference[]

    optional preference for splitting proofs into specific amounts

  • Optional counter: number

  Returns Promise<ReceiveResponse>

  New token with newly created proofs, token entries that had errors, and newKeys if they have changed

receiveTokenEntry

• receiveTokenEntry(tokenEntry, preference?, counter?): Promise<ReceiveTokenEntryResponse>

• Receive a single cashu token entry

  Parameters

  • tokenEntry: TokenEntry

    a single entry of a cashu token

  • Optional preference: AmountPreference[]

    optional preference for splitting proofs into specific amounts.

  • Optional counter: number

  Returns Promise<ReceiveTokenEntryResponse>

  New token entry with newly created proofs, proofs that had errors, and newKeys if they have changed

requestMint

• requestMint(amount): Promise<RequestMintResponse>

• Starts a minting process by requesting an invoice from the mint

  Parameters

  • amount: number

    Amount requesting for mint.

  Returns Promise<RequestMintResponse>

  the mint will create and return a Lightning invoice for the specified amount

requestTokens

• requestTokens(amount, id, AmountPreference?, counter?): Promise<{
      newKeys?: MintKeys;
      proofs: Proof[];
  }>

• Request tokens from the mint

  Parameters

  • amount: number

    amount to request

  • id: string

    id to identify the mint request*

  • Optional AmountPreference: AmountPreference[]

  • Optional counter: number

  Returns Promise<{
      newKeys?: MintKeys;
      proofs: Proof[];
  }>

  proofs and newKeys if they have changed

restore

• restore(start, count, keysetId?): Promise<{
      newKeys?: MintKeys;
      proofs: Proof[];
  }>

• Regenerates

  Parameters

  • start: number

    set starting point for count (first cycle for each keyset should usually be 0)

  • count: number

    set number of blinded messages that should be generated

  • Optional keysetId: string

  Returns Promise<{
      newKeys?: MintKeys;
      proofs: Proof[];
  }>

  proofs (and newKeys, if they have changed)

send

• send(amount, proofs, preference?, counter?): Promise<SendResponse>

• Splits and creates sendable tokens if no amount is specified, the amount is implied by the cumulative amount of all proofs if both amount and preference are set, but the preference cannot fulfill the amount, then we use the default split

  Parameters

  • amount: number

    amount to send while performing the optimal split (least proofs possible). can be set to undefined if preference is set

  • proofs: Proof[]

    proofs matching that amount

  • Optional preference: AmountPreference[]

    optional preference for splitting proofs into specific amounts. overrides amount param

  • Optional counter: number

  Returns Promise<SendResponse>

  promise of the change- and send-proofs