wallet-storage-client/out/src/storage/schema/entities/ProvenTx.d.ts

Client only Wallet Storage

import { MerklePath } from "@bsv/sdk";
import { entity, sdk, table } from "../../../index.client";
import { EntityBase } from ".";
export declare class ProvenTx extends EntityBase<table.ProvenTx> {
    /**
     * Given a txid and optionally its rawTx, create a new ProvenTx object.
     *
     * rawTx is fetched if not provided.
     *
     * Only succeeds (proven is not undefined) if a proof is confirmed for rawTx,
     * and hash of rawTx is confirmed to match txid
     *
     * The returned ProvenTx and ProvenTxReq objects have not been added to the storage database,
     * this is optional and can be done by the caller if appropriate.
     *
     * @param txid
     * @param services
     * @param rawTx
     * @returns
     */
    static fromTxid(txid: string, services: sdk.WalletServices, rawTx?: number[]): Promise<ProvenTxFromTxidResult>;
    constructor(api?: table.ProvenTx);
    updateApi(): void;
    /**
     * @returns desirialized `MerklePath` object, value is cached.
     */
    getMerklePath(): MerklePath;
    _mp?: MerklePath;
    get provenTxId(): number;
    set provenTxId(v: number);
    get created_at(): Date;
    set created_at(v: Date);
    get updated_at(): Date;
    set updated_at(v: Date);
    get txid(): string;
    set txid(v: string);
    get height(): number;
    set height(v: number);
    get index(): number;
    set index(v: number);
    get merklePath(): number[];
    set merklePath(v: number[]);
    get rawTx(): number[];
    set rawTx(v: number[]);
    get blockHash(): string;
    set blockHash(v: string);
    get merkleRoot(): string;
    set merkleRoot(v: string);
    get id(): number;
    set id(v: number);
    get entityName(): string;
    get entityTable(): string;
    equals(ei: table.ProvenTx, syncMap?: entity.SyncMap | undefined): boolean;
    static mergeFind(storage: entity.EntityStorage, userId: number, ei: table.ProvenTx, syncMap: entity.SyncMap, trx?: sdk.TrxToken): Promise<{
        found: boolean;
        eo: entity.ProvenTx;
        eiId: number;
    }>;
    mergeNew(storage: entity.EntityStorage, userId: number, syncMap: entity.SyncMap, trx?: sdk.TrxToken): Promise<void>;
    mergeExisting(storage: entity.EntityStorage, since: Date | undefined, ei: table.ProvenTx, syncMap: entity.SyncMap, trx?: sdk.TrxToken): Promise<boolean>;
    /**
     * How high attempts can go before status is forced to invalid
     */
    static getProofAttemptsLimit: number;
    /**
     * How many hours we have to try for a poof
     */
    static getProofMinutes: number;
    /**
     * Try to create a new ProvenTx from a ProvenTxReq and GetMerkleProofResultApi
     *
     * Otherwise it returns undefined and updates req.status to either 'unknown', 'invalid', or 'unconfirmed'
     *
     * @param req
     * @param gmpResult
     * @returns
     */
    static fromReq(req: entity.ProvenTxReq, gmpResult: sdk.GetMerklePathResult, countsAsAttempt: boolean): Promise<ProvenTx | undefined>;
}
export interface ProvenTxFromTxidResult {
    proven?: entity.ProvenTx;
    rawTx?: number[];
}
//# sourceMappingURL=ProvenTx.d.ts.map