lotus-sdk/dist/lib/bitcore/transaction/input.d.ts

Central repository for several classes of tools for integrating with, and building for, the Lotusia ecosystem

import { BufferWriter } from '../encoding/bufferwriter.js';
import { BufferReader } from '../encoding/bufferreader.js';
import { Script } from '../script.js';
import { BN } from '../crypto/bn.js';
import { Output } from './output.js';
import { PrivateKey } from '../privatekey.js';
import { PublicKey } from '../publickey.js';
import { SignatureSigningMethod } from '../crypto/signature.js';
import { TransactionSignature } from './signature.js';
import { Transaction } from './transaction.js';
import type { MuSigKeyAggContext, MuSigAggregatedNonce } from '../crypto/musig2.js';
import { Point } from '../crypto/point.js';
export interface InputData {
    prevTxId?: Buffer | string;
    outputIndex?: number;
    sequenceNumber?: number;
    script?: Script | Buffer | string;
    scriptBuffer?: Buffer;
    output?: Output;
}
export interface InputObject {
    prevTxId?: Buffer | string;
    outputIndex?: number;
    sequenceNumber?: number;
    script?: Script | Buffer | string;
    scriptBuffer?: Buffer;
    scriptString?: string;
    output?: Output;
}
export declare class Input {
    static readonly MAXINT = 4294967295;
    static readonly DEFAULT_SEQNUMBER = 4294967295;
    static readonly DEFAULT_LOCKTIME_SEQNUMBER = 4294967294;
    static readonly DEFAULT_RBF_SEQNUMBER = 4294967293;
    static readonly SEQUENCE_LOCKTIME_TYPE_FLAG = 4194304;
    static readonly SEQUENCE_LOCKTIME_DISABLE_FLAG = 2147483648;
    static readonly SEQUENCE_LOCKTIME_MASK = 65535;
    static readonly SEQUENCE_LOCKTIME_GRANULARITY = 512;
    static readonly SEQUENCE_BLOCKDIFF_LIMIT = 65535;
    static PublicKey: typeof PublicKeyInput;
    static PublicKeyHash: typeof PublicKeyHashInput;
    static Multisig: typeof MultisigInput;
    static MultisigScriptHash: typeof MultisigScriptHashInput;
    static Taproot: typeof TaprootInput;
    static MuSigTaproot: typeof MuSigTaprootInput;
    static P2PKH: typeof PublicKeyHashInput;
    static P2SH: typeof MultisigScriptHashInput;
    static P2TR: typeof TaprootInput;
    prevTxId: Buffer;
    outputIndex: number;
    sequenceNumber: number;
    private _scriptBuffer;
    private _script?;
    output?: Output;
    constructor(params?: InputData);
    static create(params?: InputData): Input;
    static fromObject(obj: InputData): Input;
    private _fromObject;
    get script(): Script | null;
    get scriptBuffer(): Buffer;
    setScript(script: Script | Buffer | string | null): Input;
    isNull(): boolean;
    isFinal(): boolean;
    hasSequence(): boolean;
    hasRelativeLockTime(): boolean;
    getRelativeLockTime(): bigint;
    isRelativeLockTimeInBlocks(): boolean;
    getRelativeLockTimeInBlocks(): number;
    getRelativeLockTimeInSeconds(): number;
    toObject(): InputObject;
    toJSON: () => InputObject;
    static fromBufferReader(br: BufferReader): Input;
    toBuffer(): Buffer;
    toBufferWriter(writer?: BufferWriter): BufferWriter;
    getSize(): number;
    isValid(): boolean;
    clone(): Input;
    getSignatures(transaction: Transaction, privateKey: PrivateKey, index: number, sigtype?: number, hashData?: unknown, signingMethod?: string): TransactionSignature[];
    isFullySigned(): boolean;
    addSignature(transaction: Transaction, signature: TransactionSignature, signingMethod?: SignatureSigningMethod): this;
    clearSignatures(): this;
    isValidSignature(transaction: Transaction, signature: TransactionSignature, signingMethod?: string): boolean;
    lockForSeconds(seconds: number): Input;
    lockUntilBlockHeight(heightDiff: number): Input;
    getLockTime(): Date | number | null;
    _estimateSize(): number;
    toString(): string;
}
export declare class MultisigInput extends Input {
    static readonly OPCODES_SIZE = 1;
    static readonly SIGNATURE_SIZE = 73;
    publicKeys: PublicKey[];
    threshold: number;
    signatures: (TransactionSignature | undefined)[];
    publicKeyIndex: {
        [key: string]: number;
    };
    constructor(input: Input, pubkeys?: PublicKey[], threshold?: number, signatures?: TransactionSignature[], opts?: {
        noSorting?: boolean;
    });
    toObject(): object;
    _deserializeSignatures(signatures: TransactionSignature[]): (TransactionSignature | undefined)[];
    _serializeSignatures(): (object | undefined)[];
    getSignatures(transaction: Transaction, privateKey: PrivateKey, index: number, sigtype?: number, hashData?: unknown, signingMethod?: string): TransactionSignature[];
    addSignature(transaction: Transaction, signature: TransactionSignature, signingMethod?: string): this;
    _updateScript(signingMethod?: string): this;
    _createSignatures(signingMethod?: string): Buffer[];
    clearSignatures(): this;
    isFullySigned(): boolean;
    countMissingSignatures(): number;
    countSignatures(): number;
    publicKeysWithoutSignature(): PublicKey[];
    isValidSignature(transaction: Transaction, signature: TransactionSignature, signingMethod?: string): boolean;
    normalizeSignatures(transaction: Transaction, input: Input, inputIndex: number, signatures: Buffer[], publicKeys: PublicKey[], signingMethod?: string): TransactionSignature[];
    _estimateSize(): number;
}
export declare class MultisigScriptHashInput extends Input {
    static readonly OPCODES_SIZE = 7;
    static readonly SIGNATURE_SIZE = 74;
    static readonly PUBKEY_SIZE = 34;
    publicKeys: PublicKey[];
    threshold: number;
    signatures: (TransactionSignature | undefined)[];
    redeemScript: Script;
    publicKeyIndex: {
        [key: string]: number;
    };
    checkBitsField: Uint8Array;
    constructor(input: Input, pubkeys?: PublicKey[], threshold?: number, signatures?: TransactionSignature[], opts?: {
        noSorting?: boolean;
    });
    toObject(): object;
    _deserializeSignatures(signatures: TransactionSignature[]): (TransactionSignature | undefined)[];
    _serializeSignatures(): (object | undefined)[];
    getSignatures(transaction: Transaction, privateKey: PrivateKey, index: number, sigtype?: number, hashData?: unknown, signingMethod?: string): TransactionSignature[];
    addSignature(transaction: Transaction, signature: TransactionSignature, signingMethod?: string): this;
    _updateScript(signingMethod?: string, checkBitsField?: Uint8Array): this;
    _createSignatures(signingMethod?: string): Buffer[];
    clearSignatures(): this;
    isFullySigned(): boolean;
    countMissingSignatures(): number;
    countSignatures(): number;
    publicKeysWithoutSignature(): PublicKey[];
    isValidSignature(transaction: Transaction, signature: TransactionSignature, signingMethod?: string): boolean;
    normalizeSignatures(transaction: Transaction, input: Input, inputIndex: number, signatures: Buffer[], publicKeys: PublicKey[], signingMethod?: string): TransactionSignature[];
    _estimateSize(): number;
}
export declare class PublicKeyInput extends Input {
    static readonly SCRIPT_MAX_SIZE = 73;
    getSignatures(transaction: Transaction, privateKey: PrivateKey, index: number, sigtype?: number, hashData?: unknown, signingMethod?: string): TransactionSignature[];
    addSignature(transaction: Transaction, signature: TransactionSignature, signingMethod?: SignatureSigningMethod): this;
    clearSignatures(): this;
    isFullySigned(): boolean;
    _estimateSize(): number;
}
export declare class PublicKeyHashInput extends Input {
    static readonly SCRIPT_MAX_SIZE: number;
    getSignatures(transaction: Transaction, privateKey: PrivateKey, index: number, sigtype?: number, hashData?: unknown, signingMethod?: string): TransactionSignature[];
    addSignature(transaction: Transaction, signature: TransactionSignature, signingMethod?: SignatureSigningMethod): this;
    clearSignatures(): this;
    isFullySigned(): boolean;
    _estimateSize(): number;
}
export interface TaprootInputData extends InputData {
    internalPubKey?: PublicKey;
    merkleRoot?: Buffer;
    controlBlock?: Buffer;
    tapScript?: Script;
}
export declare class TaprootInput extends Input {
    internalPubKey?: PublicKey;
    merkleRoot?: Buffer;
    controlBlock?: Buffer;
    tapScript?: Script;
    constructor(params?: TaprootInputData);
    getSignatures(transaction: Transaction, privateKey: PrivateKey, index: number, sigtype?: number, hashData?: unknown, signingMethod?: string): TransactionSignature[];
    addSignature(transaction: Transaction, signature: TransactionSignature, signingMethod?: string): this;
    isValidSignature(transaction: Transaction, signature: TransactionSignature, signingMethod?: string): boolean;
    clearSignatures(): this;
    isFullySigned(): boolean;
    _estimateSize(): number;
}
export declare class MuSigTaprootInput extends TaprootInput {
    keyAggContext?: MuSigKeyAggContext;
    publicNonces?: Map<number, [Point, Point]>;
    aggregatedNonce?: MuSigAggregatedNonce;
    partialSignatures?: Map<number, BN>;
    mySignerIndex?: number;
    constructor(params?: TaprootInputData & {
        keyAggContext?: MuSigKeyAggContext;
        mySignerIndex?: number;
    });
    initMuSigSession(keyAggContext: MuSigKeyAggContext, mySignerIndex: number): this;
    addPublicNonce(signerIndex: number, publicNonce: [Point, Point]): this;
    hasAllNonces(): boolean;
    aggregateNonces(): this;
    addPartialSignature(signerIndex: number, partialSig: BN): this;
    hasAllPartialSignatures(): boolean;
    finalizeMuSigSignature(transaction: Transaction, message: Buffer): this;
    isFullySigned(): boolean;
}
//# sourceMappingURL=input.d.ts.map