Class CashuWallet

constructor

• new CashuWallet(
      mint: CashuMint,
      options?: {
          bip39seed?: Uint8Array<ArrayBufferLike>;
          denominationTarget?: number;
          keepFactory?: OutputDataFactory;
          keys?: MintKeys | MintKeys[];
          keysets?: MintKeyset[];
          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[];
        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)

    • 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

checkMeltQuote

• checkMeltQuote(quote: string): 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: string): 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

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[]>

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

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

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

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: string,
      options?: MintProofOptions,
  ): Promise<Proof[]>

• Mint proofs for a given mint quote

  Parameters

  • amount: number

    amount to request
  • quote: string

    ID of mint quote
  • 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<{ 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<{ proofs: Proof[] }>

selectProofsToSend

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

• Parameters

  • proofs: Proof[]
  • amountToSend: number
  • OptionalincludeFees: boolean

  Returns SendResponse

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