@babbage/sdk-ts

@babbage/sdk-ts

Build Babbage apps in TypeScript

NPM Package

GitHub Repository

Installation

npm i @babbage/sdk

By Example

There are a few example projects you can check out which implement the Babbage SDK:

• Tempo: A platform for creating and sharing music, and empowering artists with micropayments
• Simple ToDo List: An app that demonstrates the basics of Bitcoin tokenization and identity

Documentation

The JavaScript API is documented below the examples, in the API section

The Babbage Learn website hosts the concepts, guides and reference materials that show you how the SDK works.

Example Usage

Encryption

import { encrypt, decrypt } from '@babbage/sdk-ts'

// Encrypt and decrypt data using the Babbage SDK
const encryptedData = await encrypt({
  plaintext: Buffer.from('some data'),
  protocolID: [0, 'Hello World'],
  keyID: '1'
})

// The same protocol and key ID is needed for decryption
const decryptedData = await decrypt({
  ciphertext: encryptedData,
  protocolID: [0, 'Hello World'],
  keyID: '1',
  returnType: 'string'
})

Creating and Redeeming Bitcoin tokens

This example also uses PushDrop

import { createAction } from '@babbage/sdk-ts'
import { create, redeem } from 'pushdrop'

const bitcoinOutputScript = await create({
  fields: [ // The "fields" are the data payload to attach to the token.
    Buffer.from('My First Token'),
    Buffer.from('My name is Ty') // Tokens can represent anything!
  ],
  // The "first token" protocol and key ID can be used to sign and 
  // lock this new Bitcoin PushDrop token.
  protocolID: 'first token',
  keyID: '1'
})

const newToken = await createAction({
  // The Bitcoin transaction ("Action" with a capital A) has an output, 
  // because it has led to the creation of a new Bitcoin token.
  outputs: [{
    // The output amount is how much Bitcoin (measured in "satoshis") 
    // this token is worth. Let's use 1000 satoshis.
    satoshis: 1000,
    // The output script for this token was created by the PushDrop library, 
    // which you can see above.
    script: bitcoinOutputScript
  }],
  // Finally, we'll describe the Action for the user
  description: 'Create my first token'
})

// Here, we're using the PushDrop library to unlcok / redeem the PushDrop 
// token that was previously created. By providing this information, 
// PushDrop can "unlock" and spend the token. When the token gets spent, 
// the user gets their 1000 satoshis back.
const unlockingScript = await pushdrop.redeem({
  // To unlock the token, we need to use the same "first token" protocol 
  // and key ID as when we created the token before. Otherwise, the 
  // key won't fit the lock and the Bitcoins won't come out.
  protocolID: 'first token',
  keyID: '1',
  // We're telling PushDrop which previous transaction and output we want to
  // unlock, so that the correct unlocking puzzle can be prepared.
  prevTxId: newToken.txid,
  outputIndex: 0, // The first output from the transaction
  // We also give PushDrop a copy of the locking puzzle ("script") that 
  // we want to open, which is helpful in preparing to unlock it.
  lockingScript: bitcoinOutputScript,
  // Finally, the number of satoshis we are expecting to unlock when the 
  // puzzle gets solved.
  outputAmount: 1000
})

// Now, we're going to use the unlocking puzle that PushDrop has prepared for us,
// so that the user can get their Bitcoins back. This is another "Action", which
// is just a Bitcoin transaction.
// The amount the user gets back will be slightly less, because of transaction fees.
await createAction({
  inputs: { // These are inputs, which unlock Bitcoin tokens.
    // The input comes from the token which we're completing
    [newToken.txid]: {
      ...newToken,
      // The output we want to redeem is specified here, and we also give 
      // the unlocking puzzle ("script") from PushDrop.
      outputsToRedeem: [{
        index: 0, // The first output of the transaction
        unlockingScript
      }]
    }
  },
  // Let the user know why they're getting some Bitcoins back
  description: 'Redeem my first token'
})

After reading the above two examples, could you implement a token with encrypted data?

API

Links: API, Interfaces, Classes, Functions, Types, Variables

Interfaces

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: AbortActionArgs

export interface AbortActionArgs {
    reference: Base64String;
}

See also: Base64String

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: AbortActionResult

export interface AbortActionResult {
    referenceNumber: string;
    log?: string;
}

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: AbortActionResult

export interface AbortActionResult {
    aborted: boolean;
}

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: AcquireCertificateArgs

export interface AcquireCertificateArgs {
    type: Base64String;
    certifier: PubKeyHex;
    acquisitionProtocol: AcquisitionProtocol;
    fields: Record<CertificateFieldNameUnder50Bytes, string>;
    serialNumber?: Base64String;
    revocationOutpoint?: OutpointString;
    signature?: HexString;
    certifierUrl?: string;
    keyringRevealer?: KeyringRevealer;
    keyringForSubject?: Record<CertificateFieldNameUnder50Bytes, Base64String>;
    privileged?: BooleanDefaultFalse;
    privilegedReason?: DescriptionString5to50Bytes;
}

See also: AcquisitionProtocol, Base64String, BooleanDefaultFalse, CertificateFieldNameUnder50Bytes, DescriptionString5to50Bytes, HexString, KeyringRevealer, OutpointString, PubKeyHex

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: AcquireCertificateResult

export interface AcquireCertificateResult extends WalletCertificate {
}

See also: WalletCertificate

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: AuthenticatedResult

export interface AuthenticatedResult {
    authenticated: boolean;
}

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: BasketInsertion

export interface BasketInsertion {
    basket: BasketStringUnder300Bytes;
    customInstructions?: string;
    tags?: OutputTagStringUnder300Bytes[];
}

See also: BasketStringUnder300Bytes, OutputTagStringUnder300Bytes

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: CertificateApi

export interface CertificateApi {
    type: string;
    subject: string;
    validationKey: string;
    serialNumber: string;
    certifier: string;
    revocationOutpoint: string;
    signature: string;
    fields?: Record<string, string>;
}

certifier: string

fields?: Record<string, string>

revocationOutpoint: string

serialNumber: string

signature: string

subject: string

type: string

validationKey: string

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: CounterpartyKeyLinkageResult

export interface CounterpartyKeyLinkageResult {
    type: "counterparty-revelation";
    prover: string;
    verifier: string;
    counterparty: string;
    revelationTime: string;
    encryptedLinkage: string;
}

revelationTime: string

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: CreateActionArgs

export interface CreateActionArgs {
    description: DescriptionString5to50Bytes;
    inputBEEF?: BEEF;
    inputs?: CreateActionInput[];
    outputs?: CreateActionOutput[];
    lockTime?: PositiveIntegerOrZero;
    version?: PositiveIntegerOrZero;
    labels?: LabelStringUnder300Bytes[];
    options?: CreateActionOptions;
}

See also: BEEF, CreateActionInput, CreateActionOptions, CreateActionOutput, DescriptionString5to50Bytes, LabelStringUnder300Bytes, PositiveIntegerOrZero

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: CreateActionInput

export interface CreateActionInput extends OptionalEnvelopeEvidenceApi {
    outputsToRedeem: CreateActionOutputToRedeem[];
}

See also: CreateActionOutputToRedeem, OptionalEnvelopeEvidenceApi

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: CreateActionInput

export interface CreateActionInput {
    outpoint: OutpointString;
    inputDescription: DescriptionString5to50Bytes;
    unlockingScript?: HexString;
    unlockingScriptLength?: PositiveInteger;
    sequenceNumber?: PositiveIntegerOrZero;
}

See also: DescriptionString5to50Bytes, HexString, OutpointString, PositiveInteger, PositiveIntegerOrZero

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: CreateActionOptions

export interface CreateActionOptions {
    acceptDelayedBroadcast?: boolean;
    trustSelf?: TrustSelf;
    knownTxids?: string[];
    resultFormat?: "beef" | "none";
    noSend?: boolean;
    noSendChange?: OutPoint[];
    sendWith?: string[];
    randomizeOutputs?: boolean;
}

See also: OutPoint, TrustSelf

acceptDelayedBroadcast?: boolean

knownTxids?: string[]

noSend?: boolean

noSendChange?: OutPoint[]

randomizeOutputs?: boolean

resultFormat?: "beef" | "none"

sendWith?: string[]

trustSelf?: TrustSelf

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: CreateActionOptions

export interface CreateActionOptions {
    signAndProcess?: BooleanDefaultTrue;
    acceptDelayedBroadcast?: BooleanDefaultTrue;
    trustSelf?: TrustSelf;
    knownTxids?: TXIDHexString[];
    returnTXIDOnly?: BooleanDefaultFalse;
    noSend?: BooleanDefaultFalse;
    noSendChange?: OutpointString[];
    sendWith?: TXIDHexString[];
    randomizeOutputs?: BooleanDefaultTrue;
}

See also: BooleanDefaultFalse, BooleanDefaultTrue, OutpointString, TXIDHexString, TrustSelf

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: CreateActionOutput

A specific output to be created as part of a new transactions. These outputs can contain custom scripts as specified by recipients.

export interface CreateActionOutput {
    script: string;
    satoshis: number;
    description?: string;
    basket?: string;
    customInstructions?: string;
    tags?: string[];
}

basket?: string

customInstructions?: string

description?: string

satoshis: number

script: string

tags?: string[]

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: CreateActionOutput

export interface CreateActionOutput {
    lockingScript: HexString;
    satoshis: SatoshiValue;
    outputDescription: DescriptionString5to50Bytes;
    basket?: BasketStringUnder300Bytes;
    customInstructions?: string;
    tags?: OutputTagStringUnder300Bytes[];
}

See also: BasketStringUnder300Bytes, DescriptionString5to50Bytes, HexString, OutputTagStringUnder300Bytes, SatoshiValue

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: CreateActionOutputToRedeem

export interface CreateActionOutputToRedeem {
    index: number;
    unlockingScript: string | number;
    spendingDescription?: string;
    sequenceNumber?: number;
}

index: number

sequenceNumber?: number

unlockingScript: string | number

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: CreateActionParams

export interface CreateActionParams {
    description: string;
    inputs?: Record<string, CreateActionInput>;
    beef?: Beef | number[];
    outputs?: CreateActionOutput[];
    lockTime?: number;
    version?: number;
    labels?: string[];
    originator?: string;
    options?: CreateActionOptions;
    acceptDelayedBroadcast?: boolean;
    log?: string;
}

See also: CreateActionInput, CreateActionOptions, CreateActionOutput

acceptDelayedBroadcast?: boolean

beef?: Beef | number[]

description: string

inputs?: Record<string, CreateActionInput>

labels?: string[]

lockTime?: number

options?: CreateActionOptions

originator?: string

outputs?: CreateActionOutput[]

version?: number

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: CreateActionResult

export interface CreateActionResult {
    signActionRequired?: boolean;
    createResult?: DojoCreateTransactionResultApi;
    txid?: string;
    rawTx?: string;
    inputs?: Record<string, OptionalEnvelopeEvidenceApi>;
    beef?: number[];
    noSendChange?: OutPoint[];
    mapiResponses?: MapiResponseApi[];
    sendWithResults?: DojoSendWithResultsApi[];
    options?: CreateActionOptions;
    log?: string;
}

See also: CreateActionOptions, DojoCreateTransactionResultApi, DojoSendWithResultsApi, MapiResponseApi, OptionalEnvelopeEvidenceApi, OutPoint

beef?: number[]

createResult?: DojoCreateTransactionResultApi

inputs?: Record<string, OptionalEnvelopeEvidenceApi>

log?: string

mapiResponses?: MapiResponseApi[]

noSendChange?: OutPoint[]

options?: CreateActionOptions

rawTx?: string

signActionRequired?: boolean

txid?: string

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: CreateActionResult

export interface CreateActionResult {
    txid?: TXIDHexString;
    tx?: AtomicBEEF;
    noSendChange?: OutpointString[];
    sendWithResults?: SendWithResult[];
    signableTransaction?: SignableTransaction;
}

See also: AtomicBEEF, OutpointString, SendWithResult, SignableTransaction, TXIDHexString

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: CreateCertificateResult

export interface CreateCertificateResult extends CertificateApi {
    type: string;
    subject: string;
    validationKey: string;
    serialNumber: string;
    certifier: string;
    revocationOutpoint: string;
    signature: string;
    fields?: Record<string, string>;
    masterKeyring?: Record<string, string>;
}

See also: CertificateApi

certifier: string

fields?: Record<string, string>

masterKeyring?: Record<string, string>

revocationOutpoint: string

serialNumber: string

signature: string

subject: string

type: string

validationKey: string

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: CreateHmacArgs

export interface CreateHmacArgs extends WalletEncryptionArgs {
    data: Byte[];
}

See also: Byte, WalletEncryptionArgs

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: CreateHmacResult

export interface CreateHmacResult {
    hmac: Byte[];
}

See also: Byte

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: CreateSignatureArgs

export interface CreateSignatureArgs extends WalletEncryptionArgs {
    data?: Byte[];
    hashToDirectlySign?: Byte[];
}

See also: Byte, WalletEncryptionArgs

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: CreateSignatureResult

export interface CreateSignatureResult {
    signature: Byte[];
}

See also: Byte

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: DiscoverByAttributesArgs

export interface DiscoverByAttributesArgs {
    attributes: Record<CertificateFieldNameUnder50Bytes, string>;
    limit?: PositiveIntegerDefault10Max10000;
    offset?: PositiveIntegerOrZero;
    seekPermission?: BooleanDefaultTrue;
}

See also: BooleanDefaultTrue, CertificateFieldNameUnder50Bytes, PositiveIntegerDefault10Max10000, PositiveIntegerOrZero

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: DiscoverByIdentityKeyArgs

export interface DiscoverByIdentityKeyArgs {
    identityKey: PubKeyHex;
    limit?: PositiveIntegerDefault10Max10000;
    offset?: PositiveIntegerOrZero;
    seekPermission?: BooleanDefaultTrue;
}

See also: BooleanDefaultTrue, PositiveIntegerDefault10Max10000, PositiveIntegerOrZero, PubKeyHex

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: DiscoverCertificatesResult

export interface DiscoverCertificatesResult {
    totalCertificates: PositiveIntegerOrZero;
    certificates: IdentityCertificate[];
}

See also: IdentityCertificate, PositiveIntegerOrZero

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: DojoCreateTransactionResultApi

export interface DojoCreateTransactionResultApi {
    inputs: Record<string, DojoCreatingTxInputsApi>;
    outputs: DojoCreateTxResultOutputApi[];
    derivationPrefix: string;
    version: number;
    lockTime: number;
    referenceNumber: string;
    paymailHandle: string;
    note?: string;
    log?: string;
}

See also: DojoCreateTxResultOutputApi, DojoCreatingTxInputsApi

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: DojoCreateTxOutputApi

A specific output to be created as part of a new transactions. These outputs can contain custom scripts as specified by recipients.

export interface DojoCreateTxOutputApi {
    script: string;
    satoshis: number;
    description?: string;
    basket?: string;
    customInstructions?: string;
    tags?: string[];
}

basket?: string

customInstructions?: string

description?: string

satoshis: number

script: string

tags?: string[]

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: DojoCreateTxResultInstructionsApi

export interface DojoCreateTxResultInstructionsApi {
    type: string;
    derivationPrefix?: string;
    derivationSuffix?: string;
    senderIdentityKey?: string;
    paymailHandle?: string;
}

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: DojoCreateTxResultOutputApi

export interface DojoCreateTxResultOutputApi extends DojoCreateTxOutputApi {
    providedBy: DojoProvidedByApi;
    purpose?: string;
    destinationBasket?: string;
    derivationSuffix?: string;
    keyOffset?: string;
}

See also: DojoCreateTxOutputApi, DojoProvidedByApi

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: DojoCreatingTxInputsApi

export interface DojoCreatingTxInputsApi extends EnvelopeEvidenceApi {
    outputsToRedeem: DojoOutputToRedeemApi[];
    providedBy: DojoProvidedByApi;
    instructions: Record<number, DojoCreateTxResultInstructionsApi>;
}

See also: DojoCreateTxResultInstructionsApi, DojoOutputToRedeemApi, DojoProvidedByApi, EnvelopeEvidenceApi

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: DojoOutputToRedeemApi

export interface DojoOutputToRedeemApi {
    index: number;
    unlockingScriptLength: number;
    spendingDescription?: string;
}

index: number

unlockingScriptLength: number

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: DojoSendWithResultsApi

export interface DojoSendWithResultsApi {
    txid: string;
    transactionId: number;
    reference: string;
    status: "unproven" | "failed" | "sending";
}

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: EnvelopeApi

Simplest case of an envelope is a rawTx and merkle proof that ties the transaction to a known block header. This will be the case for any sufficiently old transaction.

If the transaction has been mined but for some reason the block headers may not be known, an array of headers linking known headers to the one needed by the proof may be provided. They must be in height order and need to overlap a known header.

If the transaction has not been minded yet but it has been submitted to one or more miners then the mapi responses received, proving that specific miners have received the transaction for processing, are included in the mapiResponses array. Note that the miner reputations must be checked to give weight to these responses.

Additionally, when the transaction hasn't been mined or a proof is unavailable and mapi responses proving miner acceptance are unavailable, then all the transactions providing inputs can be submitted in an inputs object.

The keys of the inputs object are the transaction hashes (txids) of each of the input transactions. The value of each inputs object property is another envelope object.

References: Section 2 of https://projectbabbage.com/assets/simplified-payments.pdf https://gist.github.com/ty-everett/44b6a0e7f3d6c48439f9ff26068f8d8b

export interface EnvelopeApi extends EnvelopeEvidenceApi {
    headers?: string[];
    reference?: string;
}

See also: EnvelopeEvidenceApi

headers?: string[]

reference?: string

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: EnvelopeEvidenceApi

Either inputs or proof are required.

export interface EnvelopeEvidenceApi {
    rawTx: string;
    proof?: TscMerkleProofApi | Buffer;
    inputs?: Record<string, EnvelopeEvidenceApi>;
    txid?: string;
    mapiResponses?: MapiResponseApi[];
    depth?: number;
}

See also: MapiResponseApi, TscMerkleProofApi

depth?: number

inputs?: Record<string, EnvelopeEvidenceApi>

mapiResponses?: MapiResponseApi[]

proof?: TscMerkleProofApi | Buffer

rawTx: string

txid?: string

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: GetHeaderArgs

export interface GetHeaderArgs {
    height: PositiveInteger;
}

See also: PositiveInteger

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: GetHeaderResult

export interface GetHeaderResult {
    header: HexString;
}

See also: HexString

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: GetHeightResult

export interface GetHeightResult {
    height: PositiveInteger;
}

See also: PositiveInteger

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: GetInfoParams

export interface GetInfoParams {
    description?: string;
}

description?: string

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: GetInfoResult

export interface GetInfoResult {
    metanetClientVersion: string;
    chain: Chain;
    height: number;
    userId: number;
    userIdentityKey: string;
    dojoIdentityKey: string;
    dojoIdentityName?: string;
    perferredCurrency: string;
}

See also: Chain

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: GetNetworkResult

export interface GetNetworkResult {
    network: WalletNetwork;
}

See also: WalletNetwork

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: GetPublicKeyArgs

When identityKey is true, WalletEncryptionArgs are not used.

When identityKey is undefined, WalletEncryptionArgs are required.

export interface GetPublicKeyArgs extends Partial<WalletEncryptionArgs> {
    identityKey?: true;
    forSelf?: BooleanDefaultFalse;
}

See also: BooleanDefaultFalse, WalletEncryptionArgs

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: GetPublicKeyResult

export interface GetPublicKeyResult {
    publicKey: PubKeyHex;
}

See also: PubKeyHex

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: GetTransactionOutputResult

export interface GetTransactionOutputResult {
    txid: string;
    vout: number;
    amount: number;
    outputScript: string;
    type: string;
    spendable: boolean;
    envelope?: EnvelopeApi;
    customInstructions?: string;
    basket?: string;
    tags?: string[];
}

See also: EnvelopeApi

amount: number

basket?: string

customInstructions?: string

envelope?: EnvelopeApi

outputScript: string

spendable: boolean

tags?: string[]

txid: string

type: string

vout: number

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: GetVersionResult

export interface GetVersionResult {
    version: VersionString7To30Bytes;
}

See also: VersionString7To30Bytes

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: IdentityCertificate

export interface IdentityCertificate extends WalletCertificate {
    certifierInfo: IdentityCertifier;
    publiclyRevealedKeyring: Record<CertificateFieldNameUnder50Bytes, Base64String>;
    decryptedFields: Record<CertificateFieldNameUnder50Bytes, string>;
}

See also: Base64String, CertificateFieldNameUnder50Bytes, IdentityCertifier, WalletCertificate

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: IdentityCertifier

export interface IdentityCertifier {
    name: EntityNameStringMax100Bytes;
    iconUrl: EntityIconURLStringMax500Bytes;
    description: DescriptionString5to50Bytes;
    trust: PositiveIntegerMax10;
}

See also: DescriptionString5to50Bytes, EntityIconURLStringMax500Bytes, EntityNameStringMax100Bytes, PositiveIntegerMax10

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: InternalizeActionArgs

export interface InternalizeActionArgs {
    tx: AtomicBEEF;
    outputs: InternalizeOutput[];
    description: DescriptionString5to50Bytes;
    labels?: LabelStringUnder300Bytes[];
    seekPermission?: BooleanDefaultTrue;
}

See also: AtomicBEEF, BooleanDefaultTrue, DescriptionString5to50Bytes, InternalizeOutput, LabelStringUnder300Bytes

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: InternalizeActionResult

export interface InternalizeActionResult {
    accepted: true;
}

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: InternalizeOutput

export interface InternalizeOutput {
    outputIndex: PositiveIntegerOrZero;
    protocol: "wallet payment" | "basket insertion";
    paymentRemittance?: WalletPayment;
    insertionRemittance?: BasketInsertion;
}

See also: BasketInsertion, PositiveIntegerOrZero, WalletPayment

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: KeyDeriverApi

export interface KeyDeriverApi {
    rootKey: PrivateKey;
    identityKey: string;
    derivePublicKey(protocolID: WalletProtocol, keyID: string, counterparty: Counterparty, forSelf?: boolean): PublicKey;
    derivePrivateKey(protocolID: WalletProtocol, keyID: string, counterparty: Counterparty): PrivateKey;
    deriveSymmetricKey(protocolID: WalletProtocol, keyID: string, counterparty: Counterparty): SymmetricKey;
    revealCounterpartySecret(counterparty: Counterparty): number[];
    revealSpecificSecret(counterparty: Counterparty, protocolID: WalletProtocol, keyID: string): number[];
}

See also: Counterparty, WalletProtocol

identityKey: string

rootKey: PrivateKey

derivePrivateKey(protocolID: WalletProtocol, keyID: string, counterparty: Counterparty): PrivateKey

derivePublicKey(protocolID: WalletProtocol, keyID: string, counterparty: Counterparty, forSelf?: boolean): PublicKey

deriveSymmetricKey(protocolID: WalletProtocol, keyID: string, counterparty: Counterparty): SymmetricKey

revealCounterpartySecret(counterparty: Counterparty): number[]

revealSpecificSecret(counterparty: Counterparty, protocolID: WalletProtocol, keyID: string): number[]

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: KeyLinkageResult

export interface KeyLinkageResult {
    encryptedLinkage: Byte[];
    encryptedLinkageProof: Byte[];
    prover: PubKeyHex;
    verifier: PubKeyHex;
    counterparty: PubKeyHex;
}

See also: Byte, PubKeyHex

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: ListActionsArgs

export interface ListActionsArgs {
    labels: LabelStringUnder300Bytes[];
    labelQueryMode?: "any" | "all";
    includeLabels?: BooleanDefaultFalse;
    includeInputs?: BooleanDefaultFalse;
    includeInputSourceLockingScripts?: BooleanDefaultFalse;
    includeInputUnlockingScripts?: BooleanDefaultFalse;
    includeOutputs?: BooleanDefaultFalse;
    includeOutputLockingScripts?: BooleanDefaultFalse;
    limit?: PositiveIntegerDefault10Max10000;
    offset?: PositiveIntegerOrZero;
    seekPermission?: BooleanDefaultTrue;
}

See also: BooleanDefaultFalse, BooleanDefaultTrue, LabelStringUnder300Bytes, PositiveIntegerDefault10Max10000, PositiveIntegerOrZero

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: ListActionsResult

export interface ListActionsResult {
    totalTransactions: number;
    transactions: ListActionsTransaction[];
}

See also: ListActionsTransaction

totalTransactions: number

transactions: ListActionsTransaction[]

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: ListActionsResult

export interface ListActionsResult {
    totalActions: PositiveIntegerOrZero;
    actions: WalletAction[];
}

See also: PositiveIntegerOrZero, WalletAction

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: ListActionsTransaction

export interface ListActionsTransaction {
    txid: string;
    amount: number;
    status: TransactionStatusApi;
    senderPaymail: string;
    recipientPaymail: string;
    isOutgoing: boolean;
    note: string;
    created_at: string;
    referenceNumber: string;
    labels: string[];
    inputs?: ListActionsTransactionInput[];
    outputs?: ListActionsTransactionOutput[];
}

See also: ListActionsTransactionInput, ListActionsTransactionOutput, TransactionStatusApi

amount: number

created_at: string

isOutgoing: boolean

labels: string[]

note: string

recipientPaymail: string

referenceNumber: string

senderPaymail: string

status: TransactionStatusApi

txid: string

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: ListActionsTransactionInput

export interface ListActionsTransactionInput {
    txid: string;
    vout: number;
    amount: number;
    outputScript: string;
    type: string;
    spendable: boolean;
    spendingDescription?: string;
    basket?: string;
    tags?: string[];
}

amount: number

basket?: string

outputScript: string

spendable: boolean

spendingDescription?: string

tags?: string[]

txid: string

type: string

vout: number

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: ListActionsTransactionOutput

export interface ListActionsTransactionOutput {
    txid: string;
    vout: number;
    amount: number;
    outputScript: string;
    type: string;
    spendable: boolean;
    description?: string;
    basket?: string;
    tags?: string[];
}

amount: number

basket?: string

description?: string

outputScript: string

spendable: boolean

tags?: string[]

txid: string

type: string

vout: number

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: ListCertificatesArgs

export interface ListCertificatesArgs {
    certifiers: PubKeyHex[];
    types: Base64String[];
    limit?: PositiveIntegerDefault10Max10000;
    offset?: PositiveIntegerOrZero;
    privileged?: BooleanDefaultFalse;
    privilegedReason?: DescriptionString5to50Bytes;
}

See also: Base64String, BooleanDefaultFalse, DescriptionString5to50Bytes, PositiveIntegerDefault10Max10000, PositiveIntegerOrZero, PubKeyHex

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: ListCertificatesResult

export interface ListCertificatesResult {
    totalCertificates: PositiveIntegerOrZero;
    certificates: WalletCertificate[];
}

See also: PositiveIntegerOrZero, WalletCertificate

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: ListOutputsArgs

export interface ListOutputsArgs {
    basket: BasketStringUnder300Bytes;
    tags?: OutputTagStringUnder300Bytes[];
    tagQueryMode?: "all" | "any";
    include?: "locking scripts" | "entire transactions";
    includeCustomInstructions?: BooleanDefaultFalse;
    includeTags?: BooleanDefaultFalse;
    includeLabels?: BooleanDefaultFalse;
    limit?: PositiveIntegerDefault10Max10000;
    offset?: PositiveIntegerOrZero;
    seekPermission?: BooleanDefaultTrue;
}

See also: BasketStringUnder300Bytes, BooleanDefaultFalse, BooleanDefaultTrue, OutputTagStringUnder300Bytes, PositiveIntegerDefault10Max10000, PositiveIntegerOrZero

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: ListOutputsResult

export interface ListOutputsResult {
    totalOutputs: PositiveIntegerOrZero;
    BEEF?: BEEF;
    outputs: WalletOutput[];
}

See also: BEEF, PositiveIntegerOrZero, WalletOutput

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: MapiResponseApi

export interface MapiResponseApi {
    payload: string;
    signature: string;
    publicKey: string;
    encoding?: string;
    mimetype?: string;
}

encoding?: string

mimetype?: string

payload: string

publicKey: string

signature: string

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: OptionalEnvelopeEvidenceApi

Either rawTx or txid are required. If txid, then it must be a known transaction.

If not a known trxid, either inputs or proof are required.

export interface OptionalEnvelopeEvidenceApi {
    rawTx?: string;
    proof?: TscMerkleProofApi | Buffer;
    inputs?: Record<string, OptionalEnvelopeEvidenceApi>;
    txid?: string;
    mapiResponses?: MapiResponseApi[];
    depth?: number;
}

See also: MapiResponseApi, TscMerkleProofApi

depth?: number

inputs?: Record<string, OptionalEnvelopeEvidenceApi>

mapiResponses?: MapiResponseApi[]

proof?: TscMerkleProofApi | Buffer

rawTx?: string

txid?: string

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: OutPoint

Identifies a unique transaction output by its txid and index vout

export interface OutPoint {
    txid: string;
    vout: number;
}

txid: string

vout: number

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: ProveCertificateArgs

export interface ProveCertificateArgs {
    certificate: WalletCertificate;
    fieldsToReveal: CertificateFieldNameUnder50Bytes[];
    verifier: PubKeyHex;
    privileged?: BooleanDefaultFalse;
    privilegedReason?: DescriptionString5to50Bytes;
}

See also: BooleanDefaultFalse, CertificateFieldNameUnder50Bytes, DescriptionString5to50Bytes, PubKeyHex, WalletCertificate

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: ProveCertificateResult

export interface ProveCertificateResult extends CertificateApi {
    type: string;
    subject: string;
    validationKey: string;
    serialNumber: string;
    certifier: string;
    revocationOutpoint: string;
    signature: string;
    fields?: Record<string, string>;
    keyring: Record<string, string>;
}

See also: CertificateApi

certifier: string

fields?: Record<string, string>

keyring: Record<string, string>

revocationOutpoint: string

serialNumber: string

signature: string

subject: string

type: string

validationKey: string

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: ProveCertificateResult

export interface ProveCertificateResult {
    keyringForVerifier: Record<CertificateFieldNameUnder50Bytes, Base64String>;
}

See also: Base64String, CertificateFieldNameUnder50Bytes

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: RelinquishCertificateArgs

export interface RelinquishCertificateArgs {
    type: Base64String;
    serialNumber: Base64String;
    certifier: PubKeyHex;
}

See also: Base64String, PubKeyHex

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: RelinquishCertificateResult

export interface RelinquishCertificateResult {
    relinquished: boolean;
}

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: RelinquishOutputArgs

export interface RelinquishOutputArgs {
    basket: BasketStringUnder300Bytes;
    output: OutpointString;
}

See also: BasketStringUnder300Bytes, OutpointString

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: RelinquishOutputResult

export interface RelinquishOutputResult {
    relinquished: true;
}

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: RevealCounterpartyKeyLinkageArgs

export interface RevealCounterpartyKeyLinkageArgs {
    counterparty: PubKeyHex;
    verifier: PubKeyHex;
    privileged?: BooleanDefaultFalse;
    privilegedReason?: DescriptionString5to50Bytes;
}

See also: BooleanDefaultFalse, DescriptionString5to50Bytes, PubKeyHex

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: RevealCounterpartyKeyLinkageResult

export interface RevealCounterpartyKeyLinkageResult extends KeyLinkageResult {
    revelationTime: ISOTimestampString;
}

See also: ISOTimestampString, KeyLinkageResult

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: RevealSpecificKeyLinkageArgs

export interface RevealSpecificKeyLinkageArgs {
    counterparty: WalletCounterparty;
    verifier: PubKeyHex;
    protocolID: WalletProtocol;
    keyID: KeyIDStringUnder800Bytes;
    privilegedReason?: DescriptionString5to50Bytes;
    privileged?: BooleanDefaultFalse;
}

See also: BooleanDefaultFalse, DescriptionString5to50Bytes, KeyIDStringUnder800Bytes, PubKeyHex, WalletCounterparty, WalletProtocol

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: RevealSpecificKeyLinkageResult

export interface RevealSpecificKeyLinkageResult extends KeyLinkageResult {
    protocolID: WalletProtocol;
    keyID: KeyIDStringUnder800Bytes;
    proofType: Byte;
}

See also: Byte, KeyIDStringUnder800Bytes, KeyLinkageResult, WalletProtocol

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: SendWithResult

export interface SendWithResult {
    txid: TXIDHexString;
    status: SendWithResultStatus;
}

See also: SendWithResultStatus, TXIDHexString

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: SignActionArgs

export interface SignActionArgs {
    spends: Record<PositiveIntegerOrZero, SignActionSpend>;
    reference: Base64String;
    options?: SignActionOptions;
}

See also: Base64String, PositiveIntegerOrZero, SignActionOptions, SignActionSpend

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: SignActionOptions

export interface SignActionOptions {
    acceptDelayedBroadcast?: BooleanDefaultTrue;
    returnTXIDOnly?: BooleanDefaultFalse;
    noSend?: BooleanDefaultFalse;
    sendWith?: TXIDHexString[];
}

See also: BooleanDefaultFalse, BooleanDefaultTrue, TXIDHexString

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: SignActionResult

export interface SignActionResult {
    rawTx: string;
    inputs: Record<string, EnvelopeEvidenceApi>;
    mapiResponses: MapiResponseApi[];
    txid: string;
    log?: string;
}

See also: EnvelopeEvidenceApi, MapiResponseApi

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: SignActionResult

export interface SignActionResult {
    txid?: TXIDHexString;
    tx?: AtomicBEEF;
    sendWithResults?: SendWithResult[];
}

See also: AtomicBEEF, SendWithResult, TXIDHexString

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: SignActionSpend

export interface SignActionSpend {
    unlockingScript: HexString;
    sequenceNumber?: PositiveIntegerOrZero;
}

See also: HexString, PositiveIntegerOrZero

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: SignableTransaction

export interface SignableTransaction {
    tx: AtomicBEEF;
    reference: Base64String;
}

See also: AtomicBEEF, Base64String

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: SpecificKeyLinkageResult

export interface SpecificKeyLinkageResult {
    type: "specific-revelation";
    prover: string;
    verifier: string;
    counterparty: string;
    protocolID: ProtocolID;
    encryptedLinkage: string;
}

See also: ProtocolID

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: SubmitDirectTransaction

export interface SubmitDirectTransaction {
    rawTx: string;
    txid?: string;
    inputs?: Record<string, OptionalEnvelopeEvidenceApi>;
    mapiResponses?: MapiResponseApi[];
    proof?: TscMerkleProofApi;
    outputs: SubmitDirectTransactionOutput[];
    referenceNumber?: string;
}

See also: MapiResponseApi, OptionalEnvelopeEvidenceApi, SubmitDirectTransactionOutput, TscMerkleProofApi

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: SubmitDirectTransactionOutput

export interface SubmitDirectTransactionOutput {
    vout: number;
    satoshis: number;
    basket?: string;
    derivationPrefix?: string;
    derivationSuffix?: string;
    customInstructions?: string;
    senderIdentityKey?: string;
    tags?: string[];
}

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: SubmitDirectTransactionResult

export interface SubmitDirectTransactionResult {
    transactionId: number;
    referenceNumber: string;
}

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: TscMerkleProofApi

As defined in https://github.com/bitcoin-sv-specs/brfc-merchantapi/blob/master/README.md

export interface TscMerkleProofApi {
    height?: number;
    index: number;
    txOrId: string | Buffer;
    target: string | Buffer;
    nodes: string[] | Buffer;
    targetType?: "hash" | "header" | "merkleRoot" | "height";
    proofType?: "branch" | "tree";
    composite?: boolean;
}

height?: number

index: number

nodes: string[] | Buffer

target: string | Buffer

txOrId: string | Buffer

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: ValidAbortActionArgs

export interface ValidAbortActionArgs {
    reference: sdk.Base64String;
    log?: string;
}

See also: Base64String

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: ValidAcquireCertificateArgs

export interface ValidAcquireCertificateArgs {
    type: sdk.Base64String;
    certifier: sdk.PubKeyHex;
    acquisitionProtocol: sdk.AcquisitionProtocol;
    fields: Record<sdk.CertificateFieldNameUnder50Bytes, string>;
    serialNumber?: sdk.Base64String;
    revocationOutpoint?: sdk.OutpointString;
    signature?: sdk.HexString;
    certifierUrl?: string;
    keyringRevealer?: sdk.KeyringRevealer;
    keyringForSubject?: Record<sdk.CertificateFieldNameUnder50Bytes, sdk.Base64String>;
    privileged?: sdk.BooleanDefaultFalse;
    privilegedReason?: sdk.DescriptionString5to50Bytes;
    log?: string;
}

See also: AcquisitionProtocol, Base64String, BooleanDefaultFalse, CertificateFieldNameUnder50Bytes, DescriptionString5to50Bytes, HexString, KeyringRevealer, OutpointString, PubKeyHex

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: ValidBasketInsertion

export interface ValidBasketInsertion {
    basket: sdk.BasketStringUnder300Bytes;
    customInstructions?: string;
    tags: sdk.OutputTagStringUnder300Bytes[];
}

See also: BasketStringUnder300Bytes, OutputTagStringUnder300Bytes

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: ValidCreateActionArgs

export interface ValidCreateActionArgs extends ValidProcessActionArgs {
    description: sdk.DescriptionString5to50Bytes;
    inputBEEF?: sdk.BEEF;
    inputs: sdk.ValidCreateActionInput[];
    outputs: sdk.ValidCreateActionOutput[];
    lockTime: number;
    version: number;
    labels: string[];
    options: ValidCreateActionOptions;
    isSignAction: boolean;
}

See also: BEEF, DescriptionString5to50Bytes, ValidCreateActionInput, ValidCreateActionOptions, ValidCreateActionOutput, ValidProcessActionArgs

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: ValidCreateActionInput

export interface ValidCreateActionInput {
    outpoint: OutPoint;
    inputDescription: sdk.DescriptionString5to50Bytes;
    sequenceNumber: sdk.PositiveIntegerOrZero;
    unlockingScript?: sdk.HexString;
    unlockingScriptLength: sdk.PositiveInteger;
}

See also: DescriptionString5to50Bytes, HexString, OutPoint, PositiveInteger, PositiveIntegerOrZero

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: ValidCreateActionOptions

export interface ValidCreateActionOptions extends ValidProcessActionOptions {
    signAndProcess: boolean;
    trustSelf?: TrustSelf;
    knownTxids: sdk.TXIDHexString[];
    noSendChange: OutPoint[];
    randomizeOutputs: boolean;
}

See also: OutPoint, TXIDHexString, TrustSelf, ValidProcessActionOptions

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: ValidCreateActionOutput

export interface ValidCreateActionOutput {
    lockingScript: sdk.HexString;
    satoshis: sdk.SatoshiValue;
    outputDescription: sdk.DescriptionString5to50Bytes;
    basket?: sdk.BasketStringUnder300Bytes;
    customInstructions?: string;
    tags: sdk.OutputTagStringUnder300Bytes[];
}

See also: BasketStringUnder300Bytes, DescriptionString5to50Bytes, HexString, OutputTagStringUnder300Bytes, SatoshiValue

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: ValidInternalizeActionArgs

export interface ValidInternalizeActionArgs {
    tx: sdk.AtomicBEEF;
    outputs: sdk.InternalizeOutput[];
    description: sdk.DescriptionString5to50Bytes;
    labels: sdk.LabelStringUnder300Bytes[];
    seekPermission: sdk.BooleanDefaultTrue;
    log?: string;
}

See also: AtomicBEEF, BooleanDefaultTrue, DescriptionString5to50Bytes, InternalizeOutput, LabelStringUnder300Bytes

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: ValidInternalizeOutput

export interface ValidInternalizeOutput {
    outputIndex: sdk.PositiveIntegerOrZero;
    protocol: "wallet payment" | "basket insertion";
    paymentRemittance?: ValidWalletPayment;
    insertionRemittance?: ValidBasketInsertion;
}

See also: PositiveIntegerOrZero, ValidBasketInsertion, ValidWalletPayment

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: ValidListActionsArgs

export interface ValidListActionsArgs {
    labels: sdk.LabelStringUnder300Bytes[];
    labelQueryMode: "any" | "all";
    includeLabels: sdk.BooleanDefaultFalse;
    includeInputs: sdk.BooleanDefaultFalse;
    includeInputSourceLockingScripts: sdk.BooleanDefaultFalse;
    includeInputUnlockingScripts: sdk.BooleanDefaultFalse;
    includeOutputs: sdk.BooleanDefaultFalse;
    includeOutputLockingScripts: sdk.BooleanDefaultFalse;
    limit: sdk.PositiveIntegerDefault10Max10000;
    offset: sdk.PositiveIntegerOrZero;
    seekPermission: sdk.BooleanDefaultTrue;
    log?: string;
}

See also: BooleanDefaultFalse, BooleanDefaultTrue, LabelStringUnder300Bytes, PositiveIntegerDefault10Max10000, PositiveIntegerOrZero

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: ValidListCertificatesArgs

export interface ValidListCertificatesArgs {
    certifiers: sdk.PubKeyHex[];
    types: sdk.Base64String[];
    limit: sdk.PositiveIntegerDefault10Max10000;
    offset: sdk.PositiveIntegerOrZero;
    privileged: sdk.BooleanDefaultFalse;
    privilegedReason?: sdk.DescriptionString5to50Bytes;
    log?: string;
}

See also: Base64String, BooleanDefaultFalse, DescriptionString5to50Bytes, PositiveIntegerDefault10Max10000, PositiveIntegerOrZero, PubKeyHex

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: ValidListOutputsArgs

export interface ValidListOutputsArgs {
    basket: sdk.BasketStringUnder300Bytes;
    tags: sdk.OutputTagStringUnder300Bytes[];
    tagQueryMode: "all" | "any";
    includeLockingScripts: boolean;
    includeTransactions: boolean;
    includeCustomInstructions: sdk.BooleanDefaultFalse;
    includeTags: sdk.BooleanDefaultFalse;
    includeLabels: sdk.BooleanDefaultFalse;
    limit: sdk.PositiveIntegerDefault10Max10000;
    offset: sdk.PositiveIntegerOrZero;
    seekPermission: sdk.BooleanDefaultTrue;
    knownTxids: string[];
    log?: string;
}

See also: BasketStringUnder300Bytes, BooleanDefaultFalse, BooleanDefaultTrue, OutputTagStringUnder300Bytes, PositiveIntegerDefault10Max10000, PositiveIntegerOrZero

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: ValidProcessActionArgs

export interface ValidProcessActionArgs {
    options: sdk.ValidProcessActionOptions;
    isSendWith: boolean;
    isNewTx: boolean;
    isNoSend: boolean;
    isDelayed: boolean;
    log?: string;
}

See also: ValidProcessActionOptions

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: ValidProcessActionOptions

export interface ValidProcessActionOptions {
    acceptDelayedBroadcast: sdk.BooleanDefaultTrue;
    returnTXIDOnly: sdk.BooleanDefaultFalse;
    noSend: sdk.BooleanDefaultFalse;
    sendWith: sdk.TXIDHexString[];
}

See also: BooleanDefaultFalse, BooleanDefaultTrue, TXIDHexString

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: ValidRelinquishOutputArgs

export interface ValidRelinquishOutputArgs {
    basket: sdk.BasketStringUnder300Bytes;
    output: sdk.OutpointString;
    log?: string;
}

See also: BasketStringUnder300Bytes, OutpointString

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: ValidSignActionArgs

export interface ValidSignActionArgs extends ValidProcessActionArgs {
    spends: Record<sdk.PositiveIntegerOrZero, sdk.SignActionSpend>;
    reference: sdk.Base64String;
    options: sdk.ValidSignActionOptions;
}

See also: Base64String, PositiveIntegerOrZero, SignActionSpend, ValidProcessActionArgs, ValidSignActionOptions

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: ValidSignActionOptions

export interface ValidSignActionOptions extends ValidProcessActionOptions {
    acceptDelayedBroadcast: boolean;
    returnTXIDOnly: boolean;
    noSend: boolean;
    sendWith: sdk.TXIDHexString[];
}

See also: TXIDHexString, ValidProcessActionOptions

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: ValidWalletPayment

export interface ValidWalletPayment {
    derivationPrefix: sdk.Base64String;
    derivationSuffix: sdk.Base64String;
    senderIdentityKey: sdk.PubKeyHex;
}

See also: Base64String, PubKeyHex

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: VerifyHmacArgs

export interface VerifyHmacArgs extends WalletEncryptionArgs {
    data: Byte[];
    hmac: Byte[];
}

See also: Byte, WalletEncryptionArgs

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: VerifyHmacResult

export interface VerifyHmacResult {
    valid: boolean;
}

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: VerifySignatureArgs

export interface VerifySignatureArgs extends WalletEncryptionArgs {
    data?: Byte[];
    hashToDirectlyVerify?: Byte[];
    signature: Byte[];
    forSelf?: BooleanDefaultFalse;
}

See also: BooleanDefaultFalse, Byte, WalletEncryptionArgs

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: VerifySignatureResult

export interface VerifySignatureResult {
    valid: true;
}

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: Wallet

The Wallet interface defines a wallet capable of various tasks including transaction creation and signing, encryption, decryption, identity certificate management, identity verification, and communication with applications as per the BRC standards. This interface allows applications to interact with the wallet for a range of functionalities aligned with the Babbage architectural principles.

Error Handling

Every method of the Wallet interface has a return value of the form Promise<object>. When an error occurs, an exception object may be thrown which must conform to the WalletErrorObject interface. Serialization layers can rely on the isError property being unique to error objects to deserialize and rethrow WalletErrorObject conforming objects.

export interface Wallet extends WalletCryptoObject {
    createAction: (args: CreateActionArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<CreateActionResult>;
    signAction: (args: SignActionArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<SignActionResult>;
    abortAction: (args: AbortActionArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<AbortActionResult>;
    listActions: (args: ListActionsArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<ListActionsResult>;
    internalizeAction: (args: InternalizeActionArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<InternalizeActionResult>;
    listOutputs: (args: ListOutputsArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<ListOutputsResult>;
    relinquishOutput: (args: RelinquishOutputArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<RelinquishOutputResult>;
    acquireCertificate: (args: AcquireCertificateArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<AcquireCertificateResult>;
    listCertificates: (args: ListCertificatesArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<ListCertificatesResult>;
    proveCertificate: (args: ProveCertificateArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<ProveCertificateResult>;
    relinquishCertificate: (args: RelinquishCertificateArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<RelinquishCertificateResult>;
    discoverByIdentityKey: (args: DiscoverByIdentityKeyArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<DiscoverCertificatesResult>;
    discoverByAttributes: (args: DiscoverByAttributesArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<DiscoverCertificatesResult>;
    isAuthenticated: (args: {}, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<AuthenticatedResult>;
    waitForAuthentication: (args: {}, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<AuthenticatedResult>;
    getHeight: (args: {}, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<GetHeightResult>;
    getHeaderForHeight: (args: GetHeaderArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<GetHeaderResult>;
    getNetwork: (args: {}, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<GetNetworkResult>;
    getVersion: (args: {}, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<GetVersionResult>;
}

See also: AbortActionArgs, AbortActionResult, AcquireCertificateArgs, AcquireCertificateResult, AuthenticatedResult, CreateActionArgs, CreateActionResult, DiscoverByAttributesArgs, DiscoverByIdentityKeyArgs, DiscoverCertificatesResult, GetHeaderArgs, GetHeaderResult, GetHeightResult, GetNetworkResult, GetVersionResult, InternalizeActionArgs, InternalizeActionResult, ListActionsArgs, ListActionsResult, ListCertificatesArgs, ListCertificatesResult, ListOutputsArgs, ListOutputsResult, OriginatorDomainNameStringUnder250Bytes, ProveCertificateArgs, ProveCertificateResult, RelinquishCertificateArgs, RelinquishCertificateResult, RelinquishOutputArgs, RelinquishOutputResult, SignActionArgs, SignActionResult, WalletCryptoObject, abortAction, createAction, discoverByAttributes, discoverByIdentityKey, getHeight, getNetwork, getVersion, isAuthenticated, listActions, proveCertificate, signAction, waitForAuthentication

abortAction: (args: AbortActionArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<AbortActionResult>

acquireCertificate: (args: AcquireCertificateArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<AcquireCertificateResult>

createAction: (args: CreateActionArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<CreateActionResult>

discoverByAttributes: (args: DiscoverByAttributesArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<DiscoverCertificatesResult>

discoverByIdentityKey: (args: DiscoverByIdentityKeyArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<DiscoverCertificatesResult>

getHeaderForHeight: (args: GetHeaderArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<GetHeaderResult>

getHeight: (args: {}, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<GetHeightResult>

getNetwork: (args: {}, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<GetNetworkResult>

getVersion: (args: {}, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<GetVersionResult>

internalizeAction: (args: InternalizeActionArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<InternalizeActionResult>

isAuthenticated: (args: {}, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<AuthenticatedResult>

listActions: (args: ListActionsArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<ListActionsResult>

listCertificates: (args: ListCertificatesArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<ListCertificatesResult>

listOutputs: (args: ListOutputsArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<ListOutputsResult>

proveCertificate: (args: ProveCertificateArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<ProveCertificateResult>

relinquishCertificate: (args: RelinquishCertificateArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<RelinquishCertificateResult>

relinquishOutput: (args: RelinquishOutputArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<RelinquishOutputResult>

signAction: (args: SignActionArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<SignActionResult>

waitForAuthentication: (args: {}, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<AuthenticatedResult>

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: WalletAction

export interface WalletAction {
    txid: TXIDHexString;
    satoshis: SatoshiValue;
    status: ActionStatus;
    isOutgoing: boolean;
    description: DescriptionString5to50Bytes;
    labels?: LabelStringUnder300Bytes[];
    version: PositiveIntegerOrZero;
    lockTime: PositiveIntegerOrZero;
    inputs?: WalletActionInput[];
    outputs?: WalletActionOutput[];
}

See also: ActionStatus, DescriptionString5to50Bytes, LabelStringUnder300Bytes, PositiveIntegerOrZero, SatoshiValue, TXIDHexString, WalletActionInput, WalletActionOutput

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: WalletActionInput

export interface WalletActionInput {
    sourceOutpoint: OutpointString;
    sourceSatoshis: SatoshiValue;
    sourceLockingScript?: HexString;
    unlockingScript?: HexString;
    inputDescription: DescriptionString5to50Bytes;
    sequenceNumber: PositiveIntegerOrZero;
}

See also: DescriptionString5to50Bytes, HexString, OutpointString, PositiveIntegerOrZero, SatoshiValue

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: WalletActionOutput

export interface WalletActionOutput {
    satoshis: SatoshiValue;
    lockingScript?: HexString;
    spendable: boolean;
    customInstructions?: string;
    tags: OutputTagStringUnder300Bytes[];
    outputIndex: PositiveIntegerOrZero;
    outputDescription: DescriptionString5to50Bytes;
    basket: BasketStringUnder300Bytes;
}

See also: BasketStringUnder300Bytes, DescriptionString5to50Bytes, HexString, OutputTagStringUnder300Bytes, PositiveIntegerOrZero, SatoshiValue

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: WalletCertificate

export interface WalletCertificate {
    type: Base64String;
    subject: PubKeyHex;
    serialNumber: Base64String;
    certifier: PubKeyHex;
    revocationOutpoint: OutpointString;
    signature: HexString;
    fields: Record<CertificateFieldNameUnder50Bytes, string>;
}

See also: Base64String, CertificateFieldNameUnder50Bytes, HexString, OutpointString, PubKeyHex

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: WalletCryptoObject

The WalletCryptoObject interface defines a wallet cryptographic capabilities including: key derivation, encryption, decryption, hmac creation and verification, signature generation and verification

Error Handling

Every method of the Wallet interface has a return value of the form Promise<object>. When an error occurs, an exception object may be thrown which must conform to the WalletErrorObject interface. Serialization layers can rely on the isError property being unique to error objects to deserialize and rethrow WalletErrorObject conforming objects.

export interface WalletCryptoObject {
    getPublicKey: (args: GetPublicKeyArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<GetPublicKeyResult>;
    revealCounterpartyKeyLinkage: (args: RevealCounterpartyKeyLinkageArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<RevealCounterpartyKeyLinkageResult>;
    revealSpecificKeyLinkage: (args: RevealSpecificKeyLinkageArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<RevealSpecificKeyLinkageResult>;
    encrypt: (args: WalletEncryptArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<WalletEncryptResult>;
    decrypt: (args: WalletDecryptArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<WalletDecryptResult>;
    createHmac: (args: CreateHmacArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<CreateHmacResult>;
    verifyHmac: (args: VerifyHmacArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<VerifyHmacResult>;
    createSignature: (args: CreateSignatureArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<CreateSignatureResult>;
    verifySignature: (args: VerifySignatureArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<VerifySignatureResult>;
}

See also: CreateHmacArgs, CreateHmacResult, CreateSignatureArgs, CreateSignatureResult, GetPublicKeyArgs, GetPublicKeyResult, OriginatorDomainNameStringUnder250Bytes, RevealCounterpartyKeyLinkageArgs, RevealCounterpartyKeyLinkageResult, RevealSpecificKeyLinkageArgs, RevealSpecificKeyLinkageResult, VerifyHmacArgs, VerifyHmacResult, VerifySignatureArgs, VerifySignatureResult, WalletDecryptArgs, WalletDecryptResult, WalletEncryptArgs, WalletEncryptResult, createHmac, createSignature, decrypt, encrypt, getPublicKey, verifyHmac, verifySignature

createHmac: (args: CreateHmacArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<CreateHmacResult>

createSignature: (args: CreateSignatureArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<CreateSignatureResult>

decrypt: (args: WalletDecryptArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<WalletDecryptResult>

encrypt: (args: WalletEncryptArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<WalletEncryptResult>

getPublicKey: (args: GetPublicKeyArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<GetPublicKeyResult>

revealCounterpartyKeyLinkage: (args: RevealCounterpartyKeyLinkageArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<RevealCounterpartyKeyLinkageResult>

revealSpecificKeyLinkage: (args: RevealSpecificKeyLinkageArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<RevealSpecificKeyLinkageResult>

verifyHmac: (args: VerifyHmacArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<VerifyHmacResult>

verifySignature: (args: VerifySignatureArgs, originator?: OriginatorDomainNameStringUnder250Bytes) => Promise<VerifySignatureResult>

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: WalletDecryptArgs

export interface WalletDecryptArgs extends WalletEncryptionArgs {
    ciphertext: Byte[];
}

See also: Byte, WalletEncryptionArgs

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: WalletDecryptResult

export interface WalletDecryptResult {
    plaintext: Byte[];
}

See also: Byte

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: WalletEncryptArgs

export interface WalletEncryptArgs extends WalletEncryptionArgs {
    plaintext: Byte[];
}

See also: Byte, WalletEncryptionArgs

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: WalletEncryptResult

export interface WalletEncryptResult {
    ciphertext: Byte[];
}

See also: Byte

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: WalletEncryptionArgs

export interface WalletEncryptionArgs {
    protocolID: WalletProtocol;
    keyID: KeyIDStringUnder800Bytes;
    counterparty?: WalletCounterparty;
    privileged?: BooleanDefaultFalse;
    privilegedReason?: DescriptionString5to50Bytes;
    seekPermission?: BooleanDefaultTrue;
}

See also: BooleanDefaultFalse, BooleanDefaultTrue, DescriptionString5to50Bytes, KeyIDStringUnder800Bytes, WalletCounterparty, WalletProtocol

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: WalletErrorObject

Every method of the Wallet interface has a return value of the form Promise<object>. When errors occur, an exception object may be thrown which must conform to the WalletErrorObject interface. Serialization layers can rely on the isError property being unique to error objects. Deserialization should rethrow WalletErrorObject conforming objects.

export interface WalletErrorObject extends Error {
    isError: true;
}

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: WalletOutput

export interface WalletOutput {
    satoshis: SatoshiValue;
    lockingScript?: HexString;
    spendable: boolean;
    customInstructions?: string;
    tags?: OutputTagStringUnder300Bytes[];
    outpoint: OutpointString;
    labels?: LabelStringUnder300Bytes[];
}

See also: HexString, LabelStringUnder300Bytes, OutpointString, OutputTagStringUnder300Bytes, SatoshiValue

Links: API, Interfaces, Classes, Functions, Types, Variables

Interface: WalletPayment

export interface WalletPayment {
    derivationPrefix: Base64String;
    derivationSuffix: Base64String;
    senderIdentityKey: PubKeyHex;
}

See also: Base64String, PubKeyHex

Links: API, Interfaces, Classes, Functions, Types, Variables

Classes

Links: API, Interfaces, Classes, Functions, Types, Variables

Class: CachedKeyDeriver

A cached version of KeyDeriver that caches the results of key derivation methods. This is useful for optimizing performance when the same keys are derived multiple times. It supports configurable cache size with sane defaults and maintains cache entries using LRU (Least Recently Used) eviction policy.

export default class CachedKeyDeriver {
    constructor(rootKey: PrivateKey | "anyone", options?: {
        maxCacheSize?: number;
    }) 
    derivePublicKey(protocolID: WalletProtocol, keyID: string, counterparty: Counterparty, forSelf: boolean = false): PublicKey 
    derivePrivateKey(protocolID: WalletProtocol, keyID: string, counterparty: Counterparty): PrivateKey 
    deriveSymmetricKey(protocolID: WalletProtocol, keyID: string, counterparty: Counterparty): SymmetricKey 
    revealCounterpartySecret(counterparty: Counterparty): number[] 
    revealSpecificSecret(counterparty: Counterparty, protocolID: WalletProtocol, keyID: string): number[] 
}

See also: Counterparty, WalletProtocol

constructor(rootKey: PrivateKey | "anyone", options?: {
    maxCacheSize?: number;
}) 

derivePrivateKey(protocolID: WalletProtocol, keyID: string, counterparty: Counterparty): PrivateKey 

derivePublicKey(protocolID: WalletProtocol, keyID: string, counterparty: Counterparty, forSelf: boolean = false): PublicKey 

deriveSymmetricKey(protocolID: WalletProtocol, keyID: string, counterparty: Counterparty): SymmetricKey 

revealCounterpartySecret(counterparty: Counterparty): number[] 

revealSpecificSecret(counterparty: Counterparty, protocolID: WalletProtocol, keyID: string): number[] 

Links: API, Interfaces, Classes, Functions, Types, Variables

Class: Communicator

export class Communicator {
    static setCached(substrate: string, version: string): Communicator 
    static getCached(): Communicator | undefined 
    async dispatch<P extends object>(args: {
        name: string;
        params: P;
        isGet?: boolean;
        bodyParamKey?: string;
        bodyJsonParams?: boolean;
        contentType?: string;
        nameHttp?: string;
        isNinja?: boolean;
    }): Promise<unknown> 
}

Links: API, Interfaces, Classes, Functions, Types, Variables

Class: KeyDeriver

Class responsible for deriving various types of keys using a root private key. It supports deriving public and private keys, symmetric keys, and revealing key linkages.

export class KeyDeriver implements KeyDeriverApi {
    rootKey: PrivateKey;
    identityKey: string;
    constructor(rootKey: PrivateKey | "anyone") 
    derivePublicKey(protocolID: WalletProtocol, keyID: string, counterparty: Counterparty, forSelf: boolean = false): PublicKey 
    derivePrivateKey(protocolID: WalletProtocol, keyID: string, counterparty: Counterparty): PrivateKey 
    deriveSymmetricKey(protocolID: WalletProtocol, keyID: string, counterparty: Counterparty): SymmetricKey 
    revealCounterpartySecret(counterparty: Counterparty): number[] 
    revealSpecificSecret(counterparty: Counterparty, protocolID: WalletProtocol, keyID: string): number[] 
}

See also: Counterparty, KeyDeriverApi, WalletProtocol

constructor(rootKey: PrivateKey | "anyone") 

derivePrivateKey(protocolID: WalletProtocol, keyID: string, counterparty: Counterparty): PrivateKey 

derivePublicKey(protocolID: WalletProtocol, keyID: string, counterparty: Counterparty, forSelf: boolean = false): PublicKey 

deriveSymmetricKey(protocolID: WalletProtocol, keyID: string, counterparty: Counterparty): SymmetricKey 

revealCounterpartySecret(counterparty: Counterparty): number[] 

revealSpecificSecret(counterparty: Counterparty, protocolID: WalletProtocol, keyID: string): number[] 

Links: API, Interfaces, Classes, Functions, Types, Variables

Class: WERR_BAD_REQUEST

The request is invalid.

export class WERR_BAD_REQUEST extends WalletError {
    constructor(message?: string) 
}

See also: WalletError

Links: API, Interfaces, Classes, Functions, Types, Variables

Class: WERR_INSUFFICIENT_FUNDS

Insufficient funds in the available inputs to cover the cost of the required outputs and the transaction fee (${moreSatoshisNeeded} more satoshis are needed, for a total of ${totalSatoshisNeeded}), plus whatever would be required in order to pay the fee to unlock and spend the outputs used to provide the additional satoshis.

export class WERR_INSUFFICIENT_FUNDS extends WalletError {
    constructor(public totalSatoshisNeeded: number, public moreSatoshisNeeded: number) 
}

See also: WalletError

constructor(public totalSatoshisNeeded: number, public moreSatoshisNeeded: number) 

Links: API, Interfaces, Classes, Functions, Types, Variables

Class: WERR_INTERNAL

An internal error has occurred.

This is an example of an error with an optional custom message.

export class WERR_INTERNAL extends WalletError {
    constructor(message?: string) 
}

See also: WalletError

Links: API, Interfaces, Classes, Functions, Types, Variables

Class: WERR_INVALID_PARAMETER

The ${parameter} parameter is invalid.

This is an example of an error object with a custom property parameter and templated message.

export class WERR_INVALID_PARAMETER extends WalletError {
    constructor(public parameter: string, mustBe?: string) 
}

See also: WalletError

Links: API, Interfaces, Classes, Functions, Types, Variables

Class: WERR_INVALID_PUBLIC_KEY

export class WERR_INVALID_PUBLIC_KEY extends WalletError {
    constructor(public key: string, network: WalletNetwork = "mainnet") 
}

See also: WalletError, WalletNetwork

constructor(public key: string, network: WalletNetwork = "mainnet") 

Links: API, Interfaces, Classes, Functions, Types, Variables

Class: WERR_MISSING_PARAMETER

The required ${parameter} parameter is missing.

This is an example of an error object with a custom property parameter

export class WERR_MISSING_PARAMETER extends WalletError {
    constructor(public parameter: string) 
}

See also: WalletError

Links: API, Interfaces, Classes, Functions, Types, Variables

Class: WERR_NETWORK_CHAIN

Configured network chain is invalid or does not match across services.

export class WERR_NETWORK_CHAIN extends WalletError {
    constructor(message?: string) 
}

See also: WalletError

Links: API, Interfaces, Classes, Functions, Types, Variables

Class: WERR_NOT_IMPLEMENTED

Not implemented.

export class WERR_NOT_IMPLEMENTED extends WalletError {
    constructor(message?: string) 
}

See also: WalletError

Links: API, Interfaces, Classes, Functions, Types, Variables

Class: WERR_UNAUTHORIZED

Access is denied due to an authorization error.

export class WERR_UNAUTHORIZED extends WalletError {
    constructor(message?: string) 
}

See also: WalletError

Links: API, Interfaces, Classes, Functions, Types, Variables

Class: WalletCrypto

WalletCrypto implements single-keyring wallet cryptography functions, operating without context about whether its configured keyring is privileged.

export class WalletCrypto implements WalletCryptoObject {
    keyDeriver: KeyDeriverApi;
    constructor(keyDeriver: KeyDeriverApi) 
    async getIdentityKey(originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{
        publicKey: PubKeyHex;
    }> 
    async getPublicKey(args: GetPublicKeyArgs, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{
        publicKey: PubKeyHex;
    }> 
    async revealCounterpartyKeyLinkage(args: RevealCounterpartyKeyLinkageArgs, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<RevealCounterpartyKeyLinkageResult> 
    async revealSpecificKeyLinkage(args: RevealSpecificKeyLinkageArgs, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<RevealSpecificKeyLinkageResult> 
    async encrypt(args: WalletEncryptArgs, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<WalletEncryptResult> 
    async decrypt(args: WalletDecryptArgs, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<WalletDecryptResult> 
    async createHmac(args: CreateHmacArgs, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<CreateHmacResult> 
    async verifyHmac(args: VerifyHmacArgs, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<VerifyHmacResult> 
    async createSignature(args: CreateSignatureArgs, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<CreateSignatureResult> 
    async verifySignature(args: VerifySignatureArgs, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<VerifySignatureResult> 
}

See also: CreateHmacArgs, CreateHmacResult, CreateSignatureArgs, CreateSignatureResult, GetPublicKeyArgs, KeyDeriverApi, OriginatorDomainNameStringUnder250Bytes, PubKeyHex, RevealCounterpartyKeyLinkageArgs, RevealCounterpartyKeyLinkageResult, RevealSpecificKeyLinkageArgs, RevealSpecificKeyLinkageResult, VerifyHmacArgs, VerifyHmacResult, VerifySignatureArgs, VerifySignatureResult, WalletCryptoObject, WalletDecryptArgs, WalletDecryptResult, WalletEncryptArgs, WalletEncryptResult, createHmac, createSignature, decrypt, encrypt, getPublicKey, verifyHmac, verifySignature

async getIdentityKey(originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{
    publicKey: PubKeyHex;
}> 

Links: API, Interfaces, Classes, Functions, Types, Variables

Class: WalletError

Derived class constructors should use the derived class name as the value for name, and an internationalizable constant string for message.

If a derived class intends to wrap another WalletError, the public property should be named walletError and will be recovered by fromUnknown.

Optionaly, the derived class message can include template parameters passed in to the constructor. See WERR_MISSING_PARAMETER for an example.

To avoid derived class name colisions, packages should include a package specific identifier after the 'WERR_' prefix. e.g. 'WERR_FOO_' as the prefix for Foo package error classes.

export class WalletError extends Error implements WalletErrorObject {
    isError: true = true;
    constructor(name: string, message: string, stack?: string, public details?: Record<string, string>) 
    get code(): sdk.ErrorCodeString10To40Bytes 
    set code(v: sdk.ErrorCodeString10To40Bytes) 
    get description(): sdk.ErrorDescriptionString20To200Bytes 
    set description(v: sdk.ErrorDescriptionString20To200Bytes) 
    static fromUnknown(err: unknown): WalletError 
    asStatus(): {
        status: string;
        code: string;
        description: string;
    } 
}

See also: ErrorCodeString10To40Bytes, ErrorDescriptionString20To200Bytes, WalletErrorObject

asStatus(): {
    status: string;
    code: string;
    description: string;
} 

static fromUnknown(err: unknown): WalletError 

Links: API, Interfaces, Classes, Functions, Types, Variables

Functions

Links: API, Interfaces, Classes, Functions, Types, Variables

Function: abortAction

Aborts a previously created action which required custom input unlocking script signing.

export async function abortAction(args: {
    referenceNumber: string;
    log?: string;
}): Promise<AbortActionResult> 

See also: AbortActionResult

Links: API, Interfaces, Classes, Functions, Types, Variables

Function: asArray

export function asArray(val: Buffer | string | number[], encoding?: BufferEncoding): number[] 

Links: API, Interfaces, Classes, Functions, Types, Variables

Function: asBsvSdkScript

export function asBsvSdkScript(script: string | Buffer | Script): Script 

Links: API, Interfaces, Classes, Functions, Types, Variables

Function: asBsvSdkTx

export function asBsvSdkTx(tx: string | Buffer | Transaction): Transaction 

Links: API, Interfaces, Classes, Functions, Types, Variables

Function: asBuffer

export function asBuffer(val: Buffer | string | number[], encoding?: BufferEncoding): Buffer 

Links: API, Interfaces, Classes, Functions, Types, Variables

Function: asString

export function asString(val: Buffer | string, encoding?: BufferEncoding): string 

Links: API, Interfaces, Classes, Functions, Types, Variables

Function: buildTransactionForSignActionUnlocking

Constructs a

export async function buildTransactionForSignActionUnlocking(ninjaInputs: Record<string, CreateActionInput>, createResult: DojoCreateTransactionResultApi): Promise<Transaction> 

See also: CreateActionInput, DojoCreateTransactionResultApi

Links: API, Interfaces, Classes, Functions, Types, Variables

Function: connectToSubstrate

export default async function connectToSubstrate(): Promise<Communicator> 

See also: Communicator

Links: API, Interfaces, Classes, Functions, Types, Variables

Function: convertMerklePathToProof

Convert a MerklePath to a single BRC-10 proof

export function convertMerklePathToProof(txid: string, mp: MerklePath): TscMerkleProofApi 

See also: TscMerkleProofApi

Links: API, Interfaces, Classes, Functions, Types, Variables

Function: convertProofToMerklePath

Convert a single BRC-10 proof to a MerklePath

export function convertProofToMerklePath(txid: string, proof: TscMerkleProofApi): MerklePath 

See also: TscMerkleProofApi

Links: API, Interfaces, Classes, Functions, Types, Variables

Function: convertProofToMerklePathWithLookup

export async function convertProofToMerklePathWithLookup(txid: string, proof: TscMerkleProofApi, lookupHeight: (targetType: "hash" | "header" | "merkleRoot" | "height", target: string | Buffer) => Promise<number>): Promise<MerklePath> 

See also: TscMerkleProofApi

Links: API, Interfaces, Classes, Functions, Types, Variables