Class CashuWallet

constructor

• new CashuWallet(mint, options?): CashuWallet

• Constant

  DEFAULT_DENOMINATION_TARGET)

  Parameters

  • mint: CashuMint

    Cashu mint instance is used to make api calls

  • Optional options: {
        bip39seed?: Uint8Array;
        denominationTarget?: number;
        keys?: MintKeys | MintKeys[];
        keysets?: MintKeyset[];
        mintInfo?: GetInfoResponse;
        unit?: string;
    }

    • Optional bip39seed?: Uint8Array

      BIP39 seed for deterministic secrets. This can lead to poor performance, in which case the seed should be directly provided

    • Optional denominationTarget?: number

      target number proofs per denomination (default: see

    • Optional keys?: MintKeys | MintKeys[]

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

    • Optional keysets?: MintKeyset[]

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

    • Optional mintInfo?: GetInfoResponse

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

    • Optional unit?: string

      optionally set unit (default is 'sat')

  Returns CashuWallet

mint

keys

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

• Returns Map<string, MintKeys>

keysetId

• get keysetId(): string

• Returns string

• set keysetId(keysetId): void

• Parameters

  • keysetId: string

  Returns void

keysets

• get keysets(): MintKeyset[]

• Returns MintKeyset[]

mintInfo

• get mintInfo(): GetInfoResponse

• Returns GetInfoResponse

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

checkProofsStates

• checkProofsStates(proofs): 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): 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, description?): 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.

  • Optional description: 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

• 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, keysetId): 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): number

• calculates the fees based on inputs (proofs)

  Parameters

  • proofs: Proof[]

    input proofs to calculate fees for

  Returns number

  fee amount

getKeySets

• getKeySets(): Promise<MintKeyset[]>

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

  Returns Promise<MintKeyset[]>

  keysets with wallet's unit

getKeys

• getKeys(keysetId?, forceRefresh?): 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

  • Optional keysetId: string

    optional keysetId to get keys for

  • Optional forceRefresh: boolean

  Returns Promise<MintKeys>

  keyset

getMintInfo

• getMintInfo(): Promise<GetInfoResponse>

• Get information about the mint

  Returns Promise<GetInfoResponse>

  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, proofsToSend, options?): 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

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

    • Optional counter?: number

    • Optional keysetId?: string

    • Optional privkey?: string

  Returns Promise<MeltProofsResponse>

mintProofs

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

• Mint proofs for a given mint quote

  Parameters

  • amount: number

    amount to request

  • quote: string

    ID of mint quote

  • Optional options: {
        counter?: number;
        keysetId?: string;
        outputAmounts?: OutputAmounts;
        proofsWeHave?: Proof[];
        pubkey?: string;
    }

    • Optional counter?: number

    • Optional keysetId?: string

    • Optional outputAmounts?: OutputAmounts

    • Optional proofsWeHave?: Proof[]

    • Optional pubkey?: string

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

  proofs

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, either as string or decoded

  • Optional options: {
        counter?: number;
        keysetId?: string;
        outputAmounts?: OutputAmounts;
        privkey?: string;
        proofsWeHave?: Proof[];
        pubkey?: string;
    }

    • Optional counter?: number

    • Optional keysetId?: string

    • Optional outputAmounts?: OutputAmounts

    • Optional privkey?: string

    • Optional proofsWeHave?: Proof[]

    • Optional pubkey?: string

  Returns Promise<Proof[]>

  New token with newly created proofs, token entries 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

      set a custom keysetId to restore from. keysetIds can be loaded with CashuMint.getKeySets()

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

  proofs

selectProofsToSend

• selectProofsToSend(proofs, amountToSend, includeFees?): SendResponse

• Parameters

  • proofs: Proof[]

  • amountToSend: number

  • Optional includeFees: boolean

  Returns SendResponse

send

• send(amount, proofs, options?): 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)

  • Optional options: {
        counter?: number;
        includeFees?: boolean;
        keysetId?: string;
        offline?: boolean;
        outputAmounts?: OutputAmounts;
        privkey?: string;
        proofsWeHave?: Proof[];
        pubkey?: string;
    }

    • Optional counter?: number

    • Optional includeFees?: boolean

    • Optional keysetId?: string

    • Optional offline?: boolean

    • Optional outputAmounts?: OutputAmounts

    • Optional privkey?: string

    • Optional proofsWeHave?: Proof[]

    • Optional pubkey?: string

  Returns Promise<SendResponse>

swap

• swap(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;
        includeFees?: boolean;
        keysetId?: string;
        outputAmounts?: OutputAmounts;
        privkey?: string;
        proofsWeHave?: Proof[];
        pubkey?: string;
    }

    • Optional counter?: number

    • Optional includeFees?: boolean

    • Optional keysetId?: string

    • Optional outputAmounts?: OutputAmounts

    • Optional privkey?: string

    • Optional proofsWeHave?: Proof[]

    • Optional pubkey?: string

  Returns Promise<SendResponse>

  promise of the change- and send-proofs