@1sat/wallet-toolbox 0.0.8 → 0.0.10

package/dist/cwi/types.d.ts

@@ -0,0 +1,39 @@
+/**
+ * CWI (Chrome Wallet Interface) - Shared types for BRC-100 WalletInterface implementations
+ */
+export declare enum CWIEventName {
+    LIST_OUTPUTS = "cwi_listOutputs",
+    LIST_ACTIONS = "cwi_listActions",
+    GET_PUBLIC_KEY = "cwi_getPublicKey",
+    GET_HEIGHT = "cwi_getHeight",
+    GET_HEADER_FOR_HEIGHT = "cwi_getHeaderForHeight",
+    GET_NETWORK = "cwi_getNetwork",
+    GET_VERSION = "cwi_getVersion",
+    IS_AUTHENTICATED = "cwi_isAuthenticated",
+    WAIT_FOR_AUTHENTICATION = "cwi_waitForAuthentication",
+    CREATE_ACTION = "cwi_createAction",
+    SIGN_ACTION = "cwi_signAction",
+    ABORT_ACTION = "cwi_abortAction",
+    INTERNALIZE_ACTION = "cwi_internalizeAction",
+    CREATE_SIGNATURE = "cwi_createSignature",
+    VERIFY_SIGNATURE = "cwi_verifySignature",
+    ENCRYPT = "cwi_encrypt",
+    DECRYPT = "cwi_decrypt",
+    CREATE_HMAC = "cwi_createHmac",
+    VERIFY_HMAC = "cwi_verifyHmac",
+    RELINQUISH_OUTPUT = "cwi_relinquishOutput",
+    ACQUIRE_CERTIFICATE = "cwi_acquireCertificate",
+    LIST_CERTIFICATES = "cwi_listCertificates",
+    PROVE_CERTIFICATE = "cwi_proveCertificate",
+    RELINQUISH_CERTIFICATE = "cwi_relinquishCertificate",
+    DISCOVER_BY_IDENTITY_KEY = "cwi_discoverByIdentityKey",
+    DISCOVER_BY_ATTRIBUTES = "cwi_discoverByAttributes",
+    REVEAL_COUNTERPARTY_KEY_LINKAGE = "cwi_revealCounterpartyKeyLinkage",
+    REVEAL_SPECIFIC_KEY_LINKAGE = "cwi_revealSpecificKeyLinkage"
+}
+export interface CWIResponseDetail<T = unknown> {
+    type: CWIEventName;
+    success: boolean;
+    data?: T;
+    error?: string;
+}

package/dist/cwi/types.js

@@ -0,0 +1,39 @@
+/**
+ * CWI (Chrome Wallet Interface) - Shared types for BRC-100 WalletInterface implementations
+ */
+// BRC-100 Event Names - shared between all CWI implementations
+export var CWIEventName;
+(function (CWIEventName) {
+    // Read-only operations
+    CWIEventName["LIST_OUTPUTS"] = "cwi_listOutputs";
+    CWIEventName["LIST_ACTIONS"] = "cwi_listActions";
+    CWIEventName["GET_PUBLIC_KEY"] = "cwi_getPublicKey";
+    CWIEventName["GET_HEIGHT"] = "cwi_getHeight";
+    CWIEventName["GET_HEADER_FOR_HEIGHT"] = "cwi_getHeaderForHeight";
+    CWIEventName["GET_NETWORK"] = "cwi_getNetwork";
+    CWIEventName["GET_VERSION"] = "cwi_getVersion";
+    CWIEventName["IS_AUTHENTICATED"] = "cwi_isAuthenticated";
+    CWIEventName["WAIT_FOR_AUTHENTICATION"] = "cwi_waitForAuthentication";
+    // Signing operations (require password)
+    CWIEventName["CREATE_ACTION"] = "cwi_createAction";
+    CWIEventName["SIGN_ACTION"] = "cwi_signAction";
+    CWIEventName["ABORT_ACTION"] = "cwi_abortAction";
+    CWIEventName["INTERNALIZE_ACTION"] = "cwi_internalizeAction";
+    CWIEventName["CREATE_SIGNATURE"] = "cwi_createSignature";
+    CWIEventName["VERIFY_SIGNATURE"] = "cwi_verifySignature";
+    CWIEventName["ENCRYPT"] = "cwi_encrypt";
+    CWIEventName["DECRYPT"] = "cwi_decrypt";
+    CWIEventName["CREATE_HMAC"] = "cwi_createHmac";
+    CWIEventName["VERIFY_HMAC"] = "cwi_verifyHmac";
+    CWIEventName["RELINQUISH_OUTPUT"] = "cwi_relinquishOutput";
+    // Certificate operations
+    CWIEventName["ACQUIRE_CERTIFICATE"] = "cwi_acquireCertificate";
+    CWIEventName["LIST_CERTIFICATES"] = "cwi_listCertificates";
+    CWIEventName["PROVE_CERTIFICATE"] = "cwi_proveCertificate";
+    CWIEventName["RELINQUISH_CERTIFICATE"] = "cwi_relinquishCertificate";
+    CWIEventName["DISCOVER_BY_IDENTITY_KEY"] = "cwi_discoverByIdentityKey";
+    CWIEventName["DISCOVER_BY_ATTRIBUTES"] = "cwi_discoverByAttributes";
+    // Key linkage
+    CWIEventName["REVEAL_COUNTERPARTY_KEY_LINKAGE"] = "cwi_revealCounterpartyKeyLinkage";
+    CWIEventName["REVEAL_SPECIFIC_KEY_LINKAGE"] = "cwi_revealSpecificKeyLinkage";
+})(CWIEventName || (CWIEventName = {}));

package/dist/index.d.ts

@@ -1,7 +1,9 @@
-export { OneSatWallet, type OneSatWalletArgs, type OneSatWalletEvents, type IngestResult, } from "./OneSatWallet";
+export * from "./api";
 export { OneSatServices, type SyncOutput } from "./services/OneSatServices";
 export type { OrdfsMetadata, OrdfsContentOptions, OrdfsContentResponse, OrdfsResponseHeaders, Capability, } from "./services/types";
 export * from "./services/client";
 export { ReadOnlySigner } from "./signers/ReadOnlySigner";
 export * from "./indexers";
 export * from "./sync";
+export * from "./cwi";
+export * from "./wallet";

package/dist/index.js

@@ -3,7 +3,9 @@ import { Buffer } from "buffer";
 if (typeof globalThis.Buffer === "undefined") {
     globalThis.Buffer = Buffer;
 }
-export { OneSatWallet, } from "./OneSatWallet";
+// API Layer - The new unified API for 1sat ecosystem
+export * from "./api";
+// Services
 export { OneSatServices } from "./services/OneSatServices";
 export * from "./services/client";
 export { ReadOnlySigner } from "./signers/ReadOnlySigner";
@@ -11,3 +13,7 @@ export { ReadOnlySigner } from "./signers/ReadOnlySigner";
 export * from "./indexers";
 // Sync Queue
 export * from "./sync";
+// CWI (Chrome Wallet Interface) - BRC-100 implementations
+export * from "./cwi";
+// Wallet factory for creating 1Sat web wallets
+export * from "./wallet";

package/dist/indexers/CosignIndexer.js

@@ -20,6 +20,7 @@ export class CosignIndexer extends Indexer {
             data: decoded,
             tags: [],
             owner: decoded.address,
+            protocol: "basket insertion", // Cosign script requires cosigner signature
         };
     }
 }

package/dist/indexers/InscriptionIndexer.js

@@ -35,11 +35,10 @@ export class InscriptionIndexer extends Indexer {
         let owner = parseAddress(script, 0, this.network);
         if (!owner && decoded.scriptSuffix) {
             // Try to find owner in suffix (after OP_ENDIF)
-            const suffixScript = Script.fromBinary(Array.from(decoded.scriptSuffix));
-            owner = parseAddress(suffixScript, 0, this.network);
+            owner = parseAddress(decoded.scriptSuffix, 0, this.network);
             // Also check for OP_CODESEPARATOR pattern
-            if (!owner && suffixScript.chunks[0]?.op === OP.OP_CODESEPARATOR) {
-                owner = parseAddress(suffixScript, 1, this.network);
+            if (!owner && decoded.scriptSuffix.chunks[0]?.op === OP.OP_CODESEPARATOR) {
+                owner = parseAddress(decoded.scriptSuffix, 1, this.network);
             }
         }
         // Handle MAP field if present (special case)

package/dist/indexers/LockIndexer.js

@@ -17,6 +17,7 @@ export class LockIndexer extends Indexer {
             tags,
             owner: decoded.address,
             basket: "lock",
+            protocol: "basket insertion", // Custom Lock script requires manual unlock
         };
     }
     async summarize(ctx) {

package/dist/indexers/OrdLockIndexer.js

@@ -28,6 +28,7 @@ export class OrdLockIndexer extends Indexer {
             data: listing,
             tags: [`list:${listing.price}`],
             owner: decoded.seller,
+            protocol: "basket insertion", // OrdLock script requires manual unlock
         };
     }
     async summarize(ctx) {

package/dist/indexers/OriginIndexer.js

@@ -47,7 +47,7 @@ export class OriginIndexer extends Indexer {
         return {
             data: origin,
             tags: [], // Tags will be added in summarize() once origin is determined
-            owner: address && this.owners.has(address) ? address : undefined,
+            owner: address,
             basket: "1sat",
         };
     }

package/dist/indexers/index.d.ts

@@ -1,4 +1,4 @@
-export { Indexer, type IndexData, type IndexSummary, type ParseContext, type ParseResult, type Txo, } from "./types";
+export { Indexer, type IndexData, type IndexSummary, type InternalizeProtocol, type ParseContext, type ParseResult, type Txo, } from "./types";
 export type { Bsv21TokenData, Bsv21OutputData, Bsv21TransactionData, } from "./types";
 export { Outpoint } from "./Outpoint";
 export { parseAddress } from "./parseAddress";

package/dist/indexers/types.d.ts

@@ -54,6 +54,12 @@ export interface IndexSummary {
     icon?: string;
     data?: unknown;
 }
+/**
+ * Internalization protocol for synced outputs.
+ * - "wallet payment": P2PKH-based outputs that can be auto-signed
+ * - "basket insertion": Custom script outputs requiring manual unlock scripts
+ */
+export type InternalizeProtocol = "wallet payment" | "basket insertion";
 /**
  * Result from Indexer.parse() method
  */
@@ -64,6 +70,12 @@ export interface ParseResult {
     basket?: string;
     /** Optional text content (e.g., from text inscriptions). Truncated to 1000 chars when stored. */
     content?: string;
+    /**
+     * Internalization protocol for this output.
+     * - "wallet payment": P2PKH outputs that can be auto-signed (default)
+     * - "basket insertion": Custom script outputs requiring manual unlock
+     */
+    protocol?: InternalizeProtocol;
 }
 /**
  * Transaction output structure used during parsing
@@ -73,6 +85,12 @@ export interface Txo {
     outpoint: Outpoint;
     owner?: string;
     basket?: string;
+    /**
+     * Internalization protocol for this output.
+     * Set by the first indexer to claim ownership.
+     * Defaults to "wallet payment" if not set.
+     */
+    protocol?: InternalizeProtocol;
     data: {
         [tag: string]: IndexData;
     };

package/dist/services/OneSatServices.d.ts

@@ -1,5 +1,5 @@
 import { Beef, Transaction } from "@bsv/sdk";
-import type { TableOutput, WalletStorageManager, sdk as toolboxSdk } from "@bsv/wallet-toolbox";
+import { type TableOutput, type sdk as toolboxSdk } from "@bsv/wallet-toolbox";
 type Chain = toolboxSdk.Chain;
 type BlockHeader = toolboxSdk.BlockHeader;
 type GetMerklePathResult = toolboxSdk.GetMerklePathResult;
@@ -32,7 +32,6 @@ export type { SyncOutput };
 export declare class OneSatServices implements WalletServices {
     chain: Chain;
     readonly baseUrl: string;
-    private storage?;
     readonly chaintracks: ChaintracksClient;
     readonly beef: BeefClient;
     readonly arcade: ArcadeClient;
@@ -40,7 +39,13 @@ export declare class OneSatServices implements WalletServices {
     readonly owner: OwnerClient;
     readonly ordfs: OrdfsClient;
     readonly bsv21: Bsv21Client;
-    constructor(chain: Chain, baseUrl?: string, storage?: WalletStorageManager);
+    private fallbackServices?;
+    /**
+     * URL for wallet storage sync endpoint (BRC-100 JSON-RPC).
+     * Used by StorageClient for remote wallet backup/sync.
+     */
+    get storageUrl(): string;
+    constructor(chain: Chain, baseUrl?: string, fallbackServices?: WalletServices);
     /**
      * Get list of enabled capabilities from the server
      */
@@ -59,11 +64,15 @@ export declare class OneSatServices implements WalletServices {
     hashOutputScript(script: string): string;
     getServicesCallHistory(_reset?: boolean): ServicesCallHistory;
     getBsvExchangeRate(): Promise<number>;
-    getFiatExchangeRate(_currency: "USD" | "GBP" | "EUR", _base?: "USD" | "GBP" | "EUR"): Promise<number>;
-    getStatusForTxids(_txids: string[], _useNext?: boolean): Promise<GetStatusForTxidsResult>;
-    isUtxo(_output: TableOutput): Promise<boolean>;
-    getUtxoStatus(_output: string, _outputFormat?: GetUtxoStatusOutputFormat, _outpoint?: string, _useNext?: boolean): Promise<GetUtxoStatusResult>;
-    getScriptHashHistory(_hash: string, _useNext?: boolean): Promise<GetScriptHashHistoryResult>;
-    hashToHeader(_hash: string): Promise<BlockHeader>;
-    nLockTimeIsFinal(_txOrLockTime: string | number[] | Transaction | number): Promise<boolean>;
+    getFiatExchangeRate(currency: "USD" | "GBP" | "EUR", base?: "USD" | "GBP" | "EUR"): Promise<number>;
+    getStatusForTxids(txids: string[], _useNext?: boolean): Promise<GetStatusForTxidsResult>;
+    /**
+     * Helper to get tx status from Beef storage (fallback when Arcade doesn't know the tx)
+     */
+    private getStatusFromBeef;
+    isUtxo(output: TableOutput): Promise<boolean>;
+    getUtxoStatus(_output: string, _outputFormat?: GetUtxoStatusOutputFormat, outpoint?: string, _useNext?: boolean): Promise<GetUtxoStatusResult>;
+    getScriptHashHistory(hash: string, useNext?: boolean): Promise<GetScriptHashHistoryResult>;
+    hashToHeader(hash: string): Promise<BlockHeader>;
+    nLockTimeIsFinal(txOrLockTime: string | number[] | Transaction | number): Promise<boolean>;
 }

package/dist/services/OneSatServices.js

@@ -32,7 +32,6 @@ import { ArcadeClient, BeefClient, Bsv21Client, ChaintracksClient, OrdfsClient,
 export class OneSatServices {
     chain;
     baseUrl;
-    storage;
     // ===== API Clients =====
     chaintracks;
     beef;
@@ -41,14 +40,23 @@ export class OneSatServices {
     owner;
     ordfs;
     bsv21;
-    constructor(chain, baseUrl, storage) {
+    // Optional fallback to wallet-toolbox Services for methods we don't implement
+    fallbackServices;
+    /**
+     * URL for wallet storage sync endpoint (BRC-100 JSON-RPC).
+     * Used by StorageClient for remote wallet backup/sync.
+     */
+    get storageUrl() {
+        return `${this.baseUrl}/1sat/wallet`;
+    }
+    constructor(chain, baseUrl, fallbackServices) {
+        this.fallbackServices = fallbackServices;
         this.chain = chain;
         this.baseUrl =
             baseUrl ||
                 (chain === "main"
                     ? "https://1sat.shruggr.cloud"
                     : "https://testnet.api.1sat.app");
-        this.storage = storage;
         const opts = { timeout: 30000 };
         this.chaintracks = new ChaintracksClient(this.baseUrl, opts);
         this.beef = new BeefClient(this.baseUrl, opts);
@@ -101,12 +109,25 @@ export class OneSatServices {
         return this.chaintracks.currentHeight();
     }
     async getMerklePath(txid, _useNext) {
+        console.log("[OneSatServices] getMerklePath called for txid:", txid);
         try {
             const proofBytes = await this.beef.getProof(txid);
-            const merklePath = MerklePath.fromBinary(Array.from(proofBytes));
-            return { name: "1sat-api", merklePath };
+            const merklePath = MerklePath.fromBinary([...proofBytes]);
+            console.log("[OneSatServices] getMerklePath got proof, blockHeight:", merklePath.blockHeight);
+            // Fetch the block header for this merkle path
+            const header = await this.chaintracks.findHeaderForHeight(merklePath.blockHeight);
+            if (!header) {
+                console.log("[OneSatServices] getMerklePath header not found for height:", merklePath.blockHeight);
+                return {
+                    name: "1sat-api",
+                    error: new ServiceError("HEADER_NOT_FOUND", `Block header not found for height ${merklePath.blockHeight}`),
+                };
+            }
+            console.log("[OneSatServices] getMerklePath success, returning merklePath and header");
+            return { name: "1sat-api", merklePath, header };
         }
         catch (error) {
+            console.error("[OneSatServices] getMerklePath error:", error);
             return {
                 name: "1sat-api",
                 error: new ServiceError("NETWORK_ERROR", error instanceof Error ? error.message : "Unknown error"),
@@ -114,27 +135,19 @@ export class OneSatServices {
         }
     }
     async postBeef(beef, txids) {
+        console.log("[OneSatServices] postBeef called with txids:", txids);
         const results = [];
         for (const txid of txids) {
             try {
-                const beefTx = beef.findTxid(txid);
-                if (!beefTx?.tx) {
-                    results.push({
-                        name: "1sat-api",
-                        status: "error",
-                        error: new ServiceError("TX_NOT_FOUND", `Transaction ${txid} not found in BEEF`),
-                        txidResults: [
-                            {
-                                txid,
-                                status: "error",
-                                data: { detail: "Transaction not found in BEEF" },
-                            },
-                        ],
-                    });
-                    continue;
-                }
-                // Use Extended Format (EF) which includes source transaction data
-                const status = await this.arcade.submitTransaction(beefTx.tx.toEF());
+                // Submit as AtomicBEEF which includes all source transactions
+                console.log("[OneSatServices] Submitting tx to arcade:", txid);
+                const atomicBeef = beef.toBinaryAtomic(txid);
+                // TODO: Remove hardcoded callback headers after server testing
+                const status = await this.arcade.submitTransaction(atomicBeef, {
+                    callbackUrl: `${this.baseUrl}/1sat/arc/callback`,
+                    callbackToken: "test-callback-token",
+                });
+                console.log("[OneSatServices] Arcade response:", status);
                 if (status.txStatus === "MINED" ||
                     status.txStatus === "SEEN_ON_NETWORK" ||
                     status.txStatus === "ACCEPTED_BY_NETWORK") {
@@ -163,6 +176,7 @@ export class OneSatServices {
                 }
             }
             catch (error) {
+                console.error("[OneSatServices] postBeef error:", error);
                 results.push({
                     name: "1sat-api",
                     status: "error",
@@ -203,29 +217,177 @@ export class OneSatServices {
             },
         };
     }
-    // ===== WalletServices Interface (Not Yet Implemented) =====
+    // ===== WalletServices Interface (Delegated to fallback) =====
     async getBsvExchangeRate() {
-        throw new Error("getBsvExchangeRate not yet implemented");
+        if (!this.fallbackServices) {
+            throw new Error("getBsvExchangeRate not implemented");
+        }
+        return this.fallbackServices.getBsvExchangeRate();
     }
-    async getFiatExchangeRate(_currency, _base) {
-        throw new Error("getFiatExchangeRate not yet implemented");
+    async getFiatExchangeRate(currency, base) {
+        if (!this.fallbackServices) {
+            throw new Error("getFiatExchangeRate not implemented");
+        }
+        return this.fallbackServices.getFiatExchangeRate(currency, base);
     }
-    async getStatusForTxids(_txids, _useNext) {
-        throw new Error("getStatusForTxids not yet implemented");
+    async getStatusForTxids(txids, _useNext) {
+        const results = [];
+        let currentHeight;
+        for (const txid of txids) {
+            try {
+                // Try Arcade first (only knows about txs broadcast through it)
+                const status = await this.arcade.getStatus(txid);
+                if (status.txStatus === "MINED" || status.txStatus === "IMMUTABLE") {
+                    // Get current height for depth calculation if we haven't already
+                    if (currentHeight === undefined) {
+                        currentHeight = await this.getHeight();
+                    }
+                    const depth = status.blockHeight
+                        ? currentHeight - status.blockHeight + 1
+                        : 1;
+                    results.push({ txid, status: "mined", depth });
+                }
+                else if (status.txStatus === "SEEN_ON_NETWORK" ||
+                    status.txStatus === "ACCEPTED_BY_NETWORK" ||
+                    status.txStatus === "SENT_TO_NETWORK" ||
+                    status.txStatus === "RECEIVED") {
+                    results.push({ txid, status: "known", depth: 0 });
+                }
+                else {
+                    // REJECTED, DOUBLE_SPEND_ATTEMPTED, UNKNOWN - fall back to Beef
+                    results.push(await this.getStatusFromBeef(txid));
+                }
+            }
+            catch {
+                // Arcade 404 or error - fall back to Beef storage
+                // NOTE: If Arcade's scope is too limited (only knows txs it broadcast),
+                // consider using Beef storage as the primary source instead.
+                results.push(await this.getStatusFromBeef(txid));
+            }
+        }
+        return {
+            name: "1sat-api",
+            status: "success",
+            results,
+        };
     }
-    async isUtxo(_output) {
-        throw new Error("isUtxo not yet implemented");
+    /**
+     * Helper to get tx status from Beef storage (fallback when Arcade doesn't know the tx)
+     */
+    async getStatusFromBeef(txid) {
+        try {
+            const beefBytes = await this.beef.getBeef(txid);
+            const tx = Transaction.fromBEEF(Array.from(beefBytes));
+            if (tx.merklePath) {
+                // Has a valid merkle path = mined
+                const currentHeight = await this.getHeight();
+                const depth = currentHeight - tx.merklePath.blockHeight + 1;
+                return { txid, status: "mined", depth };
+            }
+            else {
+                // No merkle path = known but not yet mined
+                return { txid, status: "known", depth: 0 };
+            }
+        }
+        catch {
+            // 404 or error from Beef = unknown
+            return { txid, status: "unknown", depth: undefined };
+        }
+    }
+    async isUtxo(output) {
+        const outpoint = `${output.txid}_${output.vout}`;
+        const spendTxid = await this.txo.getSpend(outpoint);
+        return spendTxid === null;
     }
-    async getUtxoStatus(_output, _outputFormat, _outpoint, _useNext) {
-        throw new Error("getUtxoStatus not yet implemented");
+    async getUtxoStatus(_output, _outputFormat, outpoint, _useNext) {
+        // We ignore _output (script hash) since we look up directly by outpoint
+        if (!outpoint) {
+            return {
+                name: "1sat-api",
+                status: "error",
+                error: new ServiceError("INVALID_PARAMETER", "outpoint is required for getUtxoStatus"),
+                details: [],
+            };
+        }
+        try {
+            const txo = await this.txo.get(outpoint, {
+                sats: true,
+                spend: true,
+                block: true,
+            });
+            const isUtxo = !txo.spend;
+            const [txid, voutStr] = txo.outpoint.split("_");
+            const vout = parseInt(voutStr, 10);
+            return {
+                name: "1sat-api",
+                status: "success",
+                isUtxo,
+                details: isUtxo
+                    ? [
+                        {
+                            txid,
+                            index: vout,
+                            satoshis: txo.satoshis,
+                            height: txo.blockHeight,
+                        },
+                    ]
+                    : [],
+            };
+        }
+        catch {
+            // TXO not found - treat as not a UTXO
+            return {
+                name: "1sat-api",
+                status: "success",
+                isUtxo: false,
+                details: [],
+            };
+        }
     }
-    async getScriptHashHistory(_hash, _useNext) {
-        throw new Error("getScriptHashHistory not yet implemented");
+    async getScriptHashHistory(hash, useNext) {
+        if (!this.fallbackServices) {
+            throw new Error("getScriptHashHistory not implemented");
+        }
+        return this.fallbackServices.getScriptHashHistory(hash, useNext);
     }
-    async hashToHeader(_hash) {
-        throw new Error("hashToHeader not yet implemented");
+    async hashToHeader(hash) {
+        const header = await this.chaintracks.findHeaderForBlockHash(hash);
+        if (!header) {
+            throw new Error(`Block header not found for hash: ${hash}`);
+        }
+        return header;
     }
-    async nLockTimeIsFinal(_txOrLockTime) {
-        throw new Error("nLockTimeIsFinal not yet implemented");
+    async nLockTimeIsFinal(txOrLockTime) {
+        const MAXINT = 0xffffffff;
+        const BLOCK_LIMIT = 500000000;
+        let nLockTime;
+        if (typeof txOrLockTime === "number") {
+            nLockTime = txOrLockTime;
+        }
+        else {
+            let tx;
+            if (typeof txOrLockTime === "string") {
+                tx = Transaction.fromHex(txOrLockTime);
+            }
+            else if (Array.isArray(txOrLockTime)) {
+                tx = Transaction.fromBinary(txOrLockTime);
+            }
+            else {
+                tx = txOrLockTime;
+            }
+            // If all inputs have max sequence, the transaction is final regardless of lockTime
+            if (tx.inputs.every((i) => i.sequence === MAXINT)) {
+                return true;
+            }
+            nLockTime = tx.lockTime;
+        }
+        // If lockTime >= BLOCK_LIMIT, it's a timestamp (seconds since epoch)
+        if (nLockTime >= BLOCK_LIMIT) {
+            const currentTime = Math.floor(Date.now() / 1000);
+            return nLockTime < currentTime;
+        }
+        // Otherwise, it's a block height
+        const height = await this.getHeight();
+        return nLockTime < height;
     }
 }