@arkade-os/sdk 0.4.21 → 0.4.23

package/dist/esm/identity/seedIdentity.js

@@ -6,6 +6,7 @@ import { hex } from "@scure/base";
 import { TreeSignerSession } from '../tree/signingSession.js';
 import { schnorr, signAsync } from "@noble/secp256k1";
 import { HDKey, expand, networks, scriptExpressions, } from "@bitcoinerlab/descriptors-scure";
+import { descriptorIsOurs, isMainnetDescriptor } from './descriptor.js';
 const ALL_SIGHASH = Object.values(SigHash).filter((x) => typeof x === "number");
 /**
  * Secret-bearing state for seed-backed identities, held off the public
@@ -19,85 +20,117 @@ const ALL_SIGHASH = Object.values(SigHash).filter((x) => typeof x === "number");
  */
 const seedBytes = new WeakMap();
 const mnemonicMeta = new WeakMap();
-// ── Helpers ──────────────────────────────────────────────────────
 /**
- * Detects the network from a descriptor string by checking for tpub (testnet)
- * vs xpub (mainnet) key prefix.
- * @internal
- */
-function detectNetwork(descriptor) {
-    return descriptor.includes("tpub") ? networks.testnet : networks.bitcoin;
-}
-function hasDescriptor(opts = {}) {
-    return "descriptor" in opts && typeof opts.descriptor === "string";
-}
-/**
- * Builds a BIP86 Taproot output descriptor from a seed and network flag.
- * @internal
- */
-function buildDescriptor(seed, isMainnet) {
-    const network = isMainnet ? networks.bitcoin : networks.testnet;
-    const masterNode = HDKey.fromMasterSeed(seed, network.bip32);
-    return scriptExpressions.trBIP32({
-        masterNode,
-        network,
-        account: 0,
-        change: 0,
-        index: 0,
-    });
-}
-/**
- * Seed-based identity derived from a raw seed and an output descriptor.
+ * Seed-based identity derived from a raw seed and an account descriptor
+ * *template*.
  *
  * This is the recommended identity type for most applications. It uses
- * standard BIP86 (Taproot) derivation by default and stores an output
- * descriptor for interoperability with other wallets.
+ * standard BIP86 (Taproot) derivation by default; callers that need a
+ * different path supply the wildcard template directly.
  *
  * Prefer this (or @see MnemonicIdentity) over `SingleKey` for new
  * integrations — `SingleKey` exists for backward compatibility with
  * raw nsec-style keys.
  *
- * For descriptor-based signing, wrap with {@link StaticDescriptorProvider}.
+ * The identity holds the wildcard *template* (e.g.
+ * `tr([fp/86'/0'/0']xpub/0/*)`) on its public {@link descriptor}
+ * field. HD rotation reads it directly; consumers that need a
+ * concrete descriptor at a specific index materialize it themselves
+ * (see `HDDescriptorProvider` in the wallet layer).
+ *
+ * Exposes seed-level primitives (signing, derivation, the template)
+ * but is deliberately NOT a `DescriptorProvider`. Wrap it explicitly
+ * to get one:
+ *  - `HDDescriptorProvider` for rotating receive addresses.
+ *  - {@link StaticDescriptorProvider} for legacy, single-key behaviour.
+ *
+ * The split prevents a SeedIdentity from being silently used as a
+ * concrete descriptor source, which would defeat HD rotation without
+ * any compile-time signal that something was wrong.
  *
  * @example
  * ```typescript
  * const seed = mnemonicToSeedSync(mnemonic);
  *
- * // Testnet (BIP86 path m/86'/1'/0'/0/0)
+ * // Testnet (BIP86 wildcard descriptor m/86'/1'/0'/0/*)
  * const identity = SeedIdentity.fromSeed(seed, { isMainnet: false });
  *
- * // Mainnet (BIP86 path m/86'/0'/0'/0/0)
+ * // Mainnet (BIP86 wildcard descriptor m/86'/0'/0'/0/*)
  * const identity = SeedIdentity.fromSeed(seed, { isMainnet: true });
  *
- * // Custom descriptor
+ * // Caller-supplied wildcard descriptor (must end in `/*)`).
  * const identity = SeedIdentity.fromSeed(seed, { descriptor });
  * ```
  */
 export class SeedIdentity {
-    constructor(seed, descriptor) {
+    /**
+     * Constructs a SeedIdentity from a 64-byte seed and either a
+     * caller-supplied wildcard descriptor (`{ descriptor }`) or the
+     * default BIP86 path at the requested network (`{ isMainnet }`).
+     * Prefer the {@link fromSeed} factory for symmetry with
+     * {@link MnemonicIdentity.fromMnemonic}.
+     *
+     * Throws on a non-wildcard descriptor, an xpub mismatch with the
+     * seed, or a missing derivation path.
+     */
+    constructor(seed, opts = {}) {
         if (seed.length !== 64) {
             throw new Error("Seed must be 64 bytes");
         }
+        // Resolve the descriptor: caller-supplied wins; otherwise build
+        // the BIP86 default at the requested network via the library.
+        let descriptor;
+        let network;
+        if ("descriptor" in opts && typeof opts.descriptor === "string") {
+            descriptor = opts.descriptor;
+            network = isMainnetDescriptor(descriptor)
+                ? networks.bitcoin
+                : networks.testnet;
+        }
+        else {
+            network =
+                (opts.isMainnet ?? true)
+                    ? networks.bitcoin
+                    : networks.testnet;
+            descriptor = scriptExpressions.trBIP32({
+                masterNode: HDKey.fromMasterSeed(seed, network.bip32),
+                network,
+                account: 0,
+                change: 0,
+                index: "*",
+            });
+        }
+        // Parse the descriptor, substituting the wildcard at index 0.
+        // The library raises "index passed for non-ranged descriptor"
+        // if the input isn't a wildcard template, which we re-wrap so
+        // the caller sees what they actually got wrong.
+        let expansion;
+        try {
+            expansion = expand({ descriptor, network, index: 0 });
+        }
+        catch (e) {
+            throw new Error(`SeedIdentity requires a wildcard descriptor template (must end in "/*)"); ${e instanceof Error ? e.message : String(e)}`);
+        }
+        const keyInfo = expansion.expansionMap?.["@0"];
         // Defensive copy: `derivedKey` and `descriptor` are computed eagerly
         // from the bytes we're about to stash, so a later mutation of the
         // caller's buffer must not drift the serialized `seed` out of sync
         // with the live identity state.
         seedBytes.set(this, new Uint8Array(seed));
         this.descriptor = descriptor;
-        const network = detectNetwork(descriptor);
-        // Parse and validate the descriptor using the library
-        const expansion = expand({ descriptor, network });
-        const keyInfo = expansion.expansionMap?.["@0"];
         if (!keyInfo?.originPath) {
             throw new Error("Descriptor must include a key origin path");
         }
-        // Verify the xpub in the descriptor matches our seed
+        // Verify the xpub in the descriptor matches our seed (validates
+        // that the descriptor was generated from this seed; we don't
+        // need to keep the xpub around afterwards — `isOurs` re-derives
+        // it from `this.descriptor` on demand).
         const masterNode = HDKey.fromMasterSeed(seed, network.bip32);
         const accountNode = masterNode.derive(`m${keyInfo.originPath}`);
         if (accountNode.publicExtendedKey !== keyInfo.bip32?.toBase58()) {
             throw new Error("xpub mismatch: derived key does not match descriptor");
         }
-        // Derive the private key using the full path from the descriptor
+        // Derive the private key for index 0 using the full path
         if (!keyInfo.path) {
             throw new Error("Descriptor must specify a full derivation path");
         }
@@ -111,16 +144,14 @@ export class SeedIdentity {
      * Creates a SeedIdentity from a raw 64-byte seed.
      *
      * Pass `{ isMainnet }` for default BIP86 derivation, or
-     * `{ descriptor }` for a custom derivation path.
+     * `{ descriptor }` for a caller-supplied account-descriptor
+     * template (the option's value must end with `/*)`).
      *
      * @param seed - 64-byte seed (typically from mnemonicToSeedSync)
-     * @param opts - Network selection or custom descriptor.
+     * @param opts - Network selection or descriptor template.
      */
     static fromSeed(seed, opts = {}) {
-        const descriptor = hasDescriptor(opts)
-            ? opts.descriptor
-            : buildDescriptor(seed, opts.isMainnet ?? true);
-        return new SeedIdentity(seed, descriptor);
+        return new SeedIdentity(seed, opts);
     }
     async xOnlyPublicKey() {
         return pubSchnorr(this.derivedKey);
@@ -129,10 +160,82 @@ export class SeedIdentity {
         return pubECDSA(this.derivedKey, true);
     }
     async sign(tx, inputIndexes) {
+        return this.signTxWithKey(tx, this.derivedKey, inputIndexes);
+    }
+    async signMessage(message, signatureType = "schnorr") {
+        return this.signMessageWithKey(this.derivedKey, message, signatureType);
+    }
+    signerSession() {
+        return TreeSignerSession.random();
+    }
+    /**
+     * Converts to a watch-only identity that cannot sign. Carries the
+     * template forward, so the readonly side stays HD-capable (can
+     * derive descriptors at any index without seed access).
+     */
+    async toReadonly() {
+        return ReadonlyDescriptorIdentity.fromDescriptor(this.descriptor);
+    }
+    /**
+     * Returns true when `descriptor` is derived from this identity's seed.
+     * HD descriptors match by account xpub; bare `tr(pubkey)` descriptors
+     * match by raw pubkey. See {@link descriptorIsOurs}.
+     */
+    isOurs(descriptor) {
+        return descriptorIsOurs(descriptor, this.descriptor, pubSchnorr(this.derivedKey));
+    }
+    /**
+     * Signs each request with the key derived from its descriptor.
+     * Each descriptor must share this identity's seed ({@link isOurs}).
+     */
+    async signWithDescriptor(requests) {
+        return requests.map((request) => {
+            if (!this.isOurs(request.descriptor)) {
+                throw new Error(`Descriptor ${request.descriptor} does not belong to this identity`);
+            }
+            const key = this.derivePrivateKeyForDescriptor(request.descriptor);
+            return this.signTxWithKey(request.tx, key, request.inputIndexes);
+        });
+    }
+    /**
+     * Signs a message with the key derived from `descriptor`.
+     */
+    async signMessageWithDescriptor(descriptor, message, signatureType = "schnorr") {
+        if (!this.isOurs(descriptor)) {
+            throw new Error(`Descriptor ${descriptor} does not belong to this identity`);
+        }
+        const key = this.derivePrivateKeyForDescriptor(descriptor);
+        return this.signMessageWithKey(key, message, signatureType);
+    }
+    // ── internal helpers ─────────────────────────────────────────────
+    derivePrivateKeyForDescriptor(descriptor) {
+        const network = isMainnetDescriptor(descriptor)
+            ? networks.bitcoin
+            : networks.testnet;
+        const expansion = expand({ descriptor, network });
+        if (expansion.isRanged) {
+            throw new Error("Cannot sign with a wildcard descriptor; derive a concrete index first");
+        }
+        const keyInfo = expansion.expansionMap?.["@0"];
+        if (!keyInfo?.path) {
+            throw new Error("Descriptor must specify a full derivation path for signing");
+        }
+        const seed = seedBytes.get(this);
+        if (!seed) {
+            throw new Error("Seed bytes not available for descriptor signing");
+        }
+        const masterNode = HDKey.fromMasterSeed(seed, network.bip32);
+        const node = masterNode.derive(keyInfo.path);
+        if (!node.privateKey) {
+            throw new Error("Failed to derive private key for descriptor");
+        }
+        return node.privateKey;
+    }
+    signTxWithKey(tx, key, inputIndexes) {
         const txCpy = tx.clone();
         if (!inputIndexes) {
             try {
-                if (!txCpy.sign(this.derivedKey, ALL_SIGHASH)) {
+                if (!txCpy.sign(key, ALL_SIGHASH)) {
                     throw new Error("Failed to sign transaction");
                 }
             }
@@ -145,29 +248,20 @@ export class SeedIdentity {
                     throw e;
                 }
             }
-            return txCpy;
         }
-        for (const inputIndex of inputIndexes) {
-            if (!txCpy.signIdx(this.derivedKey, inputIndex, ALL_SIGHASH)) {
-                throw new Error(`Failed to sign input #${inputIndex}`);
+        else {
+            for (const idx of inputIndexes) {
+                if (!txCpy.signIdx(key, idx, ALL_SIGHASH)) {
+                    throw new Error(`Failed to sign input #${idx}`);
+                }
             }
         }
         return txCpy;
     }
-    async signMessage(message, signatureType = "schnorr") {
-        if (signatureType === "ecdsa") {
-            return signAsync(message, this.derivedKey, { prehash: false });
-        }
-        return schnorr.signAsync(message, this.derivedKey);
-    }
-    signerSession() {
-        return TreeSignerSession.random();
-    }
-    /**
-     * Converts to a watch-only identity that cannot sign.
-     */
-    async toReadonly() {
-        return ReadonlyDescriptorIdentity.fromDescriptor(this.descriptor);
+    signMessageWithKey(key, message, signatureType) {
+        if (signatureType === "ecdsa")
+            return signAsync(message, key, { prehash: false });
+        return schnorr.signAsync(message, key);
     }
 }
 /**
@@ -187,82 +281,107 @@ export class SeedIdentity {
  * ```
  */
 export class MnemonicIdentity extends SeedIdentity {
-    constructor(seed, descriptor, mnemonic, passphrase) {
-        super(seed, descriptor);
-        mnemonicMeta.set(this, { mnemonic, passphrase });
+    constructor(phrase, opts) {
+        const { passphrase } = opts;
+        super(mnemonicToSeedSync(phrase, passphrase), opts);
+        mnemonicMeta.set(this, { mnemonic: phrase, passphrase });
     }
     /**
      * Creates a MnemonicIdentity from a BIP39 mnemonic phrase.
      *
      * Pass `{ isMainnet }` for default BIP86 derivation, or
-     * `{ descriptor }` for a custom derivation path.
+     * `{ descriptor }` for a caller-supplied account-descriptor
+     * template (the option's value must end with `/*)`).
      *
      * @param phrase - BIP39 mnemonic phrase (12 or 24 words)
-     * @param opts - Network selection or custom descriptor, plus optional passphrase
+     * @param opts - Network selection or descriptor template, plus optional passphrase
      */
     static fromMnemonic(phrase, opts = {}) {
         if (!validateMnemonic(phrase, wordlist)) {
             throw new Error("Invalid mnemonic");
         }
-        const passphrase = opts.passphrase;
-        const seed = mnemonicToSeedSync(phrase, passphrase);
-        const descriptor = hasDescriptor(opts)
-            ? opts.descriptor
-            : buildDescriptor(seed, opts.isMainnet ?? true);
-        return new MnemonicIdentity(seed, descriptor, phrase, passphrase);
+        return new MnemonicIdentity(phrase, opts);
     }
 }
 /**
- * Watch-only identity from an output descriptor.
+ * Watch-only HD identity from a descriptor *template*.
  *
  * Can derive public keys but cannot sign transactions. Use this for
- * watch-only wallets or when sharing identity information without
- * exposing private keys.
+ * watch-only wallets — given just an xpub-based template, the readonly
+ * side still rotates through HD indices.
+ *
+ * Constructed from a wildcard template (e.g.
+ * `tr([fp/86'/0'/0']xpub.../0/*)`); the {@link descriptor} field
+ * holds it for HD providers to consume.
  *
  * @example
  * ```typescript
- * const descriptor = "tr([fingerprint/86'/0'/0']xpub.../0/0)";
- * const readonly = ReadonlyDescriptorIdentity.fromDescriptor(descriptor);
- * const pubKey = await readonly.xOnlyPublicKey();
+ * const ro = ReadonlyDescriptorIdentity.fromDescriptor(
+ *   "tr([fp/86'/0'/0']xpub.../0/*)"
+ * );
+ * ro.descriptor;
+ * // => "tr([fp/86'/0'/0']xpub.../0/*)" — the template
  * ```
  */
 export class ReadonlyDescriptorIdentity {
     constructor(descriptor) {
-        this.descriptor = descriptor;
-        const network = detectNetwork(descriptor);
-        const expansion = expand({ descriptor, network });
+        const network = isMainnetDescriptor(descriptor)
+            ? networks.bitcoin
+            : networks.testnet;
+        // Library substitutes the wildcard at index 0 and raises
+        // "index passed for non-ranged descriptor" if `descriptor` isn't
+        // actually a wildcard template — re-wrap so the caller sees
+        // the higher-level invariant they violated.
+        let expansion;
+        try {
+            expansion = expand({ descriptor, network, index: 0 });
+        }
+        catch (e) {
+            throw new Error(`ReadonlyDescriptorIdentity requires a wildcard descriptor template (must end in "/*)"); ${e instanceof Error ? e.message : String(e)}`);
+        }
         const keyInfo = expansion.expansionMap?.["@0"];
         if (!keyInfo?.pubkey) {
             throw new Error("Failed to derive public key from descriptor");
         }
-        // For taproot, the library returns 32-byte x-only pubkey
-        this.xOnlyPubKey = keyInfo.pubkey;
-        // Get 33-byte compressed key with correct parity from the bip32 node
-        if (keyInfo.bip32 && keyInfo.keyPath) {
-            // Strip leading "/" — the library's derivePath prepends "m/" itself
-            const relPath = keyInfo.keyPath.replace(/^\//, "");
-            this.compressedPubKey = keyInfo.bip32.derivePath(relPath).publicKey;
-        }
-        else if (keyInfo.bip32) {
-            this.compressedPubKey = keyInfo.bip32.publicKey;
-        }
-        else {
+        if (!keyInfo.bip32) {
             throw new Error("Cannot determine compressed public key parity from descriptor");
         }
+        this.descriptor = descriptor;
+        this.indexZero = keyInfo;
     }
     /**
-     * Creates a ReadonlyDescriptorIdentity from an output descriptor.
+     * Creates a ReadonlyDescriptorIdentity from an account-descriptor
+     * *template* (must end with the BIP-32 wildcard suffix `/*)`).
      *
-     * @param descriptor - Taproot descriptor: tr([fingerprint/path']xpub.../child/path)
+     * @param descriptor - Wildcard-suffixed Taproot template
+     *   (`tr([fp/path']xpub.../child/*)`).
      */
     static fromDescriptor(descriptor) {
         return new ReadonlyDescriptorIdentity(descriptor);
     }
     async xOnlyPublicKey() {
-        return this.xOnlyPubKey;
+        // Validated non-null in the constructor.
+        return this.indexZero.pubkey;
     }
     async compressedPublicKey() {
-        return this.compressedPubKey;
+        const { bip32, keyPath } = this.indexZero;
+        // bip32 validated non-null in the constructor; derivePath
+        // returns a fresh node so this is a read of the index-0
+        // compressed pubkey, not a mutation of the stored one.
+        if (keyPath) {
+            // Strip leading "/" — the library's derivePath prepends "m/" itself
+            return bip32.derivePath(keyPath.replace(/^\//, "")).publicKey;
+        }
+        return bip32.publicKey;
+    }
+    /**
+     * Returns true when `descriptor` derives from this identity's xpub.
+     * HD descriptors match by account xpub; bare `tr(pubkey)` descriptors
+     * fall back to comparing against the index-0 x-only pubkey. See
+     * {@link descriptorIsOurs}.
+     */
+    isOurs(descriptor) {
+        return descriptorIsOurs(descriptor, this.descriptor, this.indexZero.pubkey);
     }
 }
 /**
@@ -327,5 +446,8 @@ export function serializeSeedOwnedSigningIdentity(identity) {
  * @internal
  */
 export function serializeSeedOwnedReadonlyIdentity(identity) {
-    return { type: "readonly-descriptor", descriptor: identity.descriptor };
+    return {
+        type: "readonly-descriptor",
+        descriptor: identity.descriptor,
+    };
 }

package/dist/esm/identity/serialize.js

@@ -54,6 +54,11 @@ export async function serializeReadonlyIdentity(identity) {
  * The return type is the union of signing and readonly; use
  * {@link isSigningSerialized} on the envelope before hydration if the caller
  * needs to know which side it ends up on.
+ *
+ * Envelopes store the wildcard template directly (see
+ * `serializeSeedOwnedSigningIdentity` / `serializeSeedOwnedReadonlyIdentity`),
+ * so the `descriptor` field is passed straight through to the
+ * template-only factories.
  */
 export function hydrateIdentity(s) {
     switch (s.type) {

package/dist/esm/identity/staticDescriptorProvider.js

@@ -15,7 +15,7 @@ export class StaticDescriptorProvider {
         const pubKey = await identity.xOnlyPublicKey();
         return new StaticDescriptorProvider(identity, hex.encode(pubKey));
     }
-    getSigningDescriptor() {
+    async getNextSigningDescriptor() {
         return this.descriptor;
     }
     isOurs(descriptor) {

package/dist/esm/index.js

@@ -13,12 +13,13 @@ import { Batch } from './wallet/batch.js';
 import { Wallet, ReadonlyWallet, waitForIncomingFunds, } from './wallet/wallet.js';
 import { TxTree } from './tree/txTree.js';
 import { Ramps } from './wallet/ramps.js';
+import { HDDescriptorProvider } from './wallet/hdDescriptorProvider.js';
 import { isVtxoExpiringSoon, VtxoManager } from './wallet/vtxo-manager.js';
 import { ServiceWorkerWallet, ServiceWorkerReadonlyWallet, DEFAULT_MESSAGE_TIMEOUTS, } from './wallet/serviceWorker/wallet.js';
 import { OnchainWallet } from './wallet/onchain.js';
 import { setupServiceWorker } from './worker/browser/utils.js';
 import { ESPLORA_URL, EsploraProvider, } from './providers/onchain.js';
-import { ElectrumOnchainProvider, WsElectrumChainSource, } from './providers/electrum.js';
+import { ELECTRUM_TCP_HOST, ELECTRUM_WS_URL, ElectrumOnchainProvider, WsElectrumChainSource, } from './providers/electrum.js';
 import { RestArkProvider, SettlementEventType, } from './providers/ark.js';
 import { RestDelegatorProvider, } from './providers/delegator.js';
 import { CLTVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CSVMultisigTapscript, decodeTapscript, MultisigTapscript, } from './script/tapscript.js';
@@ -30,6 +31,7 @@ import { ArkNote } from './arknote/index.js';
 import { networks } from './networks.js';
 import { RestIndexerProvider, IndexerTxType, ChainTxType, } from './providers/indexer.js';
 import { P2A } from './utils/anchor.js';
+import { TxWeightEstimator } from './utils/txSizeEstimator.js';
 import { Unroll } from './wallet/unroll.js';
 import { ArkError, maybeArkError } from './providers/errors.js';
 import { validateVtxoTxGraph, validateConnectorsTxGraph, } from './tree/validation.js';
@@ -40,14 +42,15 @@ export * from './arkfee/index.js';
 export * as asset from './extension/asset/index.js';
 // Contracts
 import { ContractManager, ContractWatcher, contractHandlers, DefaultContractHandler, DelegateContractHandler, VHTLCContractHandler, encodeArkContract, decodeArkContract, contractFromArkContract, contractFromArkContractWithAddress, isArkContract, } from './contracts/index.js';
+import { timelockToSequence, sequenceToTimelock, } from './contracts/handlers/helpers.js';
 import { closeDatabase, openDatabase } from './repositories/indexedDB/manager.js';
 import { WalletMessageHandler, WalletNotInitializedError, ReadonlyWalletError, DelegatorNotConfiguredError, } from './wallet/serviceWorker/wallet-message-handler.js';
 import { MESSAGE_BUS_NOT_INITIALIZED, MessageBusNotInitializedError, ServiceWorkerTimeoutError, } from './worker/errors.js';
 export { 
 // Wallets
-Wallet, ReadonlyWallet, SingleKey, ReadonlySingleKey, SeedIdentity, MnemonicIdentity, ReadonlyDescriptorIdentity, isBatchSignable, OnchainWallet, Ramps, VtxoManager, DelegatorManagerImpl, RestDelegatorProvider, 
+Wallet, ReadonlyWallet, SingleKey, ReadonlySingleKey, SeedIdentity, MnemonicIdentity, ReadonlyDescriptorIdentity, isBatchSignable, OnchainWallet, Ramps, VtxoManager, HDDescriptorProvider, DelegatorManagerImpl, RestDelegatorProvider, 
 // Providers
-ESPLORA_URL, EsploraProvider, ElectrumOnchainProvider, WsElectrumChainSource, RestArkProvider, RestIndexerProvider, 
+ESPLORA_URL, EsploraProvider, ELECTRUM_WS_URL, ELECTRUM_TCP_HOST, ElectrumOnchainProvider, WsElectrumChainSource, RestArkProvider, RestIndexerProvider, 
 // Script-related
 ArkAddress, DefaultVtxo, DelegateVtxo, VtxoScript, VHTLC, 
 // Enums
@@ -75,7 +78,7 @@ BIP322,
 // TxTree
 TxTree, 
 // Anchor
-P2A, Unroll, Transaction, 
+P2A, Unroll, Transaction, TxWeightEstimator, timelockToSequence, sequenceToTimelock, 
 // Errors
 ArkError, maybeArkError, 
 // Batch session