ninja-base

ninja-base

Base level functions, classes, interfaces for Ninja

API

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

Interfaces

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

Interface: CwiCoreApi

Starting point for cwi-core's typescript api.

Supports design and testing.

export interface CwiCoreApi {
    createAction(params: CreateActionParams): Promise<CreateActionResult>;
}

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

Interface: DojoExpressClientOptions

export interface DojoExpressClientOptions {
    authrite?: AuthriteClient;
    identityKey?: string;
}

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

Interface: KeyPairApi

export interface KeyPairApi {
    privateKey: string;
    publicKey: string;
}

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

Interface: NinjaAbortActionParams

export interface NinjaAbortActionParams {
    referenceNumber: string;
    log: string | undefined;
}

log: string | undefined

referenceNumber: string

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

Interface: NinjaAbortActionResultApi

export interface NinjaAbortActionResultApi {
    referenceNumber: string;
    log: string | undefined;
}

log: string | undefined

referenceNumber: string

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

Interface: NinjaApi

A client for creating, signing, and delivering Bitcoin transactions

export interface NinjaApi {
    dojo: DojoClientApi;
    authenticate(identityKey?: string, addIfNew?: boolean): Promise<void>;
    isAuthenticated(): boolean;
    sync(): Promise<void>;
    setSyncDojosByConfig(syncDojoConfigs: SyncDojoConfigBaseApi[], options?: DojoSyncOptionsApi): Promise<void>;
    getSyncDojosByConfig(): Promise<{
        dojos: SyncDojoConfigBaseApi[];
        options?: DojoSyncOptionsApi;
    }>;
    getClientChangeKeyPair(): KeyPairApi;
    getPaymail(): Promise<string>;
    setPaymail(paymail: string): Promise<void>;
    getChain(): Promise<Chain>;
    getNetwork(format?: "default" | "nonet"): Promise<string>;
    findCertificates(certifiers?: string[] | object, types?: Record<string, string[]>): Promise<{
        status: "success";
        certificates: DojoCertificateApi[];
    }>;
    saveCertificate(certificate: DojoCertificateApi | object): Promise<void>;
    getTotalValue(basket?: string): Promise<{
        total: number;
    }>;
    getTotalOfAmounts(options: DojoGetTotalOfAmountsOptions): Promise<{
        total: number;
    }>;
    getNetOfAmounts(options?: DojoGetTotalOfAmountsOptions): Promise<number>;
    getAvatar(): Promise<DojoAvatarApi>;
    setAvatar(name: string, photoURL: string): Promise<void>;
    getTransactions(options?: DojoGetTransactionsOptions): Promise<NinjaGetTransactionsResultApi>;
    getTransactionOutputs(options?: DojoGetTransactionOutputsOptions): Promise<NinjaGetTransactionOutputsResultApi[]>;
    getTransactionLabels(options?: DojoGetTransactionLabelsOptions): Promise<{
        labels: DojoTxLabelApi[];
        total: number;
    }>;
    getEnvelopeForTransaction(txid: string): Promise<EnvelopeApi | undefined>;
    getPendingTransactions(referenceNumber?: string): Promise<DojoPendingTxApi[]>;
    updateTransactionStatus(params: {
        reference: string;
        status: DojoTransactionStatusApi;
    }): Promise<void>;
    updateOutpointStatus(params: {
        txid: string;
        vout: number;
        spendable: boolean;
    }): Promise<void>;
    createAction(params: NinjaCreateActionParams): Promise<NinjaCreateActionResult>;
    processPendingTransactions(onTransactionProcessed?: NinjaTransactionProcessedHandler, onTransactionFailed?: NinjaTransactionFailedHandler): Promise<void>;
    processTransaction(params: DojoProcessTransactionParams): Promise<DojoProcessTransactionResultApi>;
    getTransactionWithOutputs(params: NinjaGetTransactionWithOutputsParams): Promise<NinjaTransactionWithOutputsResultApi>;
    createTransactionWithOutputs(params: NinjaGetTransactionWithOutputsParams): Promise<NinjaTransactionWithOutputsResultApi>;
    processTransactionWithOutputs(params: NinjaGetTransactionWithOutputsParams): Promise<NinjaTransactionWithOutputsResultApi>;
    signAction(params: NinjaSignActionParams): Promise<NinjaSignActionResultApi>;
    abortAction(params: NinjaAbortActionParams): Promise<NinjaAbortActionResultApi>;
    createTransaction(params: NinjaCreateTransactionParams): Promise<DojoCreateTransactionResultApi>;
    submitDirectTransaction(params: NinjaSubmitDirectTransactionParams): Promise<NinjaSubmitDirectTransactionResultApi>;
    deleteCertificate(partial: Partial<DojoCertificateApi>): Promise<number>;
    labelTransaction(txid: string | number | Partial<DojoTransactionApi>, label: string): Promise<void>;
    unlabelTransaction(txid: string | number | Partial<DojoTransactionApi>, label: string): Promise<void>;
    tagOutput(output: {
        txid: string;
        vout: number;
    }, tag: string): Promise<void>;
    untagOutput(output: {
        txid: string;
        vout: number;
    }, tag: string): Promise<void>;
    unbasketOutput(output: {
        txid: string;
        vout: number;
    }): Promise<void>;
    getEnvelopesOfConflictingTransactions(txid: string): Promise<EnvelopeApi[]>;
    getHeight(): Promise<number>;
    getMerkleRootForHeight(height: number): Promise<string | undefined>;
    getHeaderForHeight(height: number): Promise<number[] | undefined>;
    getInfo(params: GetInfoParams): Promise<GetInfoResult>;
    listActions(vargs: sdk.ValidListActionsArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.ListActionsResult>;
    listOutputs(vargs: sdk.ValidListOutputsArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.ListOutputsResult>;
    createActionSdk(vargs: sdk.ValidCreateActionArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.CreateActionResult>;
    signActionSdk(vargs: sdk.ValidSignActionArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.SignActionResult>;
    abortActionSdk(vargs: sdk.ValidAbortActionArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.AbortActionResult>;
    internalizeActionSdk(vargs: sdk.ValidInternalizeActionArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.InternalizeActionResult>;
    relinquishOutputSdk(vargs: sdk.ValidRelinquishOutputArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.RelinquishOutputResult>;
    acquireCertificateSdk(vargs: sdk.AcquireCertificateArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.AcquireCertificateResult>;
    listCertificatesSdk(vargs: sdk.ValidListCertificatesArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.ListCertificatesResult>;
}

See also: KeyPairApi, NinjaAbortActionParams, NinjaAbortActionResultApi, NinjaCreateActionParams, NinjaCreateActionResult, NinjaCreateTransactionParams, NinjaGetTransactionOutputsResultApi, NinjaGetTransactionWithOutputsParams, NinjaGetTransactionsResultApi, NinjaSignActionParams, NinjaSignActionResultApi, NinjaSubmitDirectTransactionParams, NinjaSubmitDirectTransactionResultApi, NinjaTransactionFailedHandler, NinjaTransactionProcessedHandler, NinjaTransactionWithOutputsResultApi, abortAction, createActionSdk, createTransactionWithOutputs, getTransactionWithOutputs, internalizeActionSdk, processPendingTransactions, processTransactionWithOutputs, relinquishOutputSdk, signAction, signActionSdk, submitDirectTransaction

dojo: DojoClientApi

abortAction(params: NinjaAbortActionParams): Promise<NinjaAbortActionResultApi>

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

createAction(params: NinjaCreateActionParams): Promise<NinjaCreateActionResult>

createTransaction(params: NinjaCreateTransactionParams): Promise<DojoCreateTransactionResultApi>

createTransactionWithOutputs(params: NinjaGetTransactionWithOutputsParams): Promise<NinjaTransactionWithOutputsResultApi>

deleteCertificate(partial: Partial<DojoCertificateApi>): Promise<number>

findCertificates(certifiers?: string[] | object, types?: Record<string, string[]>): Promise<{
    status: "success";
    certificates: DojoCertificateApi[];
}>

getAvatar(): Promise<DojoAvatarApi>

getChain(): Promise<Chain>

getClientChangeKeyPair(): KeyPairApi

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

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

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

getHeight(): Promise<number>

getInfo(params: GetInfoParams): Promise<GetInfoResult>

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

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

getNetwork(format?: "default" | "nonet"): Promise<string>

getPaymail(): Promise<string>

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

getSyncDojosByConfig(): Promise<{
    dojos: SyncDojoConfigBaseApi[];
    options?: DojoSyncOptionsApi;
}>

getTotalOfAmounts(options: DojoGetTotalOfAmountsOptions): Promise<{
    total: number;
}>

getTotalValue(basket?: string): Promise<{
    total: number;
}>

getTransactionLabels(options?: DojoGetTransactionLabelsOptions): Promise<{
    labels: DojoTxLabelApi[];
    total: number;
}>

getTransactionOutputs(options?: DojoGetTransactionOutputsOptions): Promise<NinjaGetTransactionOutputsResultApi[]>

getTransactionWithOutputs(params: NinjaGetTransactionWithOutputsParams): Promise<NinjaTransactionWithOutputsResultApi>

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

isAuthenticated(): boolean

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

processPendingTransactions(onTransactionProcessed?: NinjaTransactionProcessedHandler, onTransactionFailed?: NinjaTransactionFailedHandler): Promise<void>

processTransaction(params: DojoProcessTransactionParams): Promise<DojoProcessTransactionResultApi>

processTransactionWithOutputs(params: NinjaGetTransactionWithOutputsParams): Promise<NinjaTransactionWithOutputsResultApi>

saveCertificate(certificate: DojoCertificateApi | object): Promise<void>

setAvatar(name: string, photoURL: string): Promise<void>

setPaymail(paymail: string): Promise<void>

setSyncDojosByConfig(syncDojoConfigs: SyncDojoConfigBaseApi[], options?: DojoSyncOptionsApi): Promise<void>

signAction(params: NinjaSignActionParams): Promise<NinjaSignActionResultApi>

submitDirectTransaction(params: NinjaSubmitDirectTransactionParams): Promise<NinjaSubmitDirectTransactionResultApi>

sync(): Promise<void>

tagOutput(output: {
    txid: string;
    vout: number;
}, tag: string): Promise<void>

unbasketOutput(output: {
    txid: string;
    vout: number;
}): Promise<void>

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

untagOutput(output: {
    txid: string;
    vout: number;
}, tag: string): Promise<void>

updateOutpointStatus(params: {
    txid: string;
    vout: number;
    spendable: boolean;
}): Promise<void>

updateTransactionStatus(params: {
    reference: string;
    status: DojoTransactionStatusApi;
}): Promise<void>

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

Interface: NinjaCompleteCreateTransactionWithOutputsParams

export interface NinjaCompleteCreateTransactionWithOutputsParams {
    inputs?: Record<string, NinjaTxInputsApi>;
    note?: string;
    createResult: DojoCreateTransactionResultApi;
}

See also: NinjaTxInputsApi

inputs?: Record<string, NinjaTxInputsApi>

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

Interface: NinjaCreateActionConfirmResult

export interface NinjaCreateActionConfirmResult {
    proceedToSign: boolean;
}

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

Interface: NinjaCreateActionParams

export interface NinjaCreateActionParams {
    params: CreateActionParams;
    confirmCreateTransactionResult?: (result: NinjaTransactionWithOutputsResultApi) => Promise<NinjaCreateActionConfirmResult>;
}

See also: NinjaCreateActionConfirmResult, NinjaTransactionWithOutputsResultApi

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

Interface: NinjaCreateActionResult

export interface NinjaCreateActionResult {
    proceedToSign: boolean;
    result?: CreateActionResult;
}

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

Interface: NinjaCreateTransactionParams

Input parameters to createTransaction method.

export interface NinjaCreateTransactionParams {
    inputs: Record<string, DojoTxInputsApi>;
    inputSelection?: DojoTxInputSelectionApi;
    outputs: DojoCreateTxOutputApi[];
    outputGeneration?: DojoOutputGenerationApi;
    fee?: DojoFeeModelApi;
    labels: string[];
    note?: string;
    recipient?: string;
}

fee?: DojoFeeModelApi

inputSelection?: DojoTxInputSelectionApi

inputs: Record<string, DojoTxInputsApi>

labels: string[]

note?: string

outputGeneration?: DojoOutputGenerationApi

outputs: DojoCreateTxOutputApi[]

recipient?: string

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

Interface: NinjaGetPendingTransactionsInputApi

export interface NinjaGetPendingTransactionsInputApi extends EnvelopeEvidenceApi {
    outputsToRedeem: number[];
    instructions: Record<number, NinjaGetPendingTransactionsInstructionsApi>;
}

See also: NinjaGetPendingTransactionsInstructionsApi

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

Interface: NinjaGetPendingTransactionsInstructionsApi

export interface NinjaGetPendingTransactionsInstructionsApi {
    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: NinjaGetPendingTransactionsTxApi

export interface NinjaGetPendingTransactionsTxApi {
    transactionId: number;
    created_at: string;
    provenTxId?: number | null;
    status: DojoTransactionStatusApi;
    isOutgoing: boolean;
    amount: number;
    senderPaymail: string | undefined | null;
    referenceNumber: string;
    truncatedExternalInputs: string | null;
    rawTransaction: Buffer | null;
    inputs?: Record<string, NinjaGetPendingTransactionsInputApi>;
}

See also: NinjaGetPendingTransactionsInputApi

amount: number

created_at: string

inputs?: Record<string, NinjaGetPendingTransactionsInputApi>

provenTxId?: number | null

referenceNumber: string

senderPaymail: string | undefined | null

status: DojoTransactionStatusApi

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

Interface: NinjaGetTransactionOutputsResultApi

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

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

Input parameters to getTransactionWithOutputs method.

export interface NinjaGetTransactionWithOutputsParams {
    outputs?: DojoCreateTxOutputApi[];
    labels?: string[];
    inputs?: Record<string, NinjaTxInputsApi>;
    beef?: Beef | number[];
    note?: string;
    lockTime?: number;
    version?: number;
    recipient?: string;
    autoProcess?: boolean;
    feePerKb?: number;
    feeModel?: DojoFeeModelApi;
    options?: CreateActionOptions;
    acceptDelayedBroadcast?: boolean;
    log?: string;
}

See also: NinjaTxInputsApi

acceptDelayedBroadcast?: boolean

autoProcess?: boolean

beef?: Beef | number[]

feeModel?: DojoFeeModelApi

feePerKb?: number

inputs?: Record<string, NinjaTxInputsApi>

labels?: string[]

lockTime?: number

log?: string

note?: string

options?: CreateActionOptions

outputs?: DojoCreateTxOutputApi[]

recipient?: string

version?: number

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

Interface: NinjaGetTransactionsResultApi

export interface NinjaGetTransactionsResultApi {
    totalTransactions: number;
    transactions: NinjaGetTransactionsTxApi[];
}

See also: NinjaGetTransactionsTxApi

totalTransactions: number

transactions: NinjaGetTransactionsTxApi[]

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

Interface: NinjaGetTransactionsTxApi

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

See also: NinjaGetTransactionsTxInputApi, NinjaGetTransactionsTxOutputApi

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

export interface NinjaGetTransactionsTxInputApi extends 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: NinjaGetTransactionsTxOutputApi

export interface NinjaGetTransactionsTxOutputApi extends 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: NinjaOutputToRedeemApi

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

index: number

sequenceNumber?: number

unlockingScript: string | number

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

Interface: NinjaSignActionParams

export interface NinjaSignActionParams extends NinjaSignCreatedTransactionParams {
    inputs: Record<string, NinjaTxInputsApi>;
    createResult: DojoCreateTransactionResultApi;
    acceptDelayedBroadcast?: boolean;
}

See also: NinjaSignCreatedTransactionParams, NinjaTxInputsApi

acceptDelayedBroadcast?: boolean

createResult: DojoCreateTransactionResultApi

inputs: Record<string, NinjaTxInputsApi>

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

Interface: NinjaSignActionResultApi

export interface NinjaSignActionResultApi extends NinjaTransactionWithOutputsResultApi {
    rawTx?: string;
    txid?: string;
    amount: number;
    inputs: Record<string, OptionalEnvelopeEvidenceApi>;
    note?: string;
    referenceNumber: string;
    outputMap?: Record<string, number>;
    mapiResponses?: MapiResponseApi[];
    log?: string;
}

See also: NinjaTransactionWithOutputsResultApi

amount: number

inputs: Record<string, OptionalEnvelopeEvidenceApi>

log?: string

mapiResponses?: MapiResponseApi[]

outputMap?: Record<string, number>

rawTx?: string

referenceNumber: string

txid?: string

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

Interface: NinjaSignCreatedTransactionParams

export interface NinjaSignCreatedTransactionParams {
    inputs: Record<string, NinjaTxInputsApi>;
    createResult: DojoCreateTransactionResultApi;
}

See also: NinjaTxInputsApi

inputs: Record<string, NinjaTxInputsApi>

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

Interface: NinjaSubmitDirectTransactionApi

Transaction input parameter to submitDirectTransaction method.

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

See also: NinjaSubmitDirectTransactionOutputApi

outputs: NinjaSubmitDirectTransactionOutputApi[]

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

Interface: NinjaSubmitDirectTransactionOutputApi

export interface NinjaSubmitDirectTransactionOutputApi extends 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: NinjaSubmitDirectTransactionParams

Input parameters to submitDirectTransaction method.

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

See also: NinjaSubmitDirectTransactionApi

derivationPrefix?: string

labels?: string[]

note: string

protocol?: string

senderIdentityKey: string

transaction: NinjaSubmitDirectTransactionApi

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

Interface: NinjaSubmitDirectTransactionResultApi

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

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

Interface: NinjaTransactionFailedApi

export interface NinjaTransactionFailedApi {
    inputs: Record<string, DojoPendingTxInputApi>;
    isOutgoing: boolean;
    reference: string;
    error: CwiError;
}

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

Interface: NinjaTransactionProcessedApi

export interface NinjaTransactionProcessedApi {
    inputs: Record<string, DojoPendingTxInputApi>;
    outputs: DojoPendingTxOutputApi[];
    isOutgoing: boolean;
    reference: string;
    txid: string;
    amount: number;
    hex: string;
    derivationPrefix?: string;
    senderIdentityKey?: string;
}

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

Interface: NinjaTransactionWithOutputsResultApi

export interface NinjaTransactionWithOutputsResultApi {
    signActionRequired?: boolean;
    createResult?: DojoCreateTransactionResultApi;
    beef?: number[];
    noSendChange?: OutPoint[];
    rawTx?: string;
    txid?: string;
    amount: number;
    inputs: Record<string, OptionalEnvelopeEvidenceApi>;
    note?: string;
    referenceNumber: string;
    outputMap?: Record<string, number>;
    mapiResponses?: MapiResponseApi[];
    options: CreateActionOptions;
    log?: string;
}

amount: number

beef?: number[]

createResult?: DojoCreateTransactionResultApi

inputs: Record<string, OptionalEnvelopeEvidenceApi>

log?: string

mapiResponses?: MapiResponseApi[]

noSendChange?: OutPoint[]

options: CreateActionOptions

outputMap?: Record<string, number>

rawTx?: string

referenceNumber: string

signActionRequired?: boolean

txid?: string

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

Interface: NinjaTxInputsApi

export interface NinjaTxInputsApi extends OptionalEnvelopeEvidenceApi {
    outputsToRedeem: NinjaOutputToRedeemApi[];
}

See also: NinjaOutputToRedeemApi

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

Interface: NinjaV1Params

export interface NinjaV1Params {
    privateKey?: string;
    config?: {
        dojoURL: string;
    };
    taalApiKeys?: {
        test: string;
        main: string;
    };
}

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

Interface: PendingDojoInput

export interface PendingDojoInput {
    vin: number;
    derivationPrefix: string;
    derivationSuffix: string;
    unlockerPubKey?: string;
    sourceSatoshis: number;
    lockingScript: string;
}

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

Interface: PendingSignAction

export interface PendingSignAction {
    reference: string;
    dcr: DojoCreateTransactionSdkResult;
    args: sdk.ValidCreateActionArgs;
    tx: Transaction;
    amount: number;
    pdi: PendingDojoInput[];
}

See also: PendingDojoInput

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

Interface: ProcessIncomingTransactionApi

export interface ProcessIncomingTransactionApi {
    inputs?: Record<string, ProcessIncomingTransactionInputApi>;
    outputs: ProcessIncomingTransactionOutputApi[];
    referenceNumber?: string;
    rawTransaction?: string;
    rawTx?: string;
    derivationPrefix?: string;
}

See also: ProcessIncomingTransactionInputApi, ProcessIncomingTransactionOutputApi

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

Interface: ProcessIncomingTransactionInputApi

export interface ProcessIncomingTransactionInputApi {
}

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

Interface: ProcessIncomingTransactionOutputApi

export interface ProcessIncomingTransactionOutputApi {
    vout?: number;
    satoshis?: number;
    amount?: number;
    senderIdentityKey?: string;
    derivationSuffix?: string;
    derivationPrefix?: string;
    paymailHandle?: string;
}

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

Interface: ProcessIncomingTransactionResultApi

export interface ProcessIncomingTransactionResultApi {
    txid: string;
    amount: number;
    derivationPrefix?: string;
    senderIdentityKey?: string;
}

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

Interface: SignActionParams

export interface SignActionParams {
    inputs: Record<string, NinjaTxInputsApi>;
    createResult?: NinjaTransactionWithOutputsResultApi;
    originator?: string;
    acceptDelayedBroadcast?: boolean;
    log?: string;
}

See also: NinjaTransactionWithOutputsResultApi, NinjaTxInputsApi

acceptDelayedBroadcast?: boolean

createResult?: NinjaTransactionWithOutputsResultApi

inputs: Record<string, NinjaTxInputsApi>

log?: string

originator?: string

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

Interface: TxOutputApi

export interface TxOutputApi {
    satoshis: number;
    script: string;
}

satoshis: number

script: string

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

Interface: TxRedeemableOutputApi

export interface TxRedeemableOutputApi {
    index: number;
    unlockingScriptLength: number;
}

index: number

unlockingScriptLength: number

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

Classes

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

Class: DojoExpressClient

Connects to a DojoExpress to implement DojoApi

export class DojoExpressClient implements DojoClientApi {
    static createDojoExpressClientOptions(): DojoExpressClientOptions 
    authrite?: AuthriteClient;
    options: DojoExpressClientOptions;
    get userId(): number 
    get identityKey(): string 
    get isAuthenticated(): boolean 
    syncDojoConfig?: SyncDojoConfigBaseApi;
    constructor(public chain: Chain, public serviceUrl: string, options?: DojoExpressClientOptions) 
    isDojoExpressClient(): boolean 
    async destroy(): Promise<void> 
    async getChain(): Promise<Chain> 
    async stats(): Promise<DojoStatsApi> 
    async getDojoIdentity(): Promise<DojoIdentityApi> 
    async authenticate(identityKey?: string, addIfNew?: boolean): Promise<void> 
    getUser(): DojoClientUserApi 
    async verifyAuthenticated(): Promise<void> 
    async getSyncDojoConfig(): Promise<SyncDojoConfigBaseApi> 
    setSyncDojos(dojos: DojoSyncApi[], syncOptions?: DojoSyncOptionsApi | undefined): void 
    getSyncDojos(): {
        dojos: DojoSyncApi[];
        options: DojoSyncOptionsApi;
    } 
    async setSyncDojosByConfig(syncDojoConfigs: SyncDojoConfigBaseApi[], options?: DojoSyncOptionsApi | undefined): Promise<void> 
    async getSyncDojosByConfig(): Promise<{
        dojos: SyncDojoConfigBaseApi[];
        options?: DojoSyncOptionsApi | undefined;
    }> 
    async sync(): Promise<void> 
    async syncIdentify(params: DojoSyncIdentifyParams): Promise<DojoSyncIdentifyResultApi> 
    async syncUpdate(params: DojoSyncUpdateParams): Promise<DojoSyncUpdateResultApi> 
    async syncMerge(params: DojoSyncMergeParams): Promise<DojoSyncMergeResultApi> 
    async getCurrentPaymails(): Promise<string[]> 
    async getAvatar(): Promise<DojoAvatarApi> 
    async setAvatar(avatar: DojoAvatarApi): Promise<void> 
    async saveCertificate(certificate: DojoCertificateApi): Promise<number> 
    async findCertificates(certifiers?: string[], types?: Record<string, string[]>): Promise<DojoCertificateApi[]> 
    async getTotalOfUnspentOutputs(basket?: string): Promise<number | undefined> 
    async updateOutpointStatus(txid: string, vout: number, spendable: boolean): Promise<void> 
    async getTotalOfAmounts(direction: "incoming" | "outgoing", options?: DojoGetTotalOfAmountsOptions): Promise<number> 
    async getNetOfAmounts(options?: DojoGetTotalOfAmountsOptions): Promise<number> 
    async updateTransactionStatus(reference: string, status: DojoTransactionStatusApi): Promise<void> 
    async getTransactions(options?: DojoGetTransactionsOptions): Promise<DojoGetTransactionsResultApi> 
    async getPendingTransactions(referenceNumber?: string): Promise<DojoPendingTxApi[]> 
    async getBeefForTransaction(txid: string, options?: DojoGetBeefOptions): Promise<Beef> 
    async getEnvelopeForTransaction(txid: string): Promise<EnvelopeApi | undefined> 
    async getEnvelopesOfConflictingTransactions(txid: string): Promise<EnvelopeApi[]> 
    async getTransactionOutputs(options?: DojoGetTransactionOutputsOptions): Promise<DojoGetTransactionOutputsResultApi> 
    async getTransactionLabels(options?: DojoGetTransactionLabelsOptions): Promise<DojoGetTransactionLabelsResultApi> 
    async currentHeight(): Promise<number> 
    async isValidRootForHeight(root: string, height: number): Promise<boolean> 
    async listActionsSdk(args: sdk.ValidListActionsArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.ListActionsResult> 
    async listOutputsSdk(args: sdk.ValidListOutputsArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.ListOutputsResult> 
    async listCertificatesSdk(args: sdk.ValidListCertificatesArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.ListCertificatesResult> 
    async acquireCertificateSdk(args: sdk.ValidAcquireCertificateArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.AcquireCertificateResult> 
    async internalizeActionSdk(args: DojoInternalizeActionArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.InternalizeActionResult> 
    async createTransactionSdk(args: sdk.ValidCreateActionArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<DojoCreateTransactionSdkResult> 
    async processActionSdk(params: DojoProcessActionSdkParams, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<DojoProcessActionSdkResults> 
    async abortActionSdk(vargs: sdk.ValidAbortActionArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.AbortActionResult> 
    async relinquishOutputSdk(vargs: sdk.ValidRelinquishOutputArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.RelinquishOutputResult> 
    async createTransaction(params: DojoCreateTransactionParams): Promise<DojoCreateTransactionResultApi> 
    async processTransaction(params: DojoProcessTransactionParams): Promise<DojoProcessTransactionResultApi> 
    async submitDirectTransaction(params: DojoSubmitDirectTransactionParams): Promise<DojoSubmitDirectTransactionResultApi> 
    async copyState(): Promise<DojoUserStateApi> 
    async getJsonOrUndefined<T>(path: string): Promise<T | undefined> 
    async getJson<T>(path: string): Promise<T> 
    handleError<T>(s: FetchStatus<T>, path: string): void 
    async postJsonOrUndefined<T, R>(path: string, params: T, noAuth?: boolean): Promise<R | undefined> 
    async postJson<T, R>(path: string, params: T, noAuth?: boolean): Promise<R> 
    async postJsonVoid<T>(path: string, params: T, noAuth?: boolean): Promise<void> 
    async softDeleteCertificate(partial: Partial<DojoCertificateApi>): Promise<number> 
    async softDeleteOutputTag(partial: Partial<DojoOutputTagApi>): Promise<number> 
    async softDeleteTxLabel(partial: Partial<DojoTxLabelApi>): Promise<number> 
    async softDeleteOutputBasket(partial: Partial<DojoOutputBasketApi>): Promise<number> 
    async labelTransaction(txid: string | number | Partial<DojoTransactionApi>, label: string): Promise<void> 
    async unlabelTransaction(txid: string | number | Partial<DojoTransactionApi>, label: string): Promise<void> 
    async tagOutput(partial: Partial<DojoOutputApi>, tag: string): Promise<void> 
    async untagOutput(partial: Partial<DojoOutputApi>, tag: string): Promise<void> 
    async unbasketOutput(partial: Partial<DojoOutputApi>): Promise<void> 
    async getHeight(): Promise<number> 
    async getMerkleRootForHeight(height: number): Promise<string | undefined> 
    async getHeaderForHeight(height: number): Promise<number[] | undefined> 
}

See also: DojoExpressClientOptions, internalizeActionSdk, processActionSdk, relinquishOutputSdk, submitDirectTransaction

constructor(public chain: Chain, public serviceUrl: string, options?: DojoExpressClientOptions) 

syncDojoConfig?: SyncDojoConfigBaseApi

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

Class: ERR_NINJA_INVALID_UNLOCK

Unlocking script for vin ${vin} (${txid}.${vout}) of new transaction is invalid.

export class ERR_NINJA_INVALID_UNLOCK extends CwiError {
    constructor(public vin: number, public txid: string, public vout: number, public signedRawTx: string, public e?: CwiError) 
}

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

Class: ERR_NINJA_MISSING_UNLOCK

Unlocking script for vin ${vin} of new transaction is invalid.

export class ERR_NINJA_MISSING_UNLOCK extends CwiError {
    constructor(vin: number) 
}

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

Class: Ninja

"Drop-in-replacement" for the original (v1) Ninja

export class Ninja extends NinjaBase {
    constructor(dojo: NinjaV1Params | DojoClientApi, clientPrivateKey?: string, authrite?: AuthriteClient) 
}

See also: NinjaBase, NinjaV1Params

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

Class: NinjaBase

export class NinjaBase implements NinjaApi {
    chain?: Chain;
    userId?: number;
    user?: DojoClientUserApi;
    keyDeriver?: sdk.KeyDeriverApi;
    _keyPair: KeyPairApi | undefined;
    _isDojoAuthenticated: boolean;
    dojoIdentity?: DojoIdentityApi;
    pendingSignActions: Record<string, PendingSignAction>;
    constructor(public dojo: DojoClientApi, clientPrivateKey?: string, public authrite?: AuthriteClient) 
    getClientChangeKeyPair(): KeyPairApi 
    async authenticate(identityKey?: string, addIfNew?: boolean): Promise<void> 
    isAuthenticated(): boolean 
    async verifyDojoAuthenticated() 
    async sync(): Promise<void> 
    async setSyncDojosByConfig(syncDojoConfigs: SyncDojoConfigBaseApi[], options?: DojoSyncOptionsApi | undefined): Promise<void> 
    async getSyncDojosByConfig(): Promise<{
        dojos: SyncDojoConfigBaseApi[];
        options?: DojoSyncOptionsApi | undefined;
    }> 
    async getPaymail(): Promise<string> 
    async setPaymail(paymail: string): Promise<void> 
    async getChain(): Promise<Chain> 
    async getNetwork(format?: "default" | "nonet"): Promise<string> 
    async findCertificates(certifiers?: string[] | object, types?: Record<string, string[]>): Promise<{
        status: "success";
        certificates: DojoCertificateApi[];
    }> 
    async saveCertificate(certificate: DojoCertificateApi | object): Promise<void> 
    async getTotalValue(basket?: string): Promise<{
        total: number;
    }> 
    async getTotalOfAmounts(options: DojoGetTotalOfAmountsOptions): Promise<{
        total: number;
    }> 
    async getNetOfAmounts(options?: DojoGetTotalOfAmountsOptions | undefined): Promise<number> 
    async getAvatar(): Promise<DojoAvatarApi> 
    async setAvatar(name: string, photoURL: string): Promise<void> 
    async updateTransactionStatus(params: {
        reference: string;
        status: DojoTransactionStatusApi;
    }): Promise<void> 
    async updateOutpointStatus(params: {
        txid: string;
        vout: number;
        spendable: boolean;
    }): Promise<void> 
    async getTransactions(options?: DojoGetTransactionsOptions): Promise<NinjaGetTransactionsResultApi> 
    async getPendingTransactions(referenceNumber?: string): Promise<DojoPendingTxApi[]> 
    async processPendingTransactions(onTransactionProcessed?: NinjaTransactionProcessedHandler, onTransactionFailed?: NinjaTransactionFailedHandler): Promise<void> 
    async getTransactionOutputs(options?: DojoGetTransactionOutputsOptions): Promise<NinjaGetTransactionOutputsResultApi[]> 
    async getTransactionLabels(options?: DojoGetTransactionLabelsOptions): Promise<{
        labels: DojoTxLabelApi[];
        total: number;
    }> 
    async getEnvelopeForTransaction(txid: string): Promise<EnvelopeApi | undefined> 
    async processTransaction(params: DojoProcessTransactionParams): Promise<DojoProcessTransactionResultApi> 
    async createAction(params: NinjaCreateActionParams): Promise<NinjaCreateActionResult> 
    async createActionSdk(vargs: sdk.ValidCreateActionArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.CreateActionResult> 
    async signActionSdk(vargs: sdk.ValidSignActionArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.SignActionResult> 
    async abortActionSdk(vargs: sdk.ValidAbortActionArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.AbortActionResult> 
    async internalizeActionSdk(vargs: sdk.ValidInternalizeActionArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.InternalizeActionResult> 
    async relinquishOutputSdk(vargs: sdk.ValidRelinquishOutputArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.RelinquishOutputResult> 
    async acquireCertificateSdk(vargs: sdk.AcquireCertificateArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.AcquireCertificateResult> 
    async listCertificatesSdk(vargs: sdk.ValidListCertificatesArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.ListCertificatesResult> 
    async listActions(vargs: sdk.ValidListActionsArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.ListActionsResult> 
    async listOutputs(vargs: sdk.ValidListOutputsArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.ListOutputsResult> 
    async getTransactionWithOutputs(params: NinjaGetTransactionWithOutputsParams): Promise<NinjaTransactionWithOutputsResultApi> 
    async createTransactionWithOutputs(params: NinjaGetTransactionWithOutputsParams): Promise<NinjaTransactionWithOutputsResultApi> 
    async processTransactionWithOutputs(params: NinjaGetTransactionWithOutputsParams): Promise<NinjaTransactionWithOutputsResultApi> 
    async signAction(params: NinjaSignActionParams): Promise<NinjaSignActionResultApi> 
    async abortAction(params: NinjaAbortActionParams): Promise<NinjaAbortActionResultApi> 
    async createTransaction(params: NinjaCreateTransactionParams): Promise<DojoCreateTransactionResultApi> 
    async deleteCertificate(partial: Partial<DojoCertificateApi>): Promise<number> 
    async labelTransaction(txid: string | number | Partial<DojoTransactionApi>, label: string): Promise<void> 
    async unlabelTransaction(txid: string | number | Partial<DojoTransactionApi>, label: string): Promise<void> 
    async tagOutput(output: {
        txid: string;
        vout: number;
    }, tag: string): Promise<void> 
    async untagOutput(output: {
        txid: string;
        vout: number;
    }, tag: string): Promise<void> 
    async unbasketOutput(output: {
        txid: string;
        vout: number;
    }): Promise<void> 
    async submitDirectTransaction(params: NinjaSubmitDirectTransactionParams): Promise<NinjaSubmitDirectTransactionResultApi> 
    async getEnvelopesOfConflictingTransactions(txid: string): Promise<EnvelopeApi[]> 
    async getHeight(): Promise<number> 
    async getMerkleRootForHeight(height: number): Promise<string | undefined> 
    async getHeaderForHeight(height: number): Promise<number[] | undefined> 
    async getInfo(params: GetInfoParams): Promise<GetInfoResult> 
}

See also: KeyPairApi, NinjaAbortActionParams, NinjaAbortActionResultApi, NinjaApi, NinjaCreateActionParams, NinjaCreateActionResult, NinjaCreateTransactionParams, NinjaGetTransactionOutputsResultApi, NinjaGetTransactionWithOutputsParams, NinjaGetTransactionsResultApi, NinjaSignActionParams, NinjaSignActionResultApi, NinjaSubmitDirectTransactionParams, NinjaSubmitDirectTransactionResultApi, NinjaTransactionFailedHandler, NinjaTransactionProcessedHandler, NinjaTransactionWithOutputsResultApi, PendingSignAction, abortAction, createActionSdk, createTransactionWithOutputs, getTransactionWithOutputs, internalizeActionSdk, processPendingTransactions, processTransactionWithOutputs, relinquishOutputSdk, signAction, signActionSdk, submitDirectTransaction

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

Class: NinjaV2

A ninja that also creates a default DojoClientExpress syncDojo configured to sync an existing user's state from a dojoURL parameter (either https://staging-dojo.babbage.systems or https://dojo.babbage.systems by default)

export class NinjaV2 extends NinjaBase {
    constructor(dojo: DojoClientApi, clientPrivateKey: string, chain: Chain) 
}

See also: NinjaBase

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

Functions

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

Function: abortAction

export async function abortAction(ninja: NinjaBase, params: NinjaAbortActionParams): Promise<NinjaAbortActionResultApi> 

See also: NinjaAbortActionParams, NinjaAbortActionResultApi, NinjaBase

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

Function: buildBsvTxFromCreateTransactionResult

Constructs a

export async function buildBsvTxFromCreateTransactionResult(ninjaInputs: Record<string, NinjaTxInputsApi>, createResult: DojoCreateTransactionResultApi, changeKeys: KeyPairApi): Promise<{
    tx: Transaction;
    outputMap: Record<string, number>;
    amount: number;
    log?: string;
}> 

See also: KeyPairApi, NinjaTxInputsApi

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

Function: completeSignedTransaction

export async function completeSignedTransaction(prior: PendingSignAction, spends: Record<number, sdk.SignActionSpend>, ninja: NinjaBase): Promise<Transaction> 

See also: NinjaBase, PendingSignAction

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

Function: convertToDojoTxInputsApi

Convert NinjaTxInputsApi to DojoTxInputsApi to protect unlocking scripts.

export function convertToDojoTxInputsApi(inputs: Record<string, NinjaTxInputsApi>): Record<string, DojoTxInputsApi> 

See also: NinjaTxInputsApi

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

Function: createActionSdk

export async function createActionSdk(ninja: NinjaBase, vargs: sdk.ValidCreateActionArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.CreateActionResult> 

See also: NinjaBase

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

Function: createTransactionWithOutputs

export async function createTransactionWithOutputs(ninja: NinjaBase, params: NinjaGetTransactionWithOutputsParams): Promise<NinjaTransactionWithOutputsResultApi> 

See also: NinjaBase, NinjaGetTransactionWithOutputsParams, NinjaTransactionWithOutputsResultApi

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

Function: getTransactionWithOutputs

export async function getTransactionWithOutputs(ninja: NinjaBase, params: NinjaGetTransactionWithOutputsParams): Promise<NinjaTransactionWithOutputsResultApi> 

See also: NinjaBase, NinjaGetTransactionWithOutputsParams, NinjaTransactionWithOutputsResultApi

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

Function: getUnlockingScriptLength

export function getUnlockingScriptLength(script: string | number): number 

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

Function: internalizeActionSdk

Internalize Action allows a wallet to take ownership of outputs in a pre-existing transaction. The transaction may, or may not already be known to both the storage and user.

Two types of outputs are handled: "wallet payments" and "basket insertions".

A "basket insertion" output is considered a custom output and has no effect on the wallet's "balance".

A "wallet payment" adds an outputs value to the wallet's change "balance". These outputs are assigned to the "default" basket.

Processing starts with simple validation and then checks for a pre-existing transaction. If the transaction is already known to the user, then the outputs are reviewed against the existing outputs treatment, and merge rules are added to the arguments passed to the storage layer. The existing transaction must be in the 'unproven' or 'completed' status. Any other status is an error.

When the transaction already exists, the description is updated. The isOutgoing sense is not changed.

"basket insertion" Merge Rules:

1. The "default" basket may not be specified as the insertion basket.
2. A change output in the "default" basket may not be target of an insertion into a different basket.
3. These baskets do not affect the wallet's balance and are typed "custom".

"wallet payment" Merge Rules:

1. Targetting an existing change "default" basket output results in a no-op. No error. No alterations made.
2. Targetting a previously "custom" non-change output converts it into a change output. This alters the transaction's amount, and the wallet balance.

export async function internalizeActionSdk(ninja: NinjaBase, vargs: sdk.ValidInternalizeActionArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.InternalizeActionResult> 

See also: NinjaBase

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

Function: invoice3241645161d8

Combine inputs per protocol 3241645161d8 to generate an 'invoice' string used for cryptographic key generation.

export function invoice3241645161d8(prefix: string, suffix: string, paymail?: string): string 

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

Function: makeAtomicBeef

export function makeAtomicBeef(tx: Transaction, beef: number[] | Beef): number[] 

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

Function: makeUnlockTestRawTxBabbageBsv

export async function makeUnlockTestRawTxBabbageBsv(params: {
    sourceTXID: string;
    sourceOutputIndex: number;
    lockingScript: string;
    satoshis: number;
    derivationPrefix: string;
    derivationSuffix: string;
    privateKey: string;
    publicKey: string;
}): Promise<string> 

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

Function: needsSignAction

export function needsSignAction(inputs: Record<string, NinjaTxInputsApi>) 

See also: NinjaTxInputsApi

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

Function: ninjaCreateAction

export async function ninjaCreateAction(ninja: NinjaBase, ninjaParams: NinjaCreateActionParams): Promise<NinjaCreateActionResult> 

See also: NinjaBase, NinjaCreateActionParams, NinjaCreateActionResult

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

Function: ninjaProcessTransaction

export async function ninjaProcessTransaction(ninja: NinjaBase, params: DojoProcessTransactionParams): Promise<DojoProcessTransactionResultApi> 

See also: NinjaBase

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

Function: processActionSdk

export async function processActionSdk(prior: PendingSignAction | undefined, ninja: NinjaBase, args: sdk.ValidProcessActionArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.SendWithResult[] | undefined> 

See also: NinjaBase, PendingSignAction

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

Function: processIncomingTransaction

Verifies protocol '3241645161d8' output scripts with derivedSuffix based addresses. Computes transaction 'amount'.

export async function processIncomingTransaction(ninja: NinjaBase, incomingTransaction: ProcessIncomingTransactionApi, protocol?: string, updateStatus?: boolean): Promise<ProcessIncomingTransactionResultApi> 

See also: NinjaBase, ProcessIncomingTransactionApi, ProcessIncomingTransactionResultApi

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

Function: processPendingTransactions

export async function processPendingTransactions(ninja: NinjaBase, onTransactionProcessed?: NinjaTransactionProcessedHandler, onTransactionFailed?: NinjaTransactionFailedHandler, onOutgoingTransaction?: NinjaOutgoingTransactionHandler): Promise<void> 

See also: NinjaBase, NinjaOutgoingTransactionHandler, NinjaTransactionFailedHandler, NinjaTransactionProcessedHandler

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

Function: processTransactionWithOutputs

export async function processTransactionWithOutputs(ninja: NinjaBase, params: NinjaGetTransactionWithOutputsParams): Promise<NinjaTransactionWithOutputsResultApi> 

See also: NinjaBase, NinjaGetTransactionWithOutputsParams, NinjaTransactionWithOutputsResultApi

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

Function: relinquishOutputSdk

export async function relinquishOutputSdk(ninja: NinjaBase, vargs: sdk.ValidRelinquishOutputArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.RelinquishOutputResult> 

See also: NinjaBase

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

Function: signAction

export async function signAction(ninja: NinjaBase, params: NinjaSignActionParams): Promise<NinjaSignActionResultApi> 

See also: NinjaBase, NinjaSignActionParams, NinjaSignActionResultApi

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

Function: signActionSdk

export async function signActionSdk(ninja: NinjaBase, vargs: sdk.ValidSignActionArgs, originator?: sdk.OriginatorDomainNameStringUnder250Bytes): Promise<sdk.SignActionResult> 

See also: NinjaBase

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

Function: signCreatedTransaction

export async function signCreatedTransaction(ninja: NinjaBase, params: NinjaSignCreatedTransactionParams): Promise<NinjaTransactionWithOutputsResultApi> 

See also: NinjaBase, NinjaSignCreatedTransactionParams, NinjaTransactionWithOutputsResultApi

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

Function: submitDirectTransaction

export async function submitDirectTransaction(ninja: NinjaBase, params: NinjaSubmitDirectTransactionParams): Promise<NinjaSubmitDirectTransactionResultApi> 

See also: NinjaBase, NinjaSubmitDirectTransactionParams, NinjaSubmitDirectTransactionResultApi

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

Function: unpackFromCreateTransactionResult

export function unpackFromCreateTransactionResult(ninjaInputs: Record<string, NinjaTxInputsApi>, createResult: DojoCreateTransactionResultApi): {
    amount: number;
    referenceNumber: string;
    inputs: Record<string, OptionalEnvelopeEvidenceApi>;
} 

See also: NinjaTxInputsApi

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

Function: validateDefaultParams

export function validateDefaultParams(params: NinjaGetTransactionWithOutputsParams, logLabel?: string) 

See also: NinjaGetTransactionWithOutputsParams

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

Types

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

Type: NinjaOutgoingTransactionHandler

export type NinjaOutgoingTransactionHandler = (tx: DojoPendingTxApi) => Promise<boolean>

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

Type: NinjaTransactionFailedHandler

export type NinjaTransactionFailedHandler = (args: NinjaTransactionFailedApi) => Promise<void>

See also: NinjaTransactionFailedApi

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

Type: NinjaTransactionProcessedHandler

export type NinjaTransactionProcessedHandler = (args: NinjaTransactionProcessedApi) => Promise<void>

See also: NinjaTransactionProcessedApi

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

Variables

Variable: invoice3241645161d8Protocol

invoice3241645161d8Protocol = "2-3241645161d8"

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

License

The license for the code in this repository is the Open BSV License.