Class CashuWallet

constructor

• new CashuWallet(
      mint: CashuMint,
      options?: {
          bip39seed?: Uint8Array<ArrayBufferLike>;
          denominationTarget?: number;
          keepFactory?: OutputDataFactory;
          keys?: MintKeys | MintKeys[];
          keysets?: MintKeyset[];
          logger?: Logger;
          mintInfo?: GetInfoResponse;
          unit?: string;
      },
  ): CashuWallet

  Parameters

  • mint: CashuMint

    Cashu mint instance is used to make api calls.
  • Optionaloptions: {
        bip39seed?: Uint8Array<ArrayBufferLike>;
        denominationTarget?: number;
        keepFactory?: OutputDataFactory;
        keys?: MintKeys | MintKeys[];
        keysets?: MintKeyset[];
        logger?: Logger;
        mintInfo?: GetInfoResponse;
        unit?: string;
    }

    • Optionalbip39seed?: Uint8Array<ArrayBufferLike>

      BIP39 seed for deterministic secrets.

    • OptionaldenominationTarget?: number

      Target number proofs per denomination (default: see

    • OptionalkeepFactory?: OutputDataFactory

      A function that will be used by all parts of the library that produce proofs to be kept (change, etc.). This can lead to poor performance, in which case the seed should be directly provided.

    • Optionalkeys?: MintKeys | MintKeys[]

      Public keys from the mint (will be fetched from mint if not provided)

    • Optionalkeysets?: MintKeyset[]

      Keysets from the mint (will be fetched from mint if not provided)

    • Optionallogger?: Logger

    • OptionalmintInfo?: GetInfoResponse

      Mint info from the mint (will be fetched from mint if not provided)

    • Optionalunit?: string

      Optionally set unit (default is 'sat')

  Returns CashuWallet

  Constant

  DEFAULT_DENOMINATION_TARGET)

mint

keys

• get keys(): Map<string, MintKeys>

  Returns Map<string, MintKeys>

keysetId

• get keysetId(): string

  Returns string

• set keysetId(keysetId: string): void

  Parameters

  • keysetId: string

  Returns void

keysets

• get keysets(): MintKeyset[]

  Returns MintKeyset[]

mintInfo

• get mintInfo(): MintInfo

  Returns MintInfo

unit

• get unit(): string

  Returns string

batchRestore

• batchRestore(
      gapLimit?: number,
      batchSize?: number,
      counter?: number,
      keysetId?: string,
  ): Promise<{ lastCounterWithSignature?: number; proofs: Proof[] }>

  Restores batches of deterministic proofs until no more signatures are returned from the mint.

  Parameters

  • OptionalgapLimit: number = 300

    The amount of empty counters that should be returned before restoring ends (defaults to 300). Default is 300
  • OptionalbatchSize: number = 100

    The amount of proofs that should be restored at a time (defaults to 100). Default is 100
  • Optionalcounter: number = 0

    The counter that should be used as a starting point (defaults to 0). Default is 0
  • OptionalkeysetId: string

    Which keysetId to use for the restoration. If none is passed the instance's default one will be used.

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

checkMeltQuote

• checkMeltQuote(quote: string): Promise<PartialMeltQuoteResponse>

  Return an existing melt quote from the mint.

  Parameters

  • quote: string

    ID of the melt quote.

  Returns Promise<PartialMeltQuoteResponse>

  The mint will return an existing melt quote.
• checkMeltQuote(quote: MeltQuoteResponse): Promise<MeltQuoteResponse>

  Return an existing melt quote from the mint.

  Parameters

  • quote: MeltQuoteResponse

    ID of the melt quote.

  Returns Promise<MeltQuoteResponse>

  The mint will return an existing melt quote.

checkMintQuote

• checkMintQuote(quote: MintQuoteResponse): Promise<MintQuoteResponse>

  Gets an existing mint quote from the mint.

  Parameters

  • quote: MintQuoteResponse

    Quote ID.

  Returns Promise<MintQuoteResponse>

  The mint will create and return a Lightning invoice for the specified amount.
• checkMintQuote(quote: string): Promise<PartialMintQuoteResponse>

  Gets an existing mint quote from the mint.

  Parameters

  • quote: string

    Quote ID.

  Returns Promise<PartialMintQuoteResponse>

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

checkProofsStates

• checkProofsStates(proofs: Proof[]): Promise<ProofState[]>

  Get an array of the states of proofs from the mint (as an array of CheckStateEnum's)

  Parameters

  • proofs: Proof[]

    (only the secret field is required)

  Returns Promise<ProofState[]>

createLockedMintQuote

• createLockedMintQuote(
      amount: number,
      pubkey: string,
      description?: string,
  ): Promise<LockedMintQuoteResponse>

  Requests a mint quote from the mint that is locked to a public key.

  Parameters

  • amount: number

    Amount requesting for mint.
  • pubkey: string

    Public key to lock the quote to.
  • Optionaldescription: string

    Optional description for the mint quote.

  Returns Promise<LockedMintQuoteResponse>

  The mint will return a mint quote with a Lightning invoice for minting tokens of the specified amount and unit. The quote will be locked to the specified pubkey.

createMeltQuote

• createMeltQuote(invoice: string): 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: number,
      description?: string,
  ): 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.
  • Optionaldescription: string

    Optional description for the mint quote.

  Returns Promise<MintQuoteResponse>

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

createMultiPathMeltQuote

• createMultiPathMeltQuote(
      invoice: string,
      millisatPartialAmount: number,
  ): Promise<MeltQuoteResponse>

  Requests a multi path melt quote from the mint.

  Parameters

  • invoice: string

    LN invoice that needs to get a fee estimate.
  • millisatPartialAmount: number

  Returns Promise<MeltQuoteResponse>

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

getActiveKeyset

• getActiveKeyset(keysets: MintKeyset[]): MintKeyset

  Choose a keyset to activate based on the lowest input fee.

  Note: this function will filter out deprecated base64 keysets.

  Parameters

  • keysets: MintKeyset[]

    Keysets to choose from.

  Returns MintKeyset

  Active keyset.

getAllKeys

• getAllKeys(): Promise<MintKeys[]>

  Get all active keys from the mint and set the keyset with the lowest fees as the active wallet keyset.

  Returns Promise<MintKeys[]>

  Keyset.

getFeesForKeyset

• getFeesForKeyset(nInputs: number, keysetId: string): number

  Calculates the fees based on inputs for a given keyset.

  Parameters

  • nInputs: number

    Number of inputs.
  • keysetId: string

    KeysetId used to lookup input_fee_ppk

  Returns number

  Fee amount.

getFeesForProofs

• getFeesForProofs(proofs: Proof[]): number

  Calculates the fees based on inputs (proofs)

  Parameters

  • proofs: Proof[]

    Input proofs to calculate fees for.

  Returns number

  Fee amount.

  Throws

  Throws an error if the proofs keyset is unknown.

getKeys

• getKeys(keysetId?: string, forceRefresh?: boolean): Promise<MintKeys>

  Get public keys from the mint. If keys were already fetched, it will return those.

  If keysetId is set, it will fetch and return that specific keyset. Otherwise, we select an active keyset with the unit of the wallet.

  Parameters

  • OptionalkeysetId: string

    Optional keysetId to get keys for.
  • OptionalforceRefresh: boolean

  Returns Promise<MintKeys>

  Keyset.

getKeySets

• getKeySets(): Promise<MintKeyset[]>

  Get keysets from the mint with the unit of the wallet.

  Returns Promise<MintKeyset[]>

  Keysets with wallet's unit.

getMintInfo

• getMintInfo(): Promise<MintInfo>

  Get information about the mint.

  Returns Promise<MintInfo>

  Mint info.

lazyGetMintInfo

• lazyGetMintInfo(): Promise<MintInfo>

  Get stored information about the mint or request it if not loaded.

  Returns Promise<MintInfo>

  Mint info.

loadMint

• loadMint(): Promise<void>

  Load mint information, keysets and keys. This function can be called if no keysets are passed in the constructor.

  Returns Promise<void>

meltProofs

• meltProofs(
      meltQuote: MeltQuoteResponse,
      proofsToSend: Proof[],
      options?: MeltProofOptions,
  ): Promise<MeltProofsResponse>

  Melt proofs for a melt quote. proofsToSend must be at least amount+fee_reserve form the melt quote. This function does not perform coin selection!. Returns melt quote and change proofs.

  Parameters

  • meltQuote: MeltQuoteResponse

    ID of the melt quote.
  • proofsToSend: Proof[]

    Proofs to melt.
  • Optionaloptions: MeltProofOptions

    Optional parameters for configuring the Melting Proof operation.

  Returns Promise<MeltProofsResponse>

mintProofs

• mintProofs(
      amount: number,
      quote: MintQuoteResponse,
      options?: MintProofOptions & { privateKey: string },
  ): Promise<Proof[]>

  Mint proofs for a given mint quote.

  Parameters

  • amount: number

    Amount to request.
  • quote: MintQuoteResponse

    ID of mint quote (when quote is a string)
  • Optionaloptions: MintProofOptions & { privateKey: string }

    Optional parameters for configuring the Mint Proof operation.

  Returns Promise<Proof[]>

  Proofs.
• mintProofs(
      amount: number,
      quote: string,
      options?: MintProofOptions,
  ): Promise<Proof[]>

  Mint proofs for a given mint quote.

  Parameters

  • amount: number

    Amount to request.
  • quote: string

    ID of mint quote (when quote is a string)
  • Optionaloptions: MintProofOptions

    Optional parameters for configuring the Mint Proof operation.

  Returns Promise<Proof[]>

  Proofs.

onMeltQuotePaid

• onMeltQuotePaid(
      quoteId: string,
      callback: (payload: MeltQuoteResponse) => void,
      errorCallback: (e: Error) => void,
  ): Promise<SubscriptionCanceller>

  Register a callback to be called whenever a melt quote's state changes.

  Parameters

  • quoteId: string
  • callback: (payload: MeltQuoteResponse) => void

    Callback function that will be called whenever a melt quote state changes.
  • errorCallback: (e: Error) => void

  Returns Promise<SubscriptionCanceller>

onMeltQuoteUpdates

• onMeltQuoteUpdates(
      quoteIds: string[],
      callback: (payload: MeltQuoteResponse) => void,
      errorCallback: (e: Error) => void,
  ): Promise<SubscriptionCanceller>

  Register a callback to be called when a single melt quote gets paid.

  Parameters

  • quoteIds: string[]
  • callback: (payload: MeltQuoteResponse) => void

    Callback function that will be called when this melt quote gets paid.
  • errorCallback: (e: Error) => void

  Returns Promise<SubscriptionCanceller>

onMintQuotePaid

• onMintQuotePaid(
      quoteId: string,
      callback: (payload: MintQuoteResponse) => void,
      errorCallback: (e: Error) => void,
  ): Promise<SubscriptionCanceller>

  Register a callback to be called when a single mint quote gets paid.

  Parameters

  • quoteId: string

    Mint quote id that should be subscribed to.
  • callback: (payload: MintQuoteResponse) => void

    Callback function that will be called when this mint quote gets paid.
  • errorCallback: (e: Error) => void

  Returns Promise<SubscriptionCanceller>

onMintQuoteUpdates

• onMintQuoteUpdates(
      quoteIds: string[],
      callback: (payload: MintQuoteResponse) => void,
      errorCallback: (e: Error) => void,
  ): Promise<SubscriptionCanceller>

  Register a callback to be called whenever a mint quote's state changes.

  Parameters

  • quoteIds: string[]

    List of mint quote IDs that should be subscribed to.
  • callback: (payload: MintQuoteResponse) => void

    Callback function that will be called whenever a mint quote state changes.
  • errorCallback: (e: Error) => void

  Returns Promise<SubscriptionCanceller>

onProofStateUpdates

• onProofStateUpdates(
      proofs: Proof[],
      callback: (payload: ProofState & { proof: Proof }) => void,
      errorCallback: (e: Error) => void,
  ): Promise<SubscriptionCanceller>

  Register a callback to be called whenever a subscribed proof state changes.

  Parameters

  • proofs: Proof[]

    List of proofs that should be subscribed to.
  • callback: (payload: ProofState & { proof: Proof }) => void

    Callback function that will be called whenever a proof's state changes.
  • errorCallback: (e: Error) => void

  Returns Promise<SubscriptionCanceller>

receive

• receive(token: string | Token, options?: ReceiveOptions): 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, either as string or decoded.
  • Optionaloptions: ReceiveOptions

    Optional configuration for token processing.

  Returns Promise<Proof[]>

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

restore

• restore(
      start: number,
      count: number,
      options?: RestoreOptions,
  ): Promise<{ lastCounterWithSignature?: number; 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.
  • Optionaloptions: RestoreOptions

    • OptionalkeysetId?: string

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

selectProofsToSend

• selectProofsToSend(
      proofs: Proof[],
      amountToSend: number,
      includeFees?: boolean,
  ): SendResponse

  Selects proofs to send based on amount and fee inclusion.

  Parameters

  • proofs: Proof[]

    Array of Proof objects available to select from.
  • amountToSend: number

    The target amount to send.
  • includeFees: boolean = false

    Optional boolean to include fees; Default: false.

  Returns SendResponse

  SendResponse containing proofs to keep and proofs to send.

  Remarks

  Uses an adapted Randomized Greedy with Local Improvement (RGLI) algorithm, which has a time complexity O(n log n) and space complexity O(n).

  See

  https://crypto.ethz.ch/publications/files/Przyda02.pdf

send

• send(
      amount: number,
      proofs: Proof[],
      options?: SendOptions,
  ): Promise<SendResponse>

  Send proofs of a given amount, by providing at least the required amount of proofs.

  Parameters

  • amount: number

    Amount to send.
  • proofs: Proof[]

    Array of proofs (accumulated amount of proofs must be >= than amount)
  • Optionaloptions: SendOptions

    Optional parameters for configuring the send operation.

  Returns Promise<SendResponse>

swap

• swap(
      amount: number,
      proofs: Proof[],
      options?: SwapOptions,
  ): 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
  • proofs: Proof[]
  • Optionaloptions: SwapOptions

    Optional parameters for configuring the swap operation.

  Returns Promise<SendResponse>

  Promise of the change- and send-proofs.