Class CashuWallet

constructor

• new CashuWallet(mint, options?): CashuWallet

• Parameters

  • mint: CashuMint

    Cashu mint instance is used to make api calls

  • Optional options: {
        keys?: MintKeys;
        mnemonicOrSeed?: string | Uint8Array;
        unit?: string;
    }

    • Optional keys?: MintKeys

    • Optional mnemonicOrSeed?: string | Uint8Array

    • Optional unit?: string

  Returns CashuWallet

mint

keys

• get keys(): MintKeys

• Returns MintKeys

• set keys(keys): void

• Parameters

  • keys: MintKeys

  Returns void

unit

• get unit(): string

• Returns string

checkMeltQuote

• checkMeltQuote(quote): Promise<MeltQuoteResponse>

• Return an existing melt quote from the mint.

  Parameters

  • quote: string

    ID of the melt quote

  Returns Promise<MeltQuoteResponse>

  the mint will return an existing melt quote

checkMintQuote

• checkMintQuote(quote): Promise<MintQuoteResponse>

• Gets an existing mint quote from the mint.

  Parameters

  • quote: string

    Quote ID

  Returns Promise<MintQuoteResponse>

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

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 'Y' field is required)

  Returns Promise<T[]>

createMeltQuote

• createMeltQuote(invoice): Promise<MeltQuoteResponse>

• Requests a melt quote from the mint. Response returns amount and fees for a given unit in order to pay a Lightning invoice.

  Parameters

  • invoice: string

    LN invoice that needs to get a fee estimate

  Returns Promise<MeltQuoteResponse>

  the mint will create and return a melt quote for the invoice with an amount and fee reserve

createMintQuote

• createMintQuote(amount): Promise<MintQuoteResponse>

• Requests a mint quote form the mint. Response returns a Lightning payment request for the requested given amount and unit.

  Parameters

  • amount: number

    Amount requesting for mint.

  Returns Promise<MintQuoteResponse>

  the mint will return a mint quote with a Lightning invoice for minting tokens of the specified amount and unit

getMintInfo

• getMintInfo(): Promise<GetInfoResponse>

• Get information about the mint

  Returns Promise<GetInfoResponse>

  mint info

meltTokens

• meltTokens(meltQuote, proofsToSend, options?): Promise<MeltTokensResponse>

• Melt tokens for a melt quote. proofsToSend must be at least amount+fee_reserve form the melt quote. Returns payment proof and change proofs

  Parameters

  • meltQuote: MeltQuoteResponse

    ID of the melt quote

  • proofsToSend: Proof[]

    proofs to melt

  • Optional options: {
        counter?: number;
        keysetId?: string;
    }

    • Optional counter?: number

    • Optional keysetId?: string

  Returns Promise<MeltTokensResponse>

mintTokens

• mintTokens(amount, quote, options?): Promise<{
      proofs: Proof[];
  }>

• Mint tokens for a given mint quote

  Parameters

  • amount: number

    amount to request

  • quote: string

    ID of mint quote

  • Optional options: {
        counter?: number;
        keysetId?: string;
        preference?: AmountPreference[];
        pubkey?: string;
    }

    • Optional counter?: number

    • Optional keysetId?: string

    • Optional preference?: AmountPreference[]

    • Optional pubkey?: string

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

  proofs

payLnInvoice

• payLnInvoice(invoice, proofsToSend, meltQuote?, options?): Promise<MeltTokensResponse>

• Helper function that pays a Lightning invoice directly without having to create a melt quote before The combined amount of Proofs must match the payment amount including fees.

  Parameters

  • invoice: string

  • proofsToSend: Proof[]

    the exact amount to send including fees

  • Optional meltQuote: MeltQuoteResponse

    melt quote for the invoice

  • Optional options: {
        counter?: number;
        keysetId?: string;
    }

    • Optional counter?: number

    • Optional keysetId?: string

  Returns Promise<MeltTokensResponse>

payLnInvoiceWithToken

• payLnInvoiceWithToken(invoice, token, meltQuote, options?): Promise<MeltTokensResponse>

• Helper function to ingest a Cashu token and pay a Lightning invoice with it.

  Parameters

  • invoice: string

    Lightning invoice

  • token: string

    cashu token

  • meltQuote: MeltQuoteResponse

    melt quote for the invoice

  • Optional options: {
        counter?: number;
        keysetId?: string;
    }

    • Optional counter?: number

    • Optional keysetId?: string

  Returns Promise<MeltTokensResponse>

receive

• receive(token, options?): Promise<Proof[]>

• Receive an encoded or raw Cashu token (only supports single tokens. It will only process the first token in the token array)

  Parameters

  • token: string | Token

    Cashu token

  • Optional options: {
        counter?: number;
        keysetId?: string;
        preference?: AmountPreference[];
        privkey?: string;
        pubkey?: string;
    }

    • Optional counter?: number

    • Optional keysetId?: string

    • Optional preference?: AmountPreference[]

    • Optional privkey?: string

    • Optional pubkey?: string

  Returns Promise<Proof[]>

  New token with newly created proofs, token entries that had errors

receiveTokenEntry

• receiveTokenEntry(tokenEntry, options?): Promise<Proof[]>

• Receive a single cashu token entry

  Parameters

  • tokenEntry: TokenEntry

    a single entry of a cashu token

  • Optional options: {
        counter?: number;
        keysetId?: string;
        preference?: AmountPreference[];
        privkey?: string;
        pubkey?: string;
    }

    • Optional counter?: number

    • Optional keysetId?: string

    • Optional preference?: AmountPreference[]

    • Optional privkey?: string

    • Optional pubkey?: string

  Returns Promise<Proof[]>

  New token entry with newly created proofs, proofs that had errors

restore

• restore(start, count, options?): Promise<{
      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 options: {
        keysetId?: string;
    }

    • Optional keysetId?: string

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

  proofs

send

• send(amount, proofs, options?): 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 options: {
        counter?: number;
        keysetId?: string;
        preference?: AmountPreference[];
        privkey?: string;
        pubkey?: string;
    }

    • Optional counter?: number

    • Optional keysetId?: string

    • Optional preference?: AmountPreference[]

    • Optional privkey?: string

    • Optional pubkey?: string

  Returns Promise<SendResponse>

  promise of the change- and send-proofs