cwi-base

cwi-base

Base classes, types, utilities for implementation support of CWI components, Project Babbage applications and services.

API

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

Interfaces

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

Interface: BaseBlockHeader

These are fields of 80 byte serialized header in order whose double sha256 hash is a block's hash value and the next block's previousHash value.

All block hash values and merkleRoot values are 32 byte Buffer values with the byte order reversed from the serialized byte order.

export interface BaseBlockHeader {
    version: number;
    previousHash: Buffer;
    merkleRoot: Buffer;
    time: number;
    bits: number;
    nonce: number;
}

bits: number

merkleRoot: Buffer

nonce: number

previousHash: Buffer

time: number

version: number

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

Interface: BaseBlockHeaderHex

Like BlockHeader but 32 byte fields are hex encoded strings.

export interface BaseBlockHeaderHex {
    version: number;
    previousHash: string;
    merkleRoot: string;
    time: number;
    bits: number;
    nonce: number;
}

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

Interface: BlockHeader

A BaseBlockHeader extended with its computed hash and height in its chain.

export interface BlockHeader extends BaseBlockHeader {
    height: number;
    hash: Buffer;
}

See also: BaseBlockHeader

hash: Buffer

height: number

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

Interface: BlockHeaderHex

Like BlockHeader but 32 byte fields are hex encoded strings.

export interface BlockHeaderHex extends BaseBlockHeaderHex {
    height: number;
    hash: string;
}

See also: BaseBlockHeaderHex

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

Interface: CertifierDetails

export interface CertifierDetails {
    name: string;
    icon: string;
    note: string;
    publicKey: string;
    trust: number;
}

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

Interface: ChaintracksApi

Full Chaintracks API including startListening with callbacks

export interface ChaintracksApi extends ChaintracksClientApi {
    startListening(listening?: () => void): Promise<void>;
}

See also: ChaintracksClientApi

startListening(listening?: () => void): Promise<void>

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

Interface: ChaintracksClientApi

Chaintracks client API excluding events and callbacks

export interface ChaintracksClientApi extends ChainTracker {
    getChain(): Promise<Chain>;
    getInfo(): Promise<ChaintracksInfoApi>;
    getPresentHeight(): Promise<number>;
    getHeaders(height: number, count: number): Promise<Buffer>;
    getHeadersHex(height: number, count: number): Promise<string>;
    findChainTipHeader(): Promise<BlockHeader>;
    findChainTipHeaderHex(): Promise<BlockHeaderHex>;
    findChainTipHash(): Promise<Buffer>;
    findChainTipHashHex(): Promise<string>;
    findChainWorkForBlockHash(hash: Buffer | string): Promise<Buffer | undefined>;
    findChainWorkHexForBlockHash(hash: Buffer | string): Promise<string | undefined>;
    findHeaderForBlockHash(hash: Buffer | string): Promise<BlockHeader | undefined>;
    findHeaderHexForBlockHash(hash: Buffer | string): Promise<BlockHeaderHex | undefined>;
    findHeaderForHeight(height: number): Promise<BlockHeader | undefined>;
    findHeaderHexForHeight(height: number): Promise<BlockHeaderHex | undefined>;
    findHeaderForMerkleRoot(merkleRoot: Buffer | string, height?: number): Promise<BlockHeader | undefined>;
    findHeaderHexForMerkleRoot(root: Buffer | string, height?: number): Promise<BlockHeaderHex | undefined>;
    addHeader(header: BaseBlockHeader | BaseBlockHeaderHex): Promise<void>;
    startListening(): Promise<void>;
    listening(): Promise<void>;
    isListening(): Promise<boolean>;
    isSynchronized(): Promise<boolean>;
    subscribeHeaders(listener: HeaderListener): Promise<string>;
    subscribeReorgs(listener: ReorgListener): Promise<string>;
    unsubscribe(subscriptionId: string): Promise<boolean>;
    isValidRootForHeight(root: string, height: number): Promise<boolean>;
    currentHeight: () => Promise<number>;
}

See also: BaseBlockHeader, BaseBlockHeaderHex, BlockHeader, BlockHeaderHex, Chain, ChaintracksInfoApi, HeaderListener, ReorgListener

addHeader(header: BaseBlockHeader | BaseBlockHeaderHex): Promise<void>

findChainTipHash(): Promise<Buffer>

findChainTipHashHex(): Promise<string>

findChainTipHeader(): Promise<BlockHeader>

findChainTipHeaderHex(): Promise<BlockHeaderHex>

findChainWorkForBlockHash(hash: Buffer | string): Promise<Buffer | undefined>

findChainWorkHexForBlockHash(hash: Buffer | string): Promise<string | undefined>

findHeaderForBlockHash(hash: Buffer | string): Promise<BlockHeader | undefined>

findHeaderForHeight(height: number): Promise<BlockHeader | undefined>

findHeaderForMerkleRoot(merkleRoot: Buffer | string, height?: number): Promise<BlockHeader | undefined>

findHeaderHexForBlockHash(hash: Buffer | string): Promise<BlockHeaderHex | undefined>

findHeaderHexForHeight(height: number): Promise<BlockHeaderHex | undefined>

findHeaderHexForMerkleRoot(root: Buffer | string, height?: number): Promise<BlockHeaderHex | undefined>

getChain(): Promise<Chain>

getHeaders(height: number, count: number): Promise<Buffer>

getHeadersHex(height: number, count: number): Promise<string>

getInfo(): Promise<ChaintracksInfoApi>

getPresentHeight(): Promise<number>

isListening(): Promise<boolean>

isSynchronized(): Promise<boolean>

listening(): Promise<void>

startListening(): Promise<void>

subscribeHeaders(listener: HeaderListener): Promise<string>

subscribeReorgs(listener: ReorgListener): Promise<string>

unsubscribe(subscriptionId: string): Promise<boolean>

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

Interface: ChaintracksInfoApi

export interface ChaintracksInfoApi {
    chain: Chain;
    heightBulk: number;
    heightLive: number;
    storageEngine: string;
    bulkStorage: string | undefined;
    bulkIndex: string | undefined;
    bulkIngestors: string[];
    liveIngestors: string[];
    packages: ChaintracksPackageInfoApi[];
}

See also: Chain, ChaintracksPackageInfoApi

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

Interface: ChaintracksPackageInfoApi

export interface ChaintracksPackageInfoApi {
    name: string;
    version: string;
}

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

Interface: DojoAliasApi

export interface DojoAliasApi extends DojoEntityTimeStampApi {
    aliasId?: number;
    created_at?: Date | null;
    updated_at?: Date | null;
    alias: string;
    domain: string;
    avatarName?: string;
    avatarPhotoURL?: string;
    reservationCompleted: boolean;
    userId: number;
    destinationBasketId: number;
}

See also: DojoEntityTimeStampApi

alias: string

avatarName?: string

avatarPhotoURL?: string

domain: string

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

Interface: DojoAvatarApi

export interface DojoAvatarApi {
    name: string;
    photoURL: string;
}

name: string

photoURL: string

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

Interface: DojoCertificateApi

export interface DojoCertificateApi extends DojoEntityTimeStampApi, CreateCertificateResult {
    certificateId?: number;
    created_at?: Date | null;
    updated_at?: Date | null;
    userId: number;
    type: string;
    subject: string;
    validationKey: string;
    serialNumber: string;
    certifier: string;
    revocationOutpoint: string;
    signature: string;
    fields?: Record<string, string>;
    masterKeyring?: Record<string, string>;
    isDeleted?: boolean;
}

See also: DojoEntityTimeStampApi

certifier: string

fields?: Record<string, string>

isDeleted?: boolean

masterKeyring?: Record<string, string>

revocationOutpoint: string

serialNumber: string

signature: string

subject: string

type: string

validationKey: string

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

Interface: DojoCertificateFieldApi

export interface DojoCertificateFieldApi extends DojoEntityTimeStampApi {
    userId: number;
    certificateId: number;
    created_at?: Date | null;
    updated_at?: Date | null;
    fieldName: string;
    fieldValue: string;
    masterKey: string;
}

See also: DojoEntityTimeStampApi

fieldName: string

fieldValue: string

masterKey: string

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

Interface: DojoClientApi

User specific public Dojo API accessible from all Dojo implementations including DojoExpressClient HTTP client

export interface DojoClientApi extends DojoPublicApi, DojoSyncApi {
    isDojoExpressClient(): boolean;
    authenticate(identityKey?: string, addIfNew?: boolean): Promise<void>;
    getDojoIdentity(): Promise<DojoIdentityApi>;
    sync(logger?: DojoLoggerApi): Promise<void>;
    setSyncDojosByConfig(syncDojoConfigs: SyncDojoConfigBaseApi[], options?: DojoSyncOptionsApi): Promise<void>;
    getSyncDojosByConfig(): Promise<{
        dojos: SyncDojoConfigBaseApi[];
        options?: DojoSyncOptionsApi;
    }>;
    getUser(): DojoClientUserApi;
    getAvatar(): Promise<DojoAvatarApi>;
    setAvatar(avatar: DojoAvatarApi): Promise<void>;
    getCurrentPaymails(): Promise<string[]>;
    saveCertificate(certificate: DojoCertificateApi): Promise<number>;
    findCertificates(certifiers?: string[], types?: Record<string, string[]>): Promise<DojoCertificateApi[]>;
    getTotalOfUnspentOutputs(basket?: string): Promise<number | undefined>;
    updateOutpointStatus(txid: string, vout: number, spendable: boolean): Promise<void>;
    getTotalOfAmounts(direction: "incoming" | "outgoing", options?: DojoGetTotalOfAmountsOptions): Promise<number>;
    getNetOfAmounts(options?: DojoGetTotalOfAmountsOptions): Promise<number>;
    updateTransactionStatus(reference: string, status: DojoTransactionStatusApi): Promise<void>;
    getTransactions(options?: DojoGetTransactionsOptions): Promise<DojoGetTransactionsResultApi>;
    createTransactionSdk(args: sdk.ValidCreateActionArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<DojoCreateTransactionSdkResult>;
    processActionSdk(params: DojoProcessActionSdkParams, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<DojoProcessActionSdkResults>;
    abortActionSdk(vargs: sdk.ValidAbortActionArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.AbortActionResult>;
    listActionsSdk(vargs: sdk.ValidListActionsArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.ListActionsResult>;
    listOutputsSdk(vargs: sdk.ValidListOutputsArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.ListOutputsResult>;
    acquireCertificateSdk(vargs: sdk.ValidAcquireDirectCertificateArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.AcquireCertificateResult>;
    listCertificatesSdk(vargs: sdk.ValidListCertificatesArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<DojoListCertificatesResult>;
    proveCertificatesSdk(vargs: sdk.ValidProveCertificateArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<DojoWalletCertificate>;
    relinquishCertificateSdk(vargs: sdk.ValidRelinquishCertificateArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.RelinquishCertificateResult>;
    discoverByIdentityKeySdk(vargs: sdk.ValidDiscoverByIdentityKeyArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.DiscoverCertificatesResult>;
    discoverByAttributesSdk(vargs: sdk.ValidDiscoverByAttributesArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.DiscoverCertificatesResult>;
    relinquishOutputSdk(vargs: sdk.ValidRelinquishOutputArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.RelinquishOutputResult>;
    isValidRootForHeight(root: string, height: number): Promise<boolean>;
    currentHeight: () => Promise<number>;
    internalizeActionSdk(dargs: DojoInternalizeActionArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.InternalizeActionResult>;
    getTransactionOutputs(options?: DojoGetTransactionOutputsOptions): Promise<DojoGetTransactionOutputsResultApi>;
    getTransactionLabels(options?: DojoGetTransactionLabelsOptions): Promise<DojoGetTransactionLabelsResultApi>;
    getBeefForTransaction(txid: string, options?: DojoGetBeefOptions): Promise<Beef>;
    getEnvelopeForTransaction(txid: string): Promise<EnvelopeApi | undefined>;
    getEnvelopesOfConflictingTransactions(txid: string): Promise<EnvelopeApi[]>;
    getPendingTransactions(referenceNumber?: string): Promise<DojoPendingTxApi[]>;
    createTransaction(params: DojoCreateTransactionParams): Promise<DojoCreateTransactionResultApi>;
    processTransaction(params: DojoProcessTransactionParams): Promise<DojoProcessTransactionResultApi>;
    submitDirectTransaction(params: DojoSubmitDirectTransactionParams): Promise<DojoSubmitDirectTransactionResultApi>;
    copyState(since?: Date): Promise<DojoUserStateApi>;
    softDeleteCertificate(partial: Partial<DojoCertificateApi>, trx?: TrxToken): Promise<number>;
    softDeleteOutputTag(partial: Partial<DojoOutputTagApi>, trx?: TrxToken): Promise<number>;
    softDeleteTxLabel(partial: Partial<DojoTxLabelApi>, trx?: TrxToken): Promise<number>;
    softDeleteOutputBasket(partial: Partial<DojoOutputBasketApi>, trx?: TrxToken): Promise<number>;
    labelTransaction(txid: string | number | Partial<DojoTransactionApi>, label: string, trx?: TrxToken): Promise<void>;
    unlabelTransaction(txid: string | number | Partial<DojoTransactionApi>, label: string, trx?: TrxToken): Promise<void>;
    tagOutput(partial: Partial<DojoOutputApi>, tag: string, trx?: TrxToken): Promise<void>;
    untagOutput(partial: Partial<DojoOutputApi>, tag: string, trx?: TrxToken): Promise<void>;
    unbasketOutput(partial: Partial<DojoOutputApi>, trx?: TrxToken): Promise<void>;
    getHeight(): Promise<number>;
    getMerkleRootForHeight(height: number): Promise<string | undefined>;
    getHeaderForHeight(height: number): Promise<number[] | undefined>;
    destroy(): Promise<void>;
}

See also: DojoAvatarApi, DojoCertificateApi, DojoClientUserApi, DojoCreateTransactionParams, DojoCreateTransactionResultApi, DojoCreateTransactionSdkResult, DojoGetBeefOptions, DojoGetTotalOfAmountsOptions, DojoGetTransactionLabelsOptions, DojoGetTransactionLabelsResultApi, DojoGetTransactionOutputsOptions, DojoGetTransactionOutputsResultApi, DojoGetTransactionsOptions, DojoGetTransactionsResultApi, DojoIdentityApi, DojoInternalizeActionArgs, DojoListCertificatesResult, DojoLoggerApi, DojoOutputApi, DojoOutputBasketApi, DojoOutputTagApi, DojoPendingTxApi, DojoProcessActionSdkParams, DojoProcessActionSdkResults, DojoProcessTransactionParams, DojoProcessTransactionResultApi, DojoPublicApi, DojoSubmitDirectTransactionParams, DojoSubmitDirectTransactionResultApi, DojoSyncApi, DojoSyncOptionsApi, DojoTransactionApi, DojoTransactionStatusApi, DojoTxLabelApi, DojoUserStateApi, DojoWalletCertificate, SyncDojoConfigBaseApi, TrxToken

authenticate(identityKey?: string, addIfNew?: boolean): Promise<void>

copyState(since?: Date): Promise<DojoUserStateApi>

createTransaction(params: DojoCreateTransactionParams): Promise<DojoCreateTransactionResultApi>

destroy(): Promise<void>

findCertificates(certifiers?: string[], types?: Record<string, string[]>): Promise<DojoCertificateApi[]>

getAvatar(): Promise<DojoAvatarApi>

getCurrentPaymails(): Promise<string[]>

getEnvelopeForTransaction(txid: string): Promise<EnvelopeApi | undefined>

getEnvelopesOfConflictingTransactions(txid: string): Promise<EnvelopeApi[]>

getHeaderForHeight(height: number): Promise<number[] | undefined>

getHeight(): Promise<number>

getMerkleRootForHeight(height: number): Promise<string | undefined>

getNetOfAmounts(options?: DojoGetTotalOfAmountsOptions): Promise<number>

getPendingTransactions(referenceNumber?: string): Promise<DojoPendingTxApi[]>

getTotalOfAmounts(direction: "incoming" | "outgoing", options?: DojoGetTotalOfAmountsOptions): Promise<number>

getTotalOfUnspentOutputs(basket?: string): Promise<number | undefined>

getTransactionLabels(options?: DojoGetTransactionLabelsOptions): Promise<DojoGetTransactionLabelsResultApi>

getTransactionOutputs(options?: DojoGetTransactionOutputsOptions): Promise<DojoGetTransactionOutputsResultApi>

getTransactions(options?: DojoGetTransactionsOptions): Promise<DojoGetTransactionsResultApi>

getUser(): DojoClientUserApi

isDojoExpressClient(): boolean

labelTransaction(txid: string | number | Partial<DojoTransactionApi>, label: string, trx?: TrxToken): Promise<void>

processTransaction(params: DojoProcessTransactionParams): Promise<DojoProcessTransactionResultApi>

saveCertificate(certificate: DojoCertificateApi): Promise<number>

setAvatar(avatar: DojoAvatarApi): Promise<void>

softDeleteCertificate(partial: Partial<DojoCertificateApi>, trx?: TrxToken): Promise<number>

softDeleteOutputBasket(partial: Partial<DojoOutputBasketApi>, trx?: TrxToken): Promise<number>

softDeleteOutputTag(partial: Partial<DojoOutputTagApi>, trx?: TrxToken): Promise<number>

softDeleteTxLabel(partial: Partial<DojoTxLabelApi>, trx?: TrxToken): Promise<number>

submitDirectTransaction(params: DojoSubmitDirectTransactionParams): Promise<DojoSubmitDirectTransactionResultApi>

sync(logger?: DojoLoggerApi): Promise<void>

tagOutput(partial: Partial<DojoOutputApi>, tag: string, trx?: TrxToken): Promise<void>

unbasketOutput(partial: Partial<DojoOutputApi>, trx?: TrxToken): Promise<void>

unlabelTransaction(txid: string | number | Partial<DojoTransactionApi>, label: string, trx?: TrxToken): Promise<void>

untagOutput(partial: Partial<DojoOutputApi>, tag: string, trx?: TrxToken): Promise<void>

updateOutpointStatus(txid: string, vout: number, spendable: boolean): Promise<void>

updateTransactionStatus(reference: string, status: DojoTransactionStatusApi): Promise<void>

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

Interface: DojoClientUserApi

export interface DojoClientUserApi extends DojoEntityTimeStampApi {
    userId?: number;
    created_at?: Date | null;
    updated_at?: Date | null;
    identityKey: string;
}

See also: DojoEntityTimeStampApi

identityKey: string

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

Interface: DojoCommissionApi

export interface DojoCommissionApi extends DojoEntityTimeStampApi {
    commissionId?: number;
    created_at?: Date | null;
    updated_at?: Date | null;
    transactionId: number;
    userId: number;
    isRedeemed: boolean;
    keyOffset: string;
    outputScript: Buffer | null;
    satoshis: number;
}

See also: DojoEntityTimeStampApi

keyOffset: string

satoshis: number

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

Interface: DojoCreateTransactionParams

export interface DojoCreateTransactionParams {
    outputs: DojoCreateTxOutputApi[];
    inputs?: Record<string, DojoTxInputsApi>;
    beef?: Beef | number[];
    inputSelection?: DojoTxInputSelectionApi;
    outputGeneration?: DojoOutputGenerationApi;
    lockTime?: number;
    version?: number;
    feeModel?: DojoFeeModelApi;
    labels?: string[];
    note?: string;
    recipient?: string;
    options?: CreateActionOptions;
    log?: string;
}

See also: DojoCreateTxOutputApi, DojoFeeModelApi, DojoOutputGenerationApi, DojoTxInputSelectionApi, DojoTxInputsApi

beef?: Beef | number[]

feeModel?: DojoFeeModelApi

inputSelection?: DojoTxInputSelectionApi

inputs?: Record<string, DojoTxInputsApi>

labels?: string[]

lockTime?: number

log?: string

note?: string

options?: CreateActionOptions

outputGeneration?: DojoOutputGenerationApi

outputs: DojoCreateTxOutputApi[]

recipient?: string

version?: number

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

Interface: DojoCreateTransactionResultApi

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

See also: DojoCreateTxResultInputsApi, DojoCreateTxResultOutputApi

inputBeef?: number[]

paymailHandle?: string

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

Interface: DojoCreateTransactionSdkInput

export interface DojoCreateTransactionSdkInput {
    vin: number;
    sourceTxid: string;
    sourceVout: number;
    sourceSatoshis: number;
    sourceLockingScript: string;
    unlockingScriptLength: number;
    providedBy: DojoProvidedByApi;
    type: string;
    spendingDescription?: string;
    derivationPrefix?: string;
    derivationSuffix?: string;
    senderIdentityKey?: string;
}

See also: DojoProvidedByApi

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

Interface: DojoCreateTransactionSdkOutput

export interface DojoCreateTransactionSdkOutput extends sdk.ValidCreateActionOutput {
    vout: number;
    providedBy: DojoProvidedByApi;
    purpose?: string;
    derivationSuffix?: string;
}

See also: DojoProvidedByApi

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

Interface: DojoCreateTransactionSdkResult

export interface DojoCreateTransactionSdkResult {
    inputBeef?: number[];
    inputs: DojoCreateTransactionSdkInput[];
    outputs: DojoCreateTransactionSdkOutput[];
    noSendChangeOutputVouts?: number[];
    derivationPrefix: string;
    version: number;
    lockTime: number;
    referenceNumber: string;
}

See also: DojoCreateTransactionSdkInput, DojoCreateTransactionSdkOutput

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: DojoCreateTxResultInputsApi

export interface DojoCreateTxResultInputsApi extends DojoTxInputsApi, OptionalEnvelopeEvidenceApi {
    providedBy: DojoProvidedByApi;
    instructions: Record<number, DojoCreateTxResultInstructionsApi>;
    outputsToRedeem: DojoOutputToRedeemApi[];
    txid: string;
}

See also: DojoCreateTxResultInstructionsApi, DojoOutputToRedeemApi, DojoProvidedByApi, DojoTxInputsApi

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

Interface: DojoCreateTxResultInstructionsApi

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

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

Interface: DojoCreateTxResultOutputApi

export interface DojoCreateTxResultOutputApi extends DojoCreateTxOutputApi {
    vout: number;
    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 {
    outputsToRedeem: DojoOutputToRedeemApi[];
    beefTx: BeefTx;
}

See also: DojoOutputToRedeemApi

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

Interface: DojoEntityTimeStampApi

export interface DojoEntityTimeStampApi {
    created_at?: Date | null;
    updated_at?: Date | null;
}

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

Interface: DojoFeeModelApi

An object representing the fee the transaction will pay.

export interface DojoFeeModelApi {
    model: "sat/kb";
    value?: number;
}

model: "sat/kb"

value?: number

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

Interface: DojoGetBeefOptions

export interface DojoGetBeefOptions {
    trustSelf?: "known";
    knownTxids?: string[];
    mergeToBeef?: Beef | number[];
    ignoreStorage?: boolean;
    ignoreServices?: boolean;
    ignoreNewProven?: boolean;
    minProofLevel?: number;
}

ignoreNewProven?: boolean

ignoreServices?: boolean

ignoreStorage?: boolean

knownTxids?: string[]

mergeToBeef?: Beef | number[]

minProofLevel?: number

trustSelf?: "known"

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

Interface: DojoGetTotalOfAmountsOptions

export interface DojoGetTotalOfAmountsOptions {
    label?: string;
    startTime?: Date | string | number;
    endTime?: Date | string | number;
    involving?: string;
    direction?: "incoming" | "outgoing";
}

direction?: "incoming" | "outgoing"

endTime?: Date | string | number

involving?: string

label?: string

startTime?: Date | string | number

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

Interface: DojoGetTransactionLabelsOptions

export interface DojoGetTransactionLabelsOptions extends DojoGetTransactionsBaseOptions {
    prefix?: string;
    transactionId?: number;
    sortBy?: DojoTransactionLabelsSortBy;
}

See also: DojoGetTransactionsBaseOptions, DojoTransactionLabelsSortBy

prefix?: string

sortBy?: DojoTransactionLabelsSortBy

transactionId?: number

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

Interface: DojoGetTransactionLabelsResultApi

export interface DojoGetTransactionLabelsResultApi {
    labels: DojoTxLabelApi[];
    total: number;
}

See also: DojoTxLabelApi

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

Interface: DojoGetTransactionOutputsOptions

export interface DojoGetTransactionOutputsOptions extends DojoGetTransactionsBaseOptions {
    basket?: string;
    tracked?: boolean;
    spendable?: boolean;
    tags?: string[];
    type?: string;
    includeEnvelope?: boolean;
    includeBeef?: boolean;
    trustSelf?: "known";
    knownTxids?: string[];
    includeCustomInstructions?: boolean;
    includeBasket?: boolean;
    includeTags?: boolean;
    tagQueryMode?: "all" | "any";
    noScript?: boolean;
    partial?: Partial<DojoOutputApi>;
}

See also: DojoGetTransactionsBaseOptions, DojoOutputApi

basket?: string

includeBasket?: boolean

includeBeef?: boolean

includeCustomInstructions?: boolean

includeEnvelope?: boolean

includeTags?: boolean

noScript?: boolean

spendable?: boolean

tagQueryMode?: "all" | "any"

tags?: string[]

tracked?: boolean

type?: string

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

Interface: DojoGetTransactionOutputsResultApi

export interface DojoGetTransactionOutputsResultApi {
    outputs: DojoOutputXApi[];
    total: number;
    beef: number[] | undefined;
}

See also: DojoOutputXApi

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

Interface: DojoGetTransactionsBaseOptions

export interface DojoGetTransactionsBaseOptions {
    limit?: number;
    offset?: number;
    order?: DojoRecordOrder;
}

See also: DojoRecordOrder

limit?: number

offset?: number

order?: DojoRecordOrder

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

Interface: DojoGetTransactionsOptions

export interface DojoGetTransactionsOptions extends DojoGetTransactionsBaseOptions {
    columns?: string[];
    referenceNumber?: string;
    status?: DojoTransactionStatusApi | DojoTransactionStatusApi[];
    label?: string;
    startTime?: Date | string | number;
    endTime?: Date | string | number;
    involving?: string;
    addLabels?: boolean;
    addInputsAndOutputs?: boolean;
    includeBasket?: boolean;
    includeTags?: boolean;
    noRawTx?: boolean;
    noScript?: boolean;
    partial?: Partial<DojoTransactionApi>;
}

See also: DojoGetTransactionsBaseOptions, DojoTransactionApi, DojoTransactionStatusApi

addInputsAndOutputs?: boolean

addLabels?: boolean

columns?: string[]

endTime?: Date | string | number

includeBasket?: boolean

includeTags?: boolean

involving?: string

label?: string

noRawTx?: boolean

noScript?: boolean

referenceNumber?: string

startTime?: Date | string | number

status?: DojoTransactionStatusApi | DojoTransactionStatusApi[]

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

Interface: DojoGetTransactionsResultApi

export interface DojoGetTransactionsResultApi {
    txs: DojoTransactionXApi[];
    total: number;
}

See also: DojoTransactionXApi

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

Interface: DojoIdentityApi

export interface DojoIdentityApi {
    dojoIdentityKey: string;
    dojoName?: string;
}

dojoIdentityKey: string

dojoName?: string

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

Interface: DojoInternalizeActionArgs

export interface DojoInternalizeActionArgs extends sdk.ValidInternalizeActionArgs {
    commonDerivationPrefix: string | undefined;
}

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

Interface: DojoListCertificatesResult

export interface DojoListCertificatesResult extends sdk.ListCertificatesResult {
    totalCertificates: sdk.PositiveIntegerOrZero;
    certificates: DojoWalletCertificate[];
}

See also: DojoWalletCertificate

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

Interface: DojoMapiResponseApi

export interface DojoMapiResponseApi extends DojoEntityTimeStampApi {
    responseId?: number;
    created_at?: Date | null;
    updated_at?: Date | null;
    provenTxReqId?: number;
    txid?: string;
    callbackID?: string;
    payload?: string;
    publicKey?: string;
    signature?: string;
    doubleSpendResponse?: string | null;
}

See also: DojoEntityTimeStampApi

doubleSpendResponse?: string | null

publicKey?: string

signature?: string

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

Interface: DojoOutputApi

export interface DojoOutputApi extends DojoEntityTimeStampApi {
    outputId?: number;
    created_at?: Date | null;
    updated_at?: Date | null;
    spendable: boolean;
    change: boolean;
    txid: string | null;
    vout: number | null;
    amount: number | null;
    outputScript: Buffer | null;
    scriptLength?: number | null;
    scriptOffset?: number | null;
    type: string;
    transactionId: number;
    userId: number;
    basketId?: number | null;
    spentBy: number | null;
    derivationPrefix: string | null;
    derivationSuffix: string | null;
    paymailHandle: string | null;
    senderIdentityKey: string | null;
    customInstructions: string | null;
    tracked: boolean | null;
    providedBy: string | null;
    purpose: string | null;
    description: string | null;
    spendingDescription: string | null;
    envelope?: EnvelopeApi;
}

See also: DojoEntityTimeStampApi

amount: number | null

customInstructions: string | null

derivationPrefix: string | null

derivationSuffix: string | null

description: string | null

envelope?: EnvelopeApi

paymailHandle: string | null

providedBy: string | null

purpose: string | null

senderIdentityKey: string | null

spendingDescription: string | null

spentBy: number | null

tracked: boolean | null

txid: string | null

type: string

vout: number | null

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

Interface: DojoOutputBasketApi

export interface DojoOutputBasketApi extends DojoEntityTimeStampApi {
    basketId?: number;
    created_at?: Date | null;
    updated_at?: Date | null;
    name: string;
    numberOfDesiredUTXOs: number;
    minimumDesiredUTXOValue: number;
    userId: number;
    isDeleted?: boolean;
}

See also: DojoEntityTimeStampApi

isDeleted?: boolean

name: string

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

Interface: DojoOutputGenerationApi

If Dojo needs to generate additional outputs for the transaction beyond what was specified, this object describes what kind of outputs to generate, and where they should be kept.

export interface DojoOutputGenerationApi {
    basket: string;
    method: "auto" | "single";
}

basket: string

method: "auto" | "single"

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

Interface: DojoOutputTagApi

export interface DojoOutputTagApi extends DojoEntityTimeStampApi {
    outputTagId?: number;
    created_at?: Date | null;
    updated_at?: Date | null;
    tag: string;
    userId: number;
    isDeleted?: boolean;
}

See also: DojoEntityTimeStampApi

isDeleted?: boolean

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

Interface: DojoOutputTagMapApi

export interface DojoOutputTagMapApi extends DojoEntityTimeStampApi {
    created_at?: Date | null;
    updated_at?: Date | null;
    outputTagId: number;
    outputId: number;
    isDeleted?: boolean;
}

See also: DojoEntityTimeStampApi

isDeleted?: boolean

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

Interface: DojoOutputToRedeemApi

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

index: number

lockingScript?: string

satoshis?: number

unlockingScriptLength: number

vin?: number

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

Interface: DojoOutputXApi

export interface DojoOutputXApi extends DojoOutputApi {
    basket?: DojoOutputBasketApi;
    tags?: DojoOutputTagApi[];
}

See also: DojoOutputApi, DojoOutputBasketApi, DojoOutputTagApi

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

Interface: DojoPendingTxApi

Return type from Ninja and Dojo getPendingTransactions methods.

export interface DojoPendingTxApi {
    amount: number;
    created_at: string;
    referenceNumber: string;
    senderPaymail?: string;
    status: string;
    isOutgoing: boolean;
    rawTransaction?: string;
    derivationPrefix?: string;
    paymailHandle?: string;
    inputs: Record<string, DojoPendingTxInputApi>;
    outputs: DojoPendingTxOutputApi[];
}

See also: DojoPendingTxInputApi, DojoPendingTxOutputApi

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

Interface: DojoPendingTxInputApi

export interface DojoPendingTxInputApi extends EnvelopeEvidenceApi {
    outputsToRedeem?: number[];
    instructions?: Record<number, DojoPendingTxInputInstructionsApi>;
}

See also: DojoPendingTxInputInstructionsApi

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

Interface: DojoPendingTxInputInstructionsApi

export interface DojoPendingTxInputInstructionsApi {
    type: string;
    derivationPrefix: string | null;
    derivationSuffix: string | null;
    paymailHandle: string | null;
    senderIdentityKey: string | null;
    customInstructions: string | null;
}

customInstructions: string | null

derivationPrefix: string | null

derivationSuffix: string | null

paymailHandle: string | null

senderIdentityKey: string | null

type: string

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

Interface: DojoPendingTxOutputApi

export interface DojoPendingTxOutputApi {
    type: string;
    satoshis: number;
    script?: string;
    derivationPrefix?: string;
    derivationSuffix?: string;
    paymailHandle?: string;
    providedBy?: string;
    purpose?: string;
    senderIdentityKey?: string;
    txid?: string;
    vout?: number;
}

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

Interface: DojoProcessActionSdkParams

export interface DojoProcessActionSdkParams {
    isNewTx: boolean;
    isSendWith: boolean;
    isNoSend: boolean;
    isDelayed: boolean;
    reference?: string;
    txid?: string;
    rawTx?: number[];
    sendWith: string[];
    log?: string;
}

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

Interface: DojoProcessActionSdkResults

export interface DojoProcessActionSdkResults {
    sendWithResults?: sdk.SendWithResult[];
    log?: string;
}

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

Interface: DojoProcessTransactionParams

Input parameters for Dojo and Ninja processTransaction

export interface DojoProcessTransactionParams {
    submittedTransaction?: string | Buffer | number[];
    reference?: string;
    inputs?: Record<string, OptionalEnvelopeEvidenceApi>;
    beef?: number[];
    outputMap?: Record<string, number>;
    noSendChange?: OutPoint[];
    options?: CreateActionOptions;
    acceptDelayedBroadcast?: boolean;
    log?: string;
}

acceptDelayedBroadcast?: boolean

beef?: number[]

inputs?: Record<string, OptionalEnvelopeEvidenceApi>

log?: string

noSendChange?: OutPoint[]

options?: CreateActionOptions

outputMap?: Record<string, number>

reference?: string

submittedTransaction?: string | Buffer | number[]

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

Interface: DojoProcessTransactionResultApi

export interface DojoProcessTransactionResultApi {
    txid: string;
    transactionId: number;
    status: "sending" | "unproven" | "failed" | "nosend";
    mapiResponses: MapiResponseApi[];
    beef?: number[];
    rawTx?: string;
    inputs?: Record<string, OptionalEnvelopeEvidenceApi>;
    sendWithResults?: DojoSendWithResultsApi[];
    log?: string;
}

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

Interface: DojoProvenOrReq

export interface DojoProvenOrReq {
    proven?: DojoProvenTxApi;
    req?: DojoProvenTxReqApi;
}

See also: DojoProvenTxApi, DojoProvenTxReqApi

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

Interface: DojoProvenTxApi

export interface DojoProvenTxApi extends DojoEntityTimeStampApi {
    provenTxId?: number;
    created_at?: Date | null;
    updated_at?: Date | null;
    txid: string;
    height: number;
    index: number;
    nodes: Buffer;
    rawTx: Buffer;
    blockHash: Buffer;
    merkleRoot: Buffer;
}

See also: DojoEntityTimeStampApi, blockHash

nodes: Buffer

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

Interface: DojoProvenTxReqApi

export interface DojoProvenTxReqApi extends DojoEntityTimeStampApi {
    provenTxReqId?: number;
    created_at?: Date | null;
    updated_at?: Date | null;
    txid: string;
    callbackID?: string;
    beef?: Buffer | null;
    rawTx?: Buffer;
    history: string;
    notify: string;
    notified: boolean;
    status: DojoProvenTxReqStatusApi;
    attempts: number;
    provenTxId?: number;
    batch?: string;
}

See also: DojoEntityTimeStampApi, DojoProvenTxReqStatusApi

attempts: number

batch?: string

history: string

notified: boolean

notify: string

provenTxId?: number

status: DojoProvenTxReqStatusApi

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

Interface: DojoPublicApi

Public Dojo Api No Authrite authentication required. Not specific to any userId

export interface DojoPublicApi {
    getChain(): Promise<Chain>;
    stats(): Promise<DojoStatsApi>;
}

See also: Chain, DojoStatsApi

getChain(): Promise<Chain>

stats(): Promise<DojoStatsApi>

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

Interface: DojoPurgeParams

The Dojo database stores a variety of data that may be considered transient.

At one extreme, the data that must be preserved:

• unspent outputs (UTXOs)
• in-use metadata (labels, baskets, tags...)

At the other extreme, everything can be preserved to fully log all transaction creation and processing actions.

The following purge actions are available to support sustained operation:

• Failed transactions, delete all associated data including:
  • Delete tag and label mapping records
  • Delete output records
  • Delete transaction records
  • Delete mapi_responses records
  • Delete proven_tx_reqs records
  • Delete commissions records
  • Update output records marked spentBy failed transactions
• Completed transactions, delete transient data including:
  • transactions table set truncatedExternalInputs = null
  • transactions table set beef = null
  • transactions table set rawTransaction = null
  • Delete mapi_responses records
  • proven_tx_reqs table delete records

export interface DojoPurgeParams {
    purgeCompleted: boolean;
    purgeFailed: boolean;
    purgeCompletedAge?: number;
    purgeFailedAge?: number;
}

purgeCompletedAge?: number

purgeFailedAge?: number

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

Interface: DojoPurgeResults

export interface DojoPurgeResults {
    count: number;
    log: string;
}

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

Interface: DojoStatsApi

export interface DojoStatsApi {
    users: number;
    transactions: number;
    txLabels: number;
    outputTags: number;
    chain: Chain;
}

See also: Chain

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

Interface: DojoSubmitDirectTransactionApi

export interface DojoSubmitDirectTransactionApi extends OptionalEnvelopeEvidenceApi {
    outputs: DojoSubmitDirectTransactionOutputApi[];
    referenceNumber?: string;
}

See also: DojoSubmitDirectTransactionOutputApi

outputs: DojoSubmitDirectTransactionOutputApi[]

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

Interface: DojoSubmitDirectTransactionOutputApi

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

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

Interface: DojoSubmitDirectTransactionParams

Input parameters to submitDirectTransaction method.

Normally used to receive spendable outputs from an externally sourced transaction (one created by a party other than this user). A transaction record is created for this user with isOutgoing false. New spendable output records are created for the indicated outputs of the transaction.

When submitDirectTransaction is called with outputs previously created by the same user on an isOutgoing true transaction, these params serve to update those outputs and the transaction amount. The transaction remains isOutgoing true.

When submitDirectTransaction is called again with additional outputs on previously submitted isOutgoing false transaction, these params serve to create new outputs and update the transaction amount. The transaction remains isOutgoing false.

export interface DojoSubmitDirectTransactionParams {
    protocol?: string;
    transaction: DojoSubmitDirectTransactionApi;
    senderIdentityKey: string;
    note: string;
    labels?: string[];
    derivationPrefix?: string;
    amount?: number;
}

See also: DojoSubmitDirectTransactionApi

derivationPrefix?: string

labels?: string[]

note: string

protocol?: string

senderIdentityKey: string

transaction: DojoSubmitDirectTransactionApi

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

Interface: DojoSubmitDirectTransactionResultApi

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

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

Interface: DojoSyncApi

Dojo Sync Protocol

The Dojo Sync Protocol keeps multiple UTXO management services (Dojos) synchronized as updates occur between them.

The protocol relies on the properties of the blockchain to handle specific conflicts.

It is intended to support use cases where there is a primary dojo which periodically synchronizes to backup "syncDojos".

There is no formal conrol within the protocol for determining the primary dojo or transitioning between roles.

Synchronization is initiated from the primary Dojo.

Step 1. Run through the configured syncDojos calling syncIdentify which shares the local dojo and syncDojo's identities. Any syncDojo that responds is added to activeSyncDojos.

Step 2. Run through the activeSyncDojos calling syncUpdate.

export interface DojoSyncApi {
    syncIdentify(params: DojoSyncIdentifyParams): Promise<DojoSyncIdentifyResultApi>;
    syncUpdate(params: DojoSyncUpdateParams): Promise<DojoSyncUpdateResultApi>;
    syncMerge(params: DojoSyncMergeParams): Promise<DojoSyncMergeResultApi>;
    authenticate(identityKey?: string, addIfNew?: boolean): Promise<void>;
    getSyncDojoConfig(): Promise<SyncDojoConfigBaseApi>;
}

See also: DojoSyncIdentifyParams, DojoSyncIdentifyResultApi, DojoSyncMergeParams, DojoSyncMergeResultApi, DojoSyncUpdateParams, DojoSyncUpdateResultApi, SyncDojoConfigBaseApi

authenticate(identityKey?: string, addIfNew?: boolean): Promise<void>

getSyncDojoConfig(): Promise<SyncDojoConfigBaseApi>

syncIdentify(params: DojoSyncIdentifyParams): Promise<DojoSyncIdentifyResultApi>

syncMerge(params: DojoSyncMergeParams): Promise<DojoSyncMergeResultApi>

syncUpdate(params: DojoSyncUpdateParams): Promise<DojoSyncUpdateResultApi>

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

Interface: DojoSyncErrorApi

export interface DojoSyncErrorApi {
    code: string;
    description: string;
    stack?: string;
}

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

Interface: DojoSyncIdentifyParams

Receipt of DojoSyncIdentityParams via the syncIdentify function starts a dojo to dojo sync.

It may also force a restart of the sync protocol.

The purpose of the Identify phase is to identify both dojo's to each other, the identity of the authenticated user, and the last known sync_state.

export interface DojoSyncIdentifyParams {
    protocolVersion: DojoSyncProtocolVersion;
    userIdentityKey: string;
    dojoIdentityKey: string;
    dojoName?: string;
    refNum: string;
}

See also: DojoSyncProtocolVersion

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

Interface: DojoSyncIdentifyResultApi

export interface DojoSyncIdentifyResultApi {
    refNum: string;
    identityKey: string;
    name?: string;
    status: DojoSyncStatus;
    when?: Date;
    error?: DojoSyncErrorApi;
}

See also: DojoSyncErrorApi, DojoSyncStatus

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

Interface: DojoSyncMapApi

export interface DojoSyncMapApi {
    aliasIds: Record<number, number>;
    certificateIds: Record<number, number>;
    commissionIds: Record<number, number>;
    responseIds: Record<number, number>;
    basketIds: Record<number, number>;
    outputIds: Record<number, number>;
    provenTxReqIds: Record<number, number>;
    provenTxIds: Record<number, number>;
    txIds: Record<number, number>;
    txLabelIds: Record<number, number>;
    outputTagIds: Record<number, number>;
}

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

Interface: DojoSyncMergeParams

export interface DojoSyncMergeParams {
    protocolVersion: DojoSyncProtocolVersion;
    refNum: string;
    when?: Date;
    state?: DojoUserStateApi;
    total?: number;
    iSyncMap?: DojoSyncMapApi;
    error?: DojoSyncErrorApi;
}

See also: DojoSyncErrorApi, DojoSyncMapApi, DojoSyncProtocolVersion, DojoUserStateApi

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

Interface: DojoSyncMergeResultApi

export interface DojoSyncMergeResultApi {
    refNum: string;
    status: DojoSyncStatus;
    iSyncMap?: DojoSyncMapApi;
    error?: DojoSyncErrorApi;
}

See also: DojoSyncErrorApi, DojoSyncMapApi, DojoSyncStatus

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

Interface: DojoSyncOptionsApi

export interface DojoSyncOptionsApi {
    disableSync?: boolean;
}

disableSync?: boolean

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

Interface: DojoSyncUpdateParams

export interface DojoSyncUpdateParams {
    protocolVersion: DojoSyncProtocolVersion;
    refNum: string;
    since?: Date;
}

See also: DojoSyncProtocolVersion

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

Interface: DojoSyncUpdateResultApi

export interface DojoSyncUpdateResultApi {
    refNum: string;
    status: DojoSyncStatus;
    since?: Date;
    state?: DojoUserStateApi;
    error?: DojoSyncErrorApi;
}

See also: DojoSyncErrorApi, DojoSyncStatus, DojoUserStateApi

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

Interface: DojoTransactionApi

export interface DojoTransactionApi extends DojoEntityTimeStampApi {
    transactionId?: number;
    created_at?: Date | null;
    updated_at?: Date | null;
    txid: string;
    lockTime?: number | null;
    version?: number | null;
    rawTransaction: Buffer | null;
    status: DojoTransactionStatusApi;
    referenceNumber: string | null;
    amount: number;
    userId: number;
    senderPaymail: string | null;
    recipientPaymail: string | null;
    note: string | null;
    isOutgoing: boolean;
    unconfirmedInputChainLength: number;
    proof: string | null;
    beef: Buffer | null;
    truncatedExternalInputs: string | null;
    provenTxId?: number | null;
    labels?: string[];
}

See also: DojoEntityTimeStampApi, DojoTransactionStatusApi

amount: number

isOutgoing: boolean

labels?: string[]

lockTime?: number | null

note: string | null

provenTxId?: number | null

rawTransaction: Buffer | null

recipientPaymail: string | null

referenceNumber: string | null

senderPaymail: string | null

status: DojoTransactionStatusApi

txid: string

version?: number | null

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

Interface: DojoTransactionXApi

export interface DojoTransactionXApi extends DojoTransactionApi {
    inputs?: DojoOutputXApi[];
    outputs?: DojoOutputXApi[];
}

See also: DojoOutputXApi, DojoTransactionApi

inputs?: DojoOutputXApi[]

outputs?: DojoOutputXApi[]

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

Interface: DojoTxInputSelectionApi

If Dojo needs to select more inputs beyond the ones specified in order to fund the transaction, this object describes which kinds of inputs can be selected, and from where.

export interface DojoTxInputSelectionApi {
    disable: boolean;
    baskets: string[];
    maxUnconfirmedChainLength?: number;
    includeSending?: boolean;
}

baskets: string[]

disable: boolean

includeSending?: boolean

maxUnconfirmedChainLength?: number

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

Interface: DojoTxInputsApi

export interface DojoTxInputsApi extends OptionalEnvelopeEvidenceApi {
    outputsToRedeem: DojoOutputToRedeemApi[];
}

See also: DojoOutputToRedeemApi

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

Interface: DojoTxLabelApi

export interface DojoTxLabelApi extends DojoEntityTimeStampApi {
    txLabelId?: number;
    created_at?: Date | null;
    updated_at?: Date | null;
    label: string;
    userId: number;
    whenLastUsed?: Date | null;
    isDeleted?: boolean;
}

See also: DojoEntityTimeStampApi

isDeleted?: boolean

label: string

whenLastUsed?: Date | null

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

Interface: DojoTxLabelMapApi

export interface DojoTxLabelMapApi extends DojoEntityTimeStampApi {
    created_at?: Date | null;
    updated_at?: Date | null;
    txLabelId: number;
    transactionId: number;
    isDeleted?: boolean;
}

See also: DojoEntityTimeStampApi

isDeleted?: boolean

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

Interface: DojoUserApi

export interface DojoUserApi extends DojoClientUserApi, DojoEntityTimeStampApi {
    userId?: number;
    created_at?: Date | null;
    updated_at?: Date | null;
    identityKey: string;
    timeSpentProcessingRequests?: number;
    bandwidthUsed?: number;
    storageSpaceUsedByHostedData?: number;
}

See also: DojoClientUserApi, DojoEntityTimeStampApi

bandwidthUsed?: number

identityKey: string

storageSpaceUsedByHostedData?: number

timeSpentProcessingRequests?: number

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

Interface: DojoUserStateApi

export interface DojoUserStateApi {
    since?: Date;
    user: DojoUserApi;
    certificates: DojoCertificateApi[];
    certificateFields: DojoCertificateFieldApi[];
    commissions: DojoCommissionApi[];
    mapiResponses: DojoMapiResponseApi[];
    outputs: DojoOutputApi[];
    baskets: DojoOutputBasketApi[];
    provenTxReqs: DojoProvenTxReqApi[];
    provenTxs: DojoProvenTxApi[];
    txs: DojoTransactionApi[];
    txLabels: DojoTxLabelApi[];
    txLabelMaps: DojoTxLabelMapApi[];
    outputTags: DojoOutputTagApi[];
    outputTagMaps: DojoOutputTagMapApi[];
}

See also: DojoCertificateApi, DojoCertificateFieldApi, DojoCommissionApi, DojoMapiResponseApi, DojoOutputApi, DojoOutputBasketApi, DojoOutputTagApi, DojoOutputTagMapApi, DojoProvenTxApi, DojoProvenTxReqApi, DojoTransactionApi, DojoTxLabelApi, DojoTxLabelMapApi, DojoUserApi

since?: Date

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

Interface: DojoWalletCertificate

export interface DojoWalletCertificate extends sdk.WalletCertificate {
    counterparty: sdk.PubKeyHex;
    keyring: Record<sdk.CertificateFieldNameUnder50Bytes, string>;
}

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

Interface: IdentityGroup

export interface IdentityGroup {
    totalTrust: number;
    members: IdentityGroupMember[];
}

See also: IdentityGroupMember

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

Interface: IdentityGroupMember

export interface IdentityGroupMember {
    certifier: CertifierDetails;
    subject: string;
}

See also: CertifierDetails

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

Interface: LiveBlockHeader

The "live" portion of the block chain is recent history that can conceivably be subject to reorganizations. The additional fields support tracking orphan blocks, chain forks, and chain reorgs.

export interface LiveBlockHeader extends BlockHeader {
    chainWork: Buffer;
    isChainTip: boolean;
    isActive: boolean;
    headerId: number;
    previousHeaderId: number | null;
}

See also: BlockHeader

chainWork: Buffer

headerId: number

isActive: boolean

isChainTip: boolean

previousHeaderId: number | null

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

Interface: LiveBlockHeaderHex

Like LiveBlockHeader but 32 byte fields are hex encoded strings.

export interface LiveBlockHeaderHex extends BlockHeaderHex {
    chainWork: string;
    isChainTip: boolean;
    isActive: boolean;
    headerId: number;
    previousHeaderId: number | null;
}

See also: BlockHeaderHex

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

Interface: MapiCallbackPayloadApi

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

export interface MapiCallbackPayloadApi {
    apiVersion: string;
    timestamp: string;
    blockHash: string;
    blockHeight: number;
    callbackTxId: string;
    callbackReason: string;
    callbackPayload: string;
}

See also: blockHash

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

Interface: MapiPostTxPayloadApi

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

export interface MapiPostTxPayloadApi {
    apiVersion: string;
    timestamp: string;
    txid: string;
    returnResult: string;
    resultDescription: string;
    minerId: string;
    currentHighestBlockHash?: string;
    currentHighestBlockHeight?: number;
    txSecondMempoolExpiry?: number;
    failureRetryable?: boolean;
    warnings?: unknown[];
    conflictedWith?: unknown[];
}

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

Interface: MapiTxStatusPayloadApi

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

export interface MapiTxStatusPayloadApi {
    apiVersion: string;
    timestamp: string;
    txid: string;
    returnResult: string;
    blockHash: string;
    blockHeight: number;
    confirmations: number;
    minerId: string;
    txSecondMempoolExpiry: number;
    merkleProof?: TscMerkleProofApi;
}

See also: blockHash

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

Interface: MapiTxidReturnResultApi

Used to parse payloads when only confirmation that a miner acknowledges a specific txid matters.

export interface MapiTxidReturnResultApi {
    apiVersion?: string;
    timestamp?: string;
    txid: string;
    returnResult: string;
}

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

Interface: Result

export interface Result {
    subject: string;
    certifier: string;
}

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

Interface: ScriptTemplateParamsSABPPP

export interface ScriptTemplateParamsSABPPP {
    derivationPrefix?: string;
    derivationSuffix?: string;
}

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

Interface: Settings

export interface Settings {
    trustThreshold: number;
}

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

Interface: SyncDojoConfigBaseApi

Each syncDojo config has the following properties:

'dojoType' one of 'Cloud URL' | 'Sqlite File' | 'MySql Connection' 'dojoIdentityKey' the identity key of the syncDojo. 'dojoName' the name of the syncDojo.

export interface SyncDojoConfigBaseApi {
    dojoType: SyncDojoConfigType;
    dojoIdentityKey: string;
    dojoName?: string;
}

See also: SyncDojoConfigType

dojoIdentityKey: string

dojoName?: string

dojoType: SyncDojoConfigType

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

Interface: SyncDojoConfigCloudUrl

The derived SyncDojoConfigCloudUrl interface adds:

'url' the service URL of the cloud dojo with which to sync

'clientPrivateKey' should be the authenticated user's private key matching their identityKey to enable automatic use of Authrite.

'useIdentityKey' may be set to true instead of using 'clientPrivateKey' if the cloud dojo does not use Authrite for access control.

The cloud dojo must exists and must already be configured with matching dojoIdentityKey.

If neither 'clientPrivateKey' or 'useIdentityKey' has a value, will attempt to use the Babbage signing strategy for Authrite.

export interface SyncDojoConfigCloudUrl extends SyncDojoConfigBaseApi {
    url: string;
    clientPrivateKey?: string;
    useIdentityKey?: boolean;
}

See also: SyncDojoConfigBaseApi

clientPrivateKey?: string

url: string

useIdentityKey?: boolean

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

Interface: SyncDojoConfigMySqlConnection

export interface SyncDojoConfigMySqlConnection extends SyncDojoConfigBaseApi {
    connection: string;
}

See also: SyncDojoConfigBaseApi

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

Interface: SyncDojoConfigSqliteFile

export interface SyncDojoConfigSqliteFile extends SyncDojoConfigBaseApi {
    filename: string;
}

See also: SyncDojoConfigBaseApi

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

Interface: TrustEvaluatorParams

export interface TrustEvaluatorParams {
    settings: Settings;
    certifiers: CertifierDetails[];
    results: Result[];
}

See also: CertifierDetails, Result, Settings

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

Interface: TrxToken

Place holder for the transaction control object used by actual storage provider implementation.

export interface TrxToken {
}

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

Classes

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

Class: CwiError

Errors which extend CwiError implement name as an alternate getter for code, and message as an alternate getter for description.

This supports catch handlers that might catch both Error derived or CwiErrorBase derived errors.

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

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

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

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

export class CwiError extends Error {
    isError = true;
    constructor(code: string, description: string, stack?: string, public details?: Record<string, string>) 
    static fromUnknown(err: unknown): CwiError 
    get code(): string 
    set code(v: string) 
    get description(): string 
    set description(v: string) 
    asStatus(): {
        status: string;
        code: string;
        description: string;
    } 
    toJSON_old(): object 
}

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

static fromUnknown(err: unknown): CwiError 

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

Class: ERR_BAD_REQUEST

The request is invalid.

export class ERR_BAD_REQUEST extends CwiError {
    constructor(description?: string) 
}

See also: CwiError

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

Class: ERR_CHAIN

Configured chain is invalid or does not match across services.

export class ERR_CHAIN extends CwiError {
    constructor(description?: string) 
}

See also: CwiError

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

Class: ERR_CHAIN_INVALID

The current chain tip is not in sync with external sources.

export class ERR_CHAIN_INVALID extends CwiError {
    constructor() 
}

See also: CwiError

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

Class: ERR_DOJO_BROADCAST_DUPE

Transaction was already broadcast.

export class ERR_DOJO_BROADCAST_DUPE extends CwiError {
    constructor() 
}

See also: CwiError

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

Class: ERR_DOJO_BROADCAST_FAILED

description || 'Dojo transaction broadcast failed.'

export class ERR_DOJO_BROADCAST_FAILED extends CwiError {
    constructor(description?: string) 
}

See also: CwiError

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

Class: ERR_DOJO_CERT_DUPE

Certificate already exists.

export class ERR_DOJO_CERT_DUPE extends CwiError {
    constructor() 
}

See also: CwiError

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

Class: ERR_DOJO_CERT_INVALID

Certificate signature is invalid.

export class ERR_DOJO_CERT_INVALID extends CwiError {
    constructor() 
}

See also: CwiError

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

Class: ERR_DOJO_CERT_SUBJECT

Certificate subject must match authenticated user's identityKey.

export class ERR_DOJO_CERT_SUBJECT extends CwiError {
    constructor() 
}

See also: CwiError

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

Class: ERR_DOJO_COMPLETED_TX

Update is invalid on completed transaction txid=${asString(txid)}

export class ERR_DOJO_COMPLETED_TX extends CwiError {
    constructor(txid: string | Buffer) 
}

See also: CwiError

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

Class: ERR_DOJO_CREATE_TX_EMPTY

Transaction must have at least one input and output.

export class ERR_DOJO_CREATE_TX_EMPTY extends CwiError {
    constructor() 
}

See also: CwiError

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

Class: ERR_DOJO_FOREIGN_KEY

description || 'Dojo foreign key validation error.'

export class ERR_DOJO_FOREIGN_KEY extends CwiError {
    constructor(description?: string) 
}

See also: CwiError

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

Class: ERR_DOJO_INVALID_BASKET_NAME

Basket names must have one visible character and not more than 1000.

export class ERR_DOJO_INVALID_BASKET_NAME extends CwiError {
    constructor() 
}

See also: CwiError

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

Class: ERR_DOJO_INVALID_BEEF

Basket names must have one visible character and not more than 1000.

export class ERR_DOJO_INVALID_BEEF extends CwiError {
    constructor(description?: string) 
}

See also: CwiError

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

Class: ERR_DOJO_INVALID_CUSTOM_INSTRUCTIONS

Output customInstruction must be a string or length not more than 2500.

export class ERR_DOJO_INVALID_CUSTOM_INSTRUCTIONS extends CwiError {
    constructor() 
}

See also: CwiError

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

Class: ERR_DOJO_INVALID_NOTE

The transaction note is invalid.

export class ERR_DOJO_INVALID_NOTE extends CwiError {
    constructor() 
}

See also: CwiError

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

Class: ERR_DOJO_INVALID_OUTPOINT

The outpoint (txid and vout combination) does not belong to a transaction known by this user of the server.

export class ERR_DOJO_INVALID_OUTPOINT extends CwiError {
    constructor() 
}

See also: CwiError

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

Class: ERR_DOJO_INVALID_OUTPUT_DESCRIPTION

Output description must be a string or length not more than 255.

export class ERR_DOJO_INVALID_OUTPUT_DESCRIPTION extends CwiError {
    constructor() 
}

See also: CwiError

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

Class: ERR_DOJO_INVALID_OUTPUT_TAG

Output tags must have one visible character and not more than 150.

export class ERR_DOJO_INVALID_OUTPUT_TAG extends CwiError {
    constructor() 
}

See also: CwiError

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

Class: ERR_DOJO_INVALID_PAYMAIL_DOMAIN

This server is not accepting registrations for new Paymail handles under the specified domain name.

export class ERR_DOJO_INVALID_PAYMAIL_DOMAIN extends CwiError {
    constructor() 
}

See also: CwiError

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

Class: ERR_DOJO_INVALID_PAYMAIL_HANDLE

The paymail handle is invalid.

export class ERR_DOJO_INVALID_PAYMAIL_HANDLE extends CwiError {
    constructor(description?: string) 
}

See also: CwiError

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

Class: ERR_DOJO_INVALID_REDEEM

outputToRedeem is invalid

export class ERR_DOJO_INVALID_REDEEM extends CwiError {
    constructor(description?: string) 
}

See also: CwiError

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

Class: ERR_DOJO_INVALID_REFERENCE

The transaction reference is invalid.

export class ERR_DOJO_INVALID_REFERENCE extends CwiError {
    constructor(reference?: string) 
}

See also: CwiError

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

Class: ERR_DOJO_INVALID_SATOSHIS

An amount of satoshis must be a non-negative integer less than 21e14.

export class ERR_DOJO_INVALID_SATOSHIS extends CwiError {
    constructor() 
}

See also: CwiError

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

Class: ERR_DOJO_INVALID_SCRIPT

Script must be a valid Bitcoin script.

export class ERR_DOJO_INVALID_SCRIPT extends CwiError {
    constructor(description?: string) 
}

See also: CwiError

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

Class: ERR_DOJO_INVALID_TIME

Time values must be integer number of seconds since the epoch.

export class ERR_DOJO_INVALID_TIME extends CwiError {
    constructor() 
}

See also: CwiError

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

Class: ERR_DOJO_INVALID_TRANSACTION_BEEF

The transaction BEEF is invalid.

export class ERR_DOJO_INVALID_TRANSACTION_BEEF extends CwiError {
    constructor(description?: string) 
}

See also: CwiError

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

Class: ERR_DOJO_INVALID_TRANSACTION_STATUS

The status of this transaction is ${stat}, which is not compatible with this operation. The transaction was not broadcasted by the recipient.

export class ERR_DOJO_INVALID_TRANSACTION_STATUS extends CwiError {
    constructor(stat: string) 
}

See also: CwiError

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

Class: ERR_DOJO_INVALID_TXID

Transaction labels must have one visible character and not more than 150.

export class ERR_DOJO_INVALID_TXID extends CwiError {
    constructor(txid: string) 
}

See also: CwiError

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

Class: ERR_DOJO_INVALID_TX_LABEL

Transaction labels must have one visible character and not more than 150.

export class ERR_DOJO_INVALID_TX_LABEL extends CwiError {
    constructor() 
}

See also: CwiError

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

Class: ERR_DOJO_INVALID_TX_RECIPIENT

Transaction recipient must be not more than 100.

export class ERR_DOJO_INVALID_TX_RECIPIENT extends CwiError {
    constructor() 
}

See also: CwiError

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

Class: ERR_DOJO_LABEL_NOT_FOUND

The label cannot be found linked with your user account.

export class ERR_DOJO_LABEL_NOT_FOUND extends CwiError {
    constructor() 
}

See also: CwiError

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

Class: ERR_DOJO_NOSENDCHANGE

outputToRedeem is invalid

export class ERR_DOJO_NOSENDCHANGE extends CwiError {
    constructor(description: string | OutPoint) 
}

See also: CwiError

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