@vbyte/btc-dev 1.0.1 → 1.0.3

package/dist/main.cjs

@@ -8413,7 +8413,7 @@ const DEFAULT_CONFIG = {
     prevouts: [],
     segwit: true
 };
-function decode_tx_data(txbytes, options = {}) {
+function decode_tx(txbytes, options = {}) {
     const config = { ...DEFAULT_CONFIG, ...options };
     Assert.is_bytes(txbytes, 'txbytes must be hex or a unit array');
     const stream = new Stream(txbytes);
@@ -8573,7 +8573,7 @@ var tx = /*#__PURE__*/Object.freeze({
     vin_template: vin_template
 });
 
-var index$7 = /*#__PURE__*/Object.freeze({
+var index$9 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     taproot: taproot,
     tx: tx
@@ -8642,7 +8642,7 @@ function create_tx_output(config) {
     const { script_pk, value } = config;
     return { script_pk, value: BigInt(value) };
 }
-function create_tx_data(config) {
+function create_tx(config) {
     assert_tx_template(config);
     const { vin = [], vout = [] } = config;
     const locktime = config.locktime ?? DEFAULT.LOCKTIME;
@@ -8652,13 +8652,13 @@ function create_tx_data(config) {
     return { locktime, vin: inputs, vout: outputs, version };
 }
 
-function parse_tx_data(txdata) {
+function parse_tx(txdata) {
     if (typeof txdata === 'string') {
-        return decode_tx_data(txdata);
+        return decode_tx(txdata);
     }
     else {
         assert_tx_template(txdata);
-        return create_tx_data(txdata);
+        return create_tx(txdata);
     }
 }
 
@@ -8995,7 +8995,7 @@ var ScriptUtil;
     ScriptUtil.OPCODES = OPCODE_MAP;
 })(ScriptUtil || (ScriptUtil = {}));
 
-var index$6 = /*#__PURE__*/Object.freeze({
+var index$8 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     OPCODE_MAP: OPCODE_MAP,
     get ScriptUtil () { return ScriptUtil; },
@@ -9014,8 +9014,8 @@ var index$6 = /*#__PURE__*/Object.freeze({
     split_script_word: split_script_word
 });
 
-function encode_tx_data(txdata, segwit = true) {
-    const tx = parse_tx_data(txdata);
+function encode_tx(txdata, segwit = true) {
+    const tx = parse_tx(txdata);
     const { version, vin, vout, locktime } = tx;
     const buffer = [encode_tx_version(version)];
     if (segwit) {
@@ -9105,43 +9105,6 @@ function encode_script_data(script) {
     }
 }
 
-const LOCKTIME_THRESHOLD = 500000000;
-var Locktime;
-(function (Locktime) {
-    Locktime.encode = encode_locktime;
-    Locktime.decode = decode_locktime;
-})(Locktime || (Locktime = {}));
-function encode_locktime(locktime) {
-    switch (locktime.type) {
-        case 'timelock':
-            Assert.ok(locktime.stamp >= LOCKTIME_THRESHOLD, 'Invalid timestamp');
-            return locktime.stamp;
-        case 'heightlock':
-            Assert.ok(locktime.height > 0, 'height must be greater than 0');
-            Assert.ok(locktime.height < LOCKTIME_THRESHOLD, 'invalid block height');
-            return locktime.height;
-        default:
-            throw new Error('Invalid locktime type');
-    }
-}
-function decode_locktime(locktime) {
-    if (isNaN(locktime) || locktime <= 0) {
-        return null;
-    }
-    if (locktime < LOCKTIME_THRESHOLD) {
-        return {
-            type: 'heightlock',
-            height: locktime
-        };
-    }
-    else {
-        return {
-            type: 'timelock',
-            stamp: locktime
-        };
-    }
-}
-
 function is_return_script(script) {
     return script.startsWith('6a');
 }
@@ -9170,100 +9133,33 @@ function get_vout_version(script) {
     }
 }
 function get_txid(txdata) {
-    const json = parse_tx_data(txdata);
-    const data = encode_tx_data(json, false);
+    const json = parse_tx(txdata);
+    const data = encode_tx(json, false);
     return hash256(data).reverse().hex;
 }
 function get_txhash(txdata) {
-    const json = parse_tx_data(txdata);
-    const data = encode_tx_data(json, true);
+    const json = parse_tx(txdata);
+    const data = encode_tx(json, true);
     return hash256(data).reverse().hex;
 }
 function get_tx_value(txdata) {
-    const tx = parse_tx_data(txdata);
+    const tx = parse_tx(txdata);
     const vin = tx.vin.reduce((acc, txin) => acc + (txin.prevout?.value ?? 0n), 0n);
     const vout = tx.vout.reduce((acc, txout) => acc + txout.value, 0n);
     const fees = (vin > vout) ? (vin - vout) : 0n;
     return { fees, vin, vout };
 }
 
-const TIMELOCK_DISABLE = 0x80000000;
-const TIMELOCK_TYPE = 0x00400000;
-const TIMELOCK_VALUE_MASK = 0x0000FFFF;
-const TIMELOCK_VALUE_MAX = 0xFFFF;
-const TIMELOCK_GRANULARITY = 512;
-var Sequence;
-(function (Sequence) {
-    Sequence.encode = encode_sequence;
-    Sequence.decode = decode_sequence;
-})(Sequence || (Sequence = {}));
-function encode_sequence(data) {
-    if (data.mode === 'height') {
-        const height = parse_height(data.height);
-        return (height & TIMELOCK_VALUE_MASK) >>> 0;
-    }
-    if (data.mode === 'stamp') {
-        const stamp = parse_stamp(data.stamp);
-        return (TIMELOCK_TYPE | (stamp & TIMELOCK_VALUE_MASK)) >>> 0;
-    }
-    throw new Error('invalid timelock mode: ' + data.mode);
-}
-function decode_sequence(sequence) {
-    const seq = parse_sequence(sequence);
-    if (seq & TIMELOCK_DISABLE)
-        return null;
-    const value = seq & TIMELOCK_VALUE_MASK;
-    if (seq & TIMELOCK_TYPE) {
-        const stamp = value * TIMELOCK_GRANULARITY;
-        if (stamp > 0xFFFFFFFF) {
-            throw new Error('Decoded timestamp exceeds 32-bit limit');
-        }
-        return { mode: 'stamp', stamp };
-    }
-    else {
-        if (value > TIMELOCK_VALUE_MAX) {
-            throw new Error('Decoded height exceeds maximum');
-        }
-        return { mode: 'height', height: value };
-    }
-}
-function parse_sequence(sequence) {
-    const seq = (typeof sequence === 'string')
-        ? parseInt(sequence, 16)
-        : sequence;
-    if (!Number.isInteger(seq) || seq < 0 || seq > 0xFFFFFFFF) {
-        throw new Error(`invalid sequence value: ${seq}`);
-    }
-    return seq;
-}
-function parse_stamp(stamp) {
-    if (stamp === undefined || !Number.isInteger(stamp)) {
-        throw new Error(`timestamp must be a number`);
-    }
-    const ts = Math.floor(stamp / TIMELOCK_GRANULARITY);
-    if (!Number.isInteger(ts) || ts < 0 || ts > TIMELOCK_VALUE_MAX) {
-        throw new Error(`timelock value must be an integer between 0 and ${TIMELOCK_VALUE_MAX} (in 512-second increments)`);
-    }
-    return ts;
-}
-function parse_height(height) {
-    if (height === undefined || !Number.isInteger(height) || height < 0 || height > TIMELOCK_VALUE_MAX) {
-        throw new Error(`Heightlock value must be an integer between 0 and ${TIMELOCK_VALUE_MAX}`);
-    }
-    return height;
-}
-
 const WIT_FLAG_BYTES = 2;
-const WIT_LENGTH_BYTE = 1;
 function get_vsize$1(bytes) {
     const weight = Buff.bytes(bytes).length;
     const remain = (weight % 4 > 0) ? 1 : 0;
     return Math.floor(weight / 4) + remain;
 }
 function get_txsize(txdata) {
-    const json = parse_tx_data(txdata);
-    const base = encode_tx_data(json, false).length;
-    const size = encode_tx_data(json, true).length;
+    const json = parse_tx(txdata);
+    const base = encode_tx(json, false).length;
+    const size = encode_tx(json, true).length;
     const weight = base * 3 + size;
     const remain = (weight % 4 > 0) ? 1 : 0;
     const vsize = Math.floor(weight / 4) + remain;
@@ -9292,100 +9188,9 @@ function get_txout_size(txoutput) {
     const bytes = encode_tx_vout(txoutput);
     return bytes.length;
 }
-function get_witness_size(witness) {
-    const stack = witness.map(e => Buff.bytes(e));
-    const size = stack.reduce((prev, next) => prev + next.length, 0);
-    const vsize = Math.ceil(WIT_LENGTH_BYTE + size / 4);
-    return { size, vsize };
-}
-
-function parse_witness_data(witness) {
-    const elems = witness.map(e => Buff.bytes(e));
-    const annex = parse_annex_data(elems);
-    if (annex !== null)
-        elems.pop();
-    const cblock = parse_cblock_data(elems);
-    if (cblock !== null)
-        elems.pop();
-    const type = parse_witness_type(elems, cblock);
-    const version = parse_witness_version(type);
-    const script = parse_witness_script(elems, type);
-    if (script !== null)
-        elems.pop();
-    const params = elems.map(e => e.hex);
-    return { annex, cblock, params, script, type, version };
-}
-function parse_annex_data(data) {
-    let elem = data.at(-1);
-    if (data.length > 1 &&
-        elem instanceof Uint8Array &&
-        elem[0] === 0x50) {
-        return new Buff(elem).hex;
-    }
-    else {
-        return null;
-    }
-}
-function parse_cblock_data(data) {
-    let elem = data.at(-1);
-    if (data.length > 1 &&
-        elem instanceof Uint8Array &&
-        elem.length > 32 &&
-        TAPLEAF_VERSIONS.includes(elem[0] & 0xfe)) {
-        return new Buff(elem).hex;
-    }
-    else {
-        return null;
-    }
-}
-function parse_witness_script(elems, type) {
-    let script;
-    switch (type) {
-        case 'p2tr-ts':
-            script = elems.at(-1);
-        case 'p2w-sh':
-            script = elems.at(-1);
-    }
-    return (script !== undefined) ? new Buff(script).hex : null;
-}
-function parse_witness_type(elems, cblock) {
-    let param_0 = elems.at(0), param_1 = elems.at(1), param_x = elems.at(-1);
-    if (cblock !== null && param_x !== undefined) {
-        return 'p2tr-ts';
-    }
-    else if (elems.length === 2 &&
-        param_0 !== undefined &&
-        param_1 !== undefined &&
-        param_0.length >= 64 &&
-        param_1.length === 33) {
-        return 'p2w-pkh';
-    }
-    else if (elems.length === 1 &&
-        param_0 !== undefined &&
-        param_0.length === 64) {
-        return 'p2tr-pk';
-    }
-    else if (elems.length > 1 &&
-        param_x !== undefined &&
-        is_valid_script(param_x)) {
-        return 'p2w-sh';
-    }
-    else {
-        return 'unknown';
-    }
-}
-function parse_witness_version(type) {
-    if (type.startsWith('p2tr'))
-        return 1;
-    if (type.startsWith('p2w'))
-        return 0;
-    return null;
-}
 
-var index$5 = /*#__PURE__*/Object.freeze({
+var index$7 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    get Locktime () { return Locktime; },
-    get Sequence () { return Sequence; },
     assert_has_prevouts: assert_has_prevouts,
     assert_tx_data: assert_tx_data,
     assert_tx_input: assert_tx_input,
@@ -9394,16 +9199,12 @@ var index$5 = /*#__PURE__*/Object.freeze({
     assert_vin_template: assert_vin_template,
     create_coinbase_input: create_coinbase_input,
     create_spend_input: create_spend_input,
-    create_tx_data: create_tx_data,
+    create_tx: create_tx,
     create_tx_input: create_tx_input,
     create_tx_output: create_tx_output,
-    decode_locktime: decode_locktime,
-    decode_sequence: decode_sequence,
-    decode_tx_data: decode_tx_data,
-    encode_locktime: encode_locktime,
+    decode_tx: decode_tx,
     encode_script_data: encode_script_data,
-    encode_sequence: encode_sequence,
-    encode_tx_data: encode_tx_data,
+    encode_tx: encode_tx,
     encode_tx_inputs: encode_tx_inputs,
     encode_tx_locktime: encode_tx_locktime,
     encode_tx_outputs: encode_tx_outputs,
@@ -9428,16 +9229,14 @@ var index$5 = /*#__PURE__*/Object.freeze({
     get_vout_type: get_vout_type,
     get_vout_version: get_vout_version,
     get_vsize: get_vsize$1,
-    get_witness_size: get_witness_size,
     is_return_script: is_return_script,
-    parse_tx_data: parse_tx_data,
-    parse_witness_data: parse_witness_data,
+    parse_tx: parse_tx,
     read_script: read_script
 });
 
 function hash_segwit_tx(txdata, options = {}) {
     const { sigflag = 0x01, txindex } = options;
-    const tx = parse_tx_data(txdata);
+    const tx = parse_tx(txdata);
     const is_anypay = (sigflag & 0x80) === 0x80;
     const flag = sigflag % 0x80;
     if (!SIGHASH_SEGWIT.includes(flag)) {
@@ -9543,7 +9342,7 @@ function encode_taptweak(pubkey, data = new Uint8Array()) {
 
 function hash_taproot_tx(template, config = {}) {
     const { script, txindex, sigflag = 0x00, extflag = 0x00, key_version = 0x00, separator_pos = 0xFFFFFFFF } = config;
-    const tx = parse_tx_data(template);
+    const tx = parse_tx(template);
     const { version, vin: input, vout: output, locktime } = tx;
     const txinput = parse_txinput(tx, config);
     const { txid, vout, sequence, witness = [] } = txinput;
@@ -9658,14 +9457,14 @@ function get_prevout(vin) {
 }
 
 function sign_segwit_tx(seckey, txdata, options) {
-    const tx = parse_tx_data(txdata);
+    const tx = parse_tx(txdata);
     const msg = hash_segwit_tx(tx, options);
     const sig = sign_ecdsa(seckey, msg).hex;
     const flag = format_sigflag(options.sigflag ?? SIGHASH_DEFAULT);
     return sig + flag;
 }
 function sign_taproot_tx(seckey, txdata, options) {
-    const tx = parse_tx_data(txdata);
+    const tx = parse_tx(txdata);
     const msg = hash_taproot_tx(tx, options);
     const sig = sign_bip340(seckey, msg).hex;
     const flag = format_sigflag(options.sigflag ?? 0);
@@ -9702,840 +9501,1046 @@ class TxSigner {
     }
 }
 
-class TransactionOutput {
-    constructor(txout) {
-        this._info = get_vout_info(txout);
-        this._size = get_txout_size(txout);
-        this._txout = txout;
+const LOCKTIME_THRESHOLD = 500000000;
+var LocktimeUtil;
+(function (LocktimeUtil) {
+    LocktimeUtil.encode = encode_locktime;
+    LocktimeUtil.decode = decode_locktime;
+})(LocktimeUtil || (LocktimeUtil = {}));
+function encode_locktime(locktime) {
+    switch (locktime.type) {
+        case 'timelock':
+            Assert.ok(locktime.stamp >= LOCKTIME_THRESHOLD, 'Invalid timestamp');
+            return locktime.stamp;
+        case 'heightlock':
+            Assert.ok(locktime.height > 0, 'height must be greater than 0');
+            Assert.ok(locktime.height < LOCKTIME_THRESHOLD, 'invalid block height');
+            return locktime.height;
+        default:
+            throw new Error('Invalid locktime type');
     }
-    get data() {
+}
+function decode_locktime(locktime) {
+    if (isNaN(locktime) || locktime <= 0) {
+        return null;
+    }
+    if (locktime < LOCKTIME_THRESHOLD) {
         return {
-            script_pk: this.script_pk,
-            size: this.size,
-            type: this.type,
-            value: this.value,
-            version: this.version
+            type: 'heightlock',
+            height: locktime
         };
     }
-    get script_pk() {
+    else {
         return {
-            hex: this._txout.script_pk,
-            asm: decode_script(this._txout.script_pk)
+            type: 'timelock',
+            stamp: locktime
         };
     }
-    get size() {
-        return this._size;
-    }
-    get type() {
-        return this._info.type;
-    }
-    get value() {
-        return this._txout.value;
-    }
-    get version() {
-        return this._info.version;
-    }
-    toJSON() { return this.data; }
-    toString() { return JSON.stringify(this.data); }
 }
 
-class TransactionWitness {
-    constructor(witness) {
-        this._data = witness.map(e => Buff.bytes(e));
-        this._meta = parse_witness_data(witness);
-        this._size = get_witness_size(witness);
-    }
-    get annex() {
-        return this._meta.annex;
-    }
-    get cblock() {
-        return this._meta.cblock;
-    }
-    get data() {
-        return {
-            annex: this.annex,
-            cblock: this.cblock,
-            params: this.params,
-            script: this.script,
-            size: this.size,
-            stack: this.stack,
-            type: this.type,
-            version: this.version,
-            vsize: this.vsize
-        };
-    }
-    get params() {
-        return this._meta.params;
-    }
-    get script() {
-        if (this._meta.script === null)
-            return null;
-        return {
-            hex: this._meta.script,
-            asm: decode_script(this._meta.script)
-        };
-    }
-    get size() {
-        return this._size.size;
-    }
-    get stack() {
-        return this._data.map(e => e.hex);
-    }
-    get type() {
-        return this._meta.type;
+var RefEncoder;
+(function (RefEncoder) {
+    RefEncoder.outpoint = {
+        encode: encode_outpoint,
+        decode: decode_outpoint,
+        verify: verify_outpoint,
+        assert: assert_outpoint,
+    };
+    RefEncoder.record_id = {
+        encode: encode_inscription_id,
+        decode: decode_inscription_id,
+        verify: verify_inscription_id,
+        assert: assert_inscription_id,
+    };
+    RefEncoder.rune_id = {
+        encode: encode_rune_id,
+        decode: decode_rune_id,
+        verify: verify_rune_id,
+        assert: assert_rune_id,
+    };
+})(RefEncoder || (RefEncoder = {}));
+function encode_inscription_id(txid, order = 0) {
+    return `${txid}i${order}`;
+}
+function decode_inscription_id(inscription_id) {
+    assert_inscription_id(inscription_id);
+    const [txid, order] = inscription_id.split('i');
+    return { txid, order: parseInt(order) };
+}
+function verify_inscription_id(inscription_id) {
+    return inscription_id.match(/^[a-f0-9]{64}i\d+$/) !== null;
+}
+function assert_inscription_id(inscription_id) {
+    if (!verify_inscription_id(inscription_id)) {
+        throw new Error(`invalid inscription id: ${inscription_id}`);
     }
-    get version() {
-        return this._meta.version;
+}
+function encode_rune_id(block_height, block_index) {
+    return `${block_height}:${block_index}`;
+}
+function decode_rune_id(rune_id) {
+    assert_rune_id(rune_id);
+    const [block_height, block_index] = rune_id.split(':');
+    return { block_height: parseInt(block_height), block_index: parseInt(block_index) };
+}
+function verify_rune_id(rune_id) {
+    return rune_id.match(/^\d+:\d+$/) !== null;
+}
+function assert_rune_id(rune_id) {
+    if (!verify_rune_id(rune_id)) {
+        throw new Error(`invalid rune id: ${rune_id}`);
     }
-    get vsize() {
-        return this._size.vsize;
+}
+function encode_outpoint(txid, vout) {
+    return `${txid}:${vout}`;
+}
+function decode_outpoint(outpoint) {
+    assert_outpoint(outpoint);
+    const [txid, vout] = outpoint.split(':');
+    return { txid, vout: parseInt(vout) };
+}
+function verify_outpoint(outpoint) {
+    return outpoint.match(/^[a-f0-9]{64}:[0-9]+$/) !== null;
+}
+function assert_outpoint(outpoint) {
+    if (!verify_outpoint(outpoint)) {
+        throw new Error(`invalid outpoint: ${outpoint}`);
     }
-    toJSON() { return this.data; }
-    toString() { return JSON.stringify(this.data); }
 }
 
-class TransactionInput {
-    constructor(txin) {
-        this._size = get_txin_size(txin);
-        this._txin = txin;
-        this._witness = txin.witness.length > 0
-            ? new TransactionWitness(txin.witness)
-            : null;
-    }
-    get coinbase() {
-        return this._txin.coinbase;
-    }
-    get data() {
-        return {
-            coinbase: this.coinbase,
-            prevout: this.prevout?.data ?? null,
-            script_sig: this.script_sig,
-            sequence: this.sequence,
-            size: this.size,
-            txid: this.txid,
-            vout: this.vout,
-            witness: this.witness?.data ?? null
-        };
-    }
-    get has_prevout() {
-        return this._txin.prevout !== null;
+const _0n = BigInt(0);
+const _1n = BigInt(1);
+const _26n = BigInt(26);
+var ScribeEncoder;
+(function (ScribeEncoder) {
+    ScribeEncoder.encode = encode_inscription;
+    ScribeEncoder.decode = decode_inscription;
+})(ScribeEncoder || (ScribeEncoder = {}));
+function decode_inscription(script) {
+    const envelopes = parse_envelopes(script);
+    return envelopes.map(parse_record);
+}
+function encode_inscription(data) {
+    return data.map(create_envelope).join('');
+}
+function create_envelope(data) {
+    let asm = ['OP_0', 'OP_IF', '6f7264'];
+    if (typeof data.delegate === 'string') {
+        const id = encode_id(data.delegate);
+        asm.push('OP_11', id);
     }
-    get is_coinbase() {
-        return this._txin.coinbase !== null;
+    if (typeof data.ref === 'string') {
+        asm.push('OP_WITHIN', data.ref);
     }
-    get prevout() {
-        return this._txin.prevout
-            ? new TransactionOutput(this._txin.prevout)
-            : null;
+    if (typeof data.parent === 'string') {
+        const id = encode_id(data.parent);
+        asm.push('OP_3', id);
     }
-    get script_sig() {
-        if (this._txin.script_sig === null)
-            return null;
-        return {
-            asm: decode_script(this._txin.script_sig),
-            hex: this._txin.script_sig
-        };
+    if (typeof data.opcode === 'number') {
+        const code = encode_pointer(data.opcode);
+        asm.push('OP_NOP', code);
     }
-    get sequence() {
-        return {
-            hex: encode_txin_sequence(this._txin.sequence).hex,
-            data: Sequence.decode(this._txin.sequence),
-            value: this._txin.sequence
-        };
+    if (typeof data.pointer === 'number') {
+        const ptr = encode_pointer(data.pointer);
+        asm.push('OP_2', ptr);
     }
-    get size() {
-        return this._size;
+    if (typeof data.rune === 'string') {
+        const label = encode_rune_label(data.rune);
+        asm.push('OP_13', label);
     }
-    get txid() {
-        return this._txin.txid;
+    if (typeof data.mimetype === 'string') {
+        const label = encode_label(data.mimetype);
+        asm.push('OP_1', label);
     }
-    get vout() {
-        return this._txin.vout;
+    if (typeof data.content === 'string') {
+        const chunks = encode_content(data.content);
+        asm.push('OP_0', ...chunks);
     }
-    get witness() {
-        return this._witness;
+    asm.push('OP_ENDIF');
+    return encode_script(asm);
+}
+function parse_envelopes(script) {
+    const words = decode_script(script);
+    const start_idx = words.findIndex(e => e === 'OP_0');
+    Assert.ok(start_idx !== -1, 'inscription envelope not found');
+    const envelopes = [];
+    for (let idx = start_idx; idx < words.length; idx++) {
+        Assert.ok(words[idx + 1] === 'OP_IF', 'OP_IF missing from envelope');
+        Assert.ok(words[idx + 2] === '6f7264', 'magic bytes missing from envelope');
+        const stop_idx = words.findIndex(e => e === 'OP_ENDIF');
+        Assert.ok(stop_idx !== -1, 'inscription envelope missing END_IF statement');
+        const env = words.slice(idx + 3, stop_idx);
+        envelopes.push(env);
+        idx += stop_idx;
     }
-    toJSON() { return this.data; }
-    toString() { return JSON.stringify(this.data); }
+    return envelopes;
 }
-
-let Transaction$1 = class Transaction {
-    constructor(txdata) {
-        this._tx = (typeof txdata !== 'string')
-            ? parse_tx_data(txdata)
-            : decode_tx_data(txdata);
-        this._vin = this._tx.vin.map(txin => new TransactionInput(txin));
-        this._vout = this._tx.vout.map(txout => new TransactionOutput(txout));
-        this._size = get_txsize(this._tx);
-        this._hash = get_txhash(this._tx);
-        this._value = get_tx_value(this._tx);
+function parse_record(envelope) {
+    const record = {};
+    for (let i = 0; i < envelope.length; i++) {
+        switch (envelope[i]) {
+            case 'OP_1':
+                record.mimetype = decode_label(envelope[i + 1]);
+                i += 1;
+                break;
+            case 'OP_2':
+                record.pointer = decode_pointer(envelope[i + 1]);
+                i += 1;
+                break;
+            case 'OP_3':
+                record.parent = decode_id(envelope[i + 1]);
+                i += 1;
+                break;
+            case 'OP_11':
+                record.delegate = decode_id(envelope[i + 1]);
+                i += 1;
+                break;
+            case 'OP_13':
+                record.rune = decode_rune_label(envelope[i + 1]);
+                i += 1;
+                break;
+            case 'OP_WITHIN':
+                record.ref = envelope[i + 1];
+                i += 1;
+                break;
+            case 'OP_NOP':
+                record.opcode = decode_pointer(envelope[i + 1]);
+                i += 1;
+                break;
+            case 'OP_0':
+                record.content = decode_content(envelope.slice(i + 1));
+                return record;
+        }
     }
-    get data() {
-        return {
-            hash: this.hash,
-            locktime: this.locktime,
-            return: this.return,
-            size: this.size,
-            spends: this.spends,
-            txid: this.txid,
-            value: this.value,
-            version: this.version,
-            vin: this.vin.map(txin => txin.data),
-            vout: this.vout.map(txout => txout.data)
-        };
+    return record;
+}
+function encode_id(identifier) {
+    Assert.ok(identifier.includes('i'), 'identifier must include an index');
+    const parts = identifier.split('i');
+    const bytes = Buff.hex(parts[0]);
+    const idx = Number(parts[1]);
+    const txid = bytes.reverse().hex;
+    return (idx !== 0) ? txid + Buff.num(idx).hex : txid;
+}
+function decode_id(hexstr) {
+    const bytes = Buff.hex(hexstr);
+    const idx = bytes.at(-1) ?? 0;
+    const txid = bytes.slice(0, -1).reverse().hex;
+    return txid + 'i' + String(idx);
+}
+function encode_pointer(pointer) {
+    return Buff.num(pointer).reverse().hex;
+}
+function decode_pointer(hexstr) {
+    return Buff.hex(hexstr).reverse().num;
+}
+function encode_label(label) {
+    return Buff.str(label).hex;
+}
+function decode_label(hexstr) {
+    return Buff.hex(hexstr).str;
+}
+function encode_content(content) {
+    const bytes = Buff.is_hex(content)
+        ? Buff.hex(content)
+        : Buff.str(content);
+    const stream = new Stream(bytes);
+    const chunks = [];
+    while (stream.size > 0) {
+        if (stream.size > 520) {
+            const chunk = stream.read(520);
+            chunks.push(chunk.hex);
+        }
+        else {
+            const chunk = stream.read(stream.size);
+            chunks.push(chunk.hex);
+        }
     }
-    get hash() {
-        return this._hash;
+    return chunks;
+}
+function decode_content(hexstrs, type = 'hex') {
+    const data = Buff.join(hexstrs);
+    return (type === 'hex')
+        ? data.hex
+        : data.str;
+}
+function encode_rune_label(label) {
+    const str = label.toUpperCase();
+    let big = _0n;
+    for (const char of str) {
+        if (char >= 'A' && char <= 'Z') {
+            big = big * _26n + BigInt(char.charCodeAt(0) - ('A'.charCodeAt(0) - 1));
+        }
+        else {
+            continue;
+        }
     }
-    get locktime() {
+    big = big - _1n;
+    return Buff.big(big).reverse().hex;
+}
+function decode_rune_label(hex) {
+    let big = Buff.hex(hex).reverse().big;
+    big = big + _1n;
+    let result = '';
+    while (big > _0n) {
+        const mod = big % _26n;
+        if (mod === _0n) {
+            result = 'Z' + result;
+            big = big / _26n - _1n;
+        }
+        else {
+            const charCode = Number(mod) + 'A'.charCodeAt(0) - 1;
+            result = String.fromCharCode(charCode) + result;
+            big = big / _26n;
+        }
+    }
+    return result;
+}
+
+const TIMELOCK_DISABLE = 0x80000000;
+const TIMELOCK_TYPE = 0x00400000;
+const TIMELOCK_VALUE_MASK = 0x0000FFFF;
+const TIMELOCK_VALUE_MAX = 0xFFFF;
+const TIMELOCK_GRANULARITY = 512;
+var SequenceUtil;
+(function (SequenceUtil) {
+    SequenceUtil.encode = encode_sequence;
+    SequenceUtil.decode = decode_sequence;
+})(SequenceUtil || (SequenceUtil = {}));
+function encode_sequence(data) {
+    if (data.mode === 'height') {
+        const height = parse_height(data.height);
+        return (height & TIMELOCK_VALUE_MASK) >>> 0;
+    }
+    if (data.mode === 'stamp') {
+        const stamp = parse_stamp(data.stamp);
+        return (TIMELOCK_TYPE | (stamp & TIMELOCK_VALUE_MASK)) >>> 0;
+    }
+    throw new Error('invalid timelock mode: ' + data.mode);
+}
+function decode_sequence(sequence) {
+    const seq = parse_sequence(sequence);
+    if (seq & TIMELOCK_DISABLE)
+        return null;
+    const value = seq & TIMELOCK_VALUE_MASK;
+    if (seq & TIMELOCK_TYPE) {
+        const stamp = value * TIMELOCK_GRANULARITY;
+        if (stamp > 0xFFFFFFFF) {
+            throw new Error('Decoded timestamp exceeds 32-bit limit');
+        }
+        return { mode: 'stamp', stamp };
+    }
+    else {
+        if (value > TIMELOCK_VALUE_MAX) {
+            throw new Error('Decoded height exceeds maximum');
+        }
+        return { mode: 'height', height: value };
+    }
+}
+function parse_sequence(sequence) {
+    const seq = (typeof sequence === 'string')
+        ? parseInt(sequence, 16)
+        : sequence;
+    if (!Number.isInteger(seq) || seq < 0 || seq > 0xFFFFFFFF) {
+        throw new Error(`invalid sequence value: ${seq}`);
+    }
+    return seq;
+}
+function parse_stamp(stamp) {
+    if (stamp === undefined || !Number.isInteger(stamp)) {
+        throw new Error(`timestamp must be a number`);
+    }
+    const ts = Math.floor(stamp / TIMELOCK_GRANULARITY);
+    if (!Number.isInteger(ts) || ts < 0 || ts > TIMELOCK_VALUE_MAX) {
+        throw new Error(`timelock value must be an integer between 0 and ${TIMELOCK_VALUE_MAX} (in 512-second increments)`);
+    }
+    return ts;
+}
+function parse_height(height) {
+    if (height === undefined || !Number.isInteger(height) || height < 0 || height > TIMELOCK_VALUE_MAX) {
+        throw new Error(`Heightlock value must be an integer between 0 and ${TIMELOCK_VALUE_MAX}`);
+    }
+    return height;
+}
+
+var index$6 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    get LocktimeUtil () { return LocktimeUtil; },
+    get RefEncoder () { return RefEncoder; },
+    get ScribeEncoder () { return ScribeEncoder; },
+    get SequenceUtil () { return SequenceUtil; },
+    decode_inscription: decode_inscription,
+    decode_locktime: decode_locktime,
+    decode_sequence: decode_sequence,
+    encode_inscription: encode_inscription,
+    encode_locktime: encode_locktime,
+    encode_sequence: encode_sequence
+});
+
+class TransactionOutput {
+    constructor(txout) {
+        this._info = get_vout_info(txout);
+        this._size = get_txout_size(txout);
+        this._txout = txout;
+    }
+    get data() {
         return {
-            hex: encode_tx_locktime(this._tx.locktime).hex,
-            data: Locktime.decode(this._tx.locktime),
-            value: this._tx.locktime
+            script_pk: this.script_pk,
+            size: this.size,
+            type: this.type,
+            value: this.value,
+            version: this.version
         };
     }
-    get return() {
-        return this._tx.vout.find(txout => is_return_script(txout.script_pk)) || null;
-    }
-    get size() {
+    get script_pk() {
         return {
-            ...this._size,
-            segwit: this._vin.reduce((acc, txin) => acc + (txin.witness?.vsize ?? 0), 0),
-            vin: this._vin.reduce((acc, txin) => acc + txin.size, 0),
-            vout: this._vout.reduce((acc, txout) => acc + txout.size, 0),
-            witness: this._vin.reduce((acc, txin) => acc + (txin.witness?.size ?? 0), 0)
+            hex: this._txout.script_pk,
+            asm: decode_script(this._txout.script_pk)
         };
     }
-    get spends() {
-        return this._tx.vin
-            .filter(txin => txin.prevout !== null)
-            .map(txin => new TransactionOutput(txin.prevout));
+    get size() {
+        return this._size;
     }
-    get txid() {
-        return get_txid(this._tx);
+    get type() {
+        return this._info.type;
     }
     get value() {
-        return this._value;
+        return this._txout.value;
     }
     get version() {
-        return this._tx.version;
-    }
-    get vin() {
-        return this._vin;
-    }
-    get vout() {
-        return this._vout;
+        return this._info.version;
     }
     toJSON() { return this.data; }
     toString() { return JSON.stringify(this.data); }
-};
-
-const ENCODING_REGEX = {
-    base58: /^[13mn2][a-km-zA-HJ-NP-Z1-9]{25,34}$/,
-    bech32: /^(bc|tb|bcrt)1q[ac-hj-np-z02-9]{6,87}$/,
-    bech32m: /^(bc|tb|bcrt)1p[ac-hj-np-z02-9]{6,87}$/
-};
-const VERSION = {
-    bech32: 0,
-    bech32m: 1
-};
-function decode_address(address) {
-    const format = get_address_format(address);
-    if (format === null)
-        throw new Error('unrecognized address format: ' + format);
-    if (format === 'base58')
-        return base58_decode(address);
-    if (format === 'bech32')
-        return bech32_decode(address);
-    if (format === 'bech32m')
-        return bech32m_decode(address);
-    throw new Error('unable to find a matching address configuration');
-}
-function encode_address(config) {
-    if (config.format === 'base58')
-        return base58_encode(config);
-    if (config.format === 'bech32')
-        return bech32_encode(config);
-    if (config.format === 'bech32m')
-        return bech32m_encode(config);
-    throw new Error('unrecognized encoding format: ' + config.format);
 }
-function get_address_format(address) {
-    for (const [format, regex] of Object.entries(ENCODING_REGEX)) {
-        if (regex.test(address))
-            return format;
-    }
-    return null;
+
+function parse_witness_data(witness) {
+    const elems = witness.map(e => Buff.bytes(e));
+    const annex = parse_annex_data(elems);
+    if (annex !== null)
+        elems.pop();
+    const cblock = parse_cblock_data(elems);
+    if (cblock !== null)
+        elems.pop();
+    const type = parse_witness_type(elems, cblock);
+    const version = parse_witness_version(type);
+    const script = parse_witness_script(elems, type);
+    if (script !== null)
+        elems.pop();
+    const params = elems.map(e => e.hex);
+    return { annex, cblock, params, script, type, version };
 }
-function base58_encode(config) {
-    Assert.ok(config.format === 'base58', 'encoding mismatch');
-    Assert.exists(config.version, 'must specify a version');
-    const bytes = Buff.join([config.version, config.data]);
-    return B58chk.encode(bytes);
-}
-function base58_decode(encoded) {
-    const bytes = B58chk.decode(encoded);
-    const data = bytes.slice(1);
-    const version = bytes[0];
-    return { data, format: 'base58', version };
-}
-function bech32_encode(config) {
-    Assert.ok(config.format === 'bech32', 'encoding mismatch');
-    Assert.exists(config.prefix, 'prefix is required');
-    const bytes = Buff.bytes(config.data);
-    const words = Bech32.to_words(bytes);
-    return Bech32.encode(config.prefix, [VERSION.bech32, ...words]);
-}
-function bech32_decode(encoded) {
-    const { prefix, words } = Bech32.decode(encoded);
-    const [version, ...rest] = words;
-    Assert.ok(version === VERSION.bech32, 'bech32 version mismatch');
-    const data = Bech32.to_bytes(rest);
-    return { data, format: 'bech32', prefix, version };
-}
-function bech32m_encode(config) {
-    Assert.ok(config.format === 'bech32m', 'encoding mismatch');
-    Assert.exists(config.prefix, 'prefix is required');
-    const bytes = Buff.bytes(config.data);
-    const words = Bech32m.to_words(bytes);
-    return Bech32m.encode(config.prefix, [VERSION.bech32m, ...words]);
+function parse_annex_data(data) {
+    let elem = data.at(-1);
+    if (data.length > 1 &&
+        elem instanceof Uint8Array &&
+        elem[0] === 0x50) {
+        return new Buff(elem).hex;
+    }
+    else {
+        return null;
+    }
 }
-function bech32m_decode(encoded) {
-    const { prefix, words } = Bech32m.decode(encoded);
-    const [version, ...rest] = words;
-    Assert.ok(version === VERSION.bech32m, 'bech32m version mismatch');
-    const data = Bech32m.to_bytes(rest);
-    return { data, format: 'bech32m', prefix, version };
+function parse_cblock_data(data) {
+    let elem = data.at(-1);
+    if (data.length > 1 &&
+        elem instanceof Uint8Array &&
+        elem.length > 32 &&
+        TAPLEAF_VERSIONS.includes(elem[0] & 0xfe)) {
+        return new Buff(elem).hex;
+    }
+    else {
+        return null;
+    }
 }
-
-function get_address_script(script_key, script_type) {
-    switch (script_type) {
-        case 'p2pkh':
-            return get_p2pkh_script(script_key);
-        case 'p2sh':
-            return get_p2sh_script(script_key);
-        case 'p2w-pkh':
-            return get_p2w_pkh_script(script_key);
+function parse_witness_script(elems, type) {
+    let script;
+    switch (type) {
+        case 'p2tr-ts':
+            script = elems.at(-1);
         case 'p2w-sh':
-            return get_p2w_sh_script(script_key);
-        case 'p2tr':
-            return get_p2tr_script(script_key);
-        default:
-            throw new Error('unrecognized script type: ' + script_type);
+            script = elems.at(-1);
     }
+    return (script !== undefined) ? new Buff(script).hex : null;
 }
-function get_p2pkh_script(script_key) {
-    return {
-        script_hex: '76a914' + script_key + '88ac',
-        script_asm: ['OP_DUP', 'OP_HASH160', script_key, 'OP_EQUALVERIFY', 'OP_CHECKSIG']
-    };
-}
-function get_p2sh_script(script_key) {
-    return {
-        script_hex: 'a914' + script_key + '87',
-        script_asm: ['OP_HASH160', script_key, 'OP_EQUAL']
-    };
-}
-function get_p2w_pkh_script(script_key) {
-    return {
-        script_hex: '0014' + script_key,
-        script_asm: ['OP_0', script_key]
-    };
-}
-function get_p2w_sh_script(script_key) {
-    return {
-        script_hex: '0020' + script_key,
-        script_asm: ['OP_0', script_key]
-    };
-}
-function get_p2tr_script(script_key) {
-    return {
-        script_hex: '5120' + script_key,
-        script_asm: ['OP_1', script_key]
-    };
-}
-
-const CONFIG_TABLE = [
-    ['1', 'p2pkh', 'main', 20, 'base58', 0x00],
-    ['3', 'p2sh', 'main', 20, 'base58', 0x05],
-    ['m', 'p2pkh', 'testnet', 20, 'base58', 0x6F],
-    ['n', 'p2pkh', 'testnet', 20, 'base58', 0x6F],
-    ['2', 'p2sh', 'testnet', 20, 'base58', 0xC4],
-    ['m', 'p2pkh', 'regtest', 20, 'base58', 0x6F],
-    ['n', 'p2pkh', 'regtest', 20, 'base58', 0x6F],
-    ['2', 'p2sh', 'regtest', 20, 'base58', 0xC4],
-    ['bc', 'p2w-pkh', 'main', 20, 'bech32', 0],
-    ['tb', 'p2w-pkh', 'testnet', 20, 'bech32', 0],
-    ['bcrt', 'p2w-pkh', 'regtest', 20, 'bech32', 0],
-    ['bc', 'p2w-sh', 'main', 32, 'bech32', 0],
-    ['tb', 'p2w-sh', 'testnet', 32, 'bech32', 0],
-    ['bcrt', 'p2w-sh', 'regtest', 32, 'bech32', 0],
-    ['bc', 'p2tr', 'main', 32, 'bech32m', 1],
-    ['tb', 'p2tr', 'testnet', 32, 'bech32m', 1],
-    ['bcrt', 'p2tr', 'regtest', 32, 'bech32m', 1]
-];
-function get_address_config(address_network, address_type) {
-    for (const [prefix, type, network, size, format, version] of CONFIG_TABLE) {
-        if (type === address_type && network === address_network) {
-            return { type, prefix, network, size, format, version };
-        }
+function parse_witness_type(elems, cblock) {
+    let param_0 = elems.at(0), param_1 = elems.at(1), param_x = elems.at(-1);
+    if (cblock !== null && param_x !== undefined) {
+        return 'p2tr-ts';
     }
-    return null;
-}
-function get_address_ctx(address) {
-    const dec = decode_address(address);
-    for (const [prefix, type, network, size, format, version] of CONFIG_TABLE) {
-        if (format !== dec.format)
-            continue;
-        if (size !== dec.data.length)
-            continue;
-        if (version !== dec.version)
-            continue;
-        if (dec.prefix) {
-            if (prefix !== dec.prefix)
-                continue;
-        }
-        else {
-            if (!address.startsWith(prefix))
-                continue;
-        }
-        const hex = Buff.uint(dec.data).hex;
-        return { data: dec.data, hex, type, prefix, network, size, format, version };
+    else if (elems.length === 2 &&
+        param_0 !== undefined &&
+        param_1 !== undefined &&
+        param_0.length >= 64 &&
+        param_1.length === 33) {
+        return 'p2w-pkh';
+    }
+    else if (elems.length === 1 &&
+        param_0 !== undefined &&
+        param_0.length === 64) {
+        return 'p2tr-pk';
+    }
+    else if (elems.length > 1 &&
+        param_x !== undefined &&
+        is_valid_script(param_x)) {
+        return 'p2w-sh';
+    }
+    else {
+        return 'unknown';
     }
-    throw new Error('address configuration is invalid');
 }
-function parse_address(address) {
-    const ctx = get_address_ctx(address);
-    const script = get_address_script(ctx.hex, ctx.type);
-    return { ...ctx, ...script };
+function parse_witness_version(type) {
+    if (type.startsWith('p2tr'))
+        return 1;
+    if (type.startsWith('p2w'))
+        return 0;
+    return null;
 }
 
-const ADDR_TYPE$4 = 'p2pkh';
-var P2PKH;
-(function (P2PKH) {
-    P2PKH.create = create_p2pkh_address;
-    P2PKH.encode = encode_p2pkh_address;
-    P2PKH.decode = decode_p2pkh_address;
-})(P2PKH || (P2PKH = {}));
-function create_p2pkh_address(script, network = 'main') {
-    const bytes = Buff.bytes(script);
-    const hash = hash160$1(bytes);
-    return encode_p2pkh_address(hash, network);
-}
-function encode_p2pkh_address(pk_hash, network = 'main') {
-    const bytes = Buff.bytes(pk_hash);
-    const config = get_address_config(network, ADDR_TYPE$4);
-    Assert.exists(config, `unrecognized address config: ${ADDR_TYPE$4} on ${network}`);
-    Assert.size(bytes, config.size, `invalid payload size: ${bytes.length} !== ${config.size}`);
-    return encode_address({
-        data: bytes,
-        format: 'base58',
-        version: config.version
-    });
-}
-function decode_p2pkh_address(address) {
-    const parsed = parse_address(address);
-    Assert.ok(parsed.type === 'p2pkh', `address type mismatch: ${parsed.type} !== ${ADDR_TYPE$4}`);
-    return parsed;
+const WIT_LENGTH_BYTE = 1;
+function get_witness_size(witness) {
+    const stack = witness.map(e => Buff.bytes(e));
+    const size = stack.reduce((prev, next) => prev + next.length, 0);
+    const vsize = Math.ceil(WIT_LENGTH_BYTE + size / 4);
+    return { size, vsize };
 }
 
-const ADDR_TYPE$3 = 'p2sh';
-var P2SH;
-(function (P2SH) {
-    P2SH.create = create_p2sh_address;
-    P2SH.encode = encode_p2sh_address;
-    P2SH.decode = decode_p2sh_address;
-})(P2SH || (P2SH = {}));
-function create_p2sh_address(script, network = 'main') {
-    const bytes = Buff.bytes(script);
-    const hash = hash160$1(bytes);
-    return encode_p2sh_address(hash, network);
-}
-function encode_p2sh_address(script_hash, network = 'main') {
-    const bytes = Buff.bytes(script_hash);
-    const config = get_address_config(network, ADDR_TYPE$3);
-    Assert.exists(config, `unrecognized address config: ${ADDR_TYPE$3} on ${network}`);
-    Assert.size(bytes, config.size, `invalid payload size: ${bytes.length} !== ${config.size}`);
-    return encode_address({
-        data: bytes,
-        format: 'base58',
-        version: config.version
-    });
-}
-function decode_p2sh_address(address) {
-    const parsed = parse_address(address);
-    Assert.ok(parsed.type === 'p2sh', `address type mismatch: ${parsed.type} !== ${ADDR_TYPE$3}`);
-    return parsed;
-}
+var index$5 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    get_witness_size: get_witness_size,
+    parse_witness_data: parse_witness_data
+});
 
-const ADDR_TYPE$2 = 'p2w-pkh';
-var P2WPKH;
-(function (P2WPKH) {
-    P2WPKH.create = create_p2wpkh_address;
-    P2WPKH.encode = encode_p2wpkh_address;
-    P2WPKH.decode = decode_p2wpkh_address;
-})(P2WPKH || (P2WPKH = {}));
-function create_p2wpkh_address(pubkey, network = 'main') {
-    const bytes = Buff.bytes(pubkey);
-    Assert.size(bytes, 33, `invalid payload size: ${bytes.length} !== 33`);
-    const hash = hash160$1(bytes);
-    return encode_p2wpkh_address(hash, network);
-}
-function encode_p2wpkh_address(pk_hash, network = 'main') {
-    const bytes = Buff.bytes(pk_hash);
-    const config = get_address_config(network, ADDR_TYPE$2);
-    Assert.exists(config, `unrecognized address config: ${ADDR_TYPE$2} on ${network}`);
-    Assert.size(bytes, config.size, `invalid payload size: ${bytes.length} !== ${config.size}`);
-    return encode_address({
-        data: bytes,
-        format: 'bech32',
-        prefix: config.prefix
-    });
-}
-function decode_p2wpkh_address(address) {
-    const parsed = parse_address(address);
-    Assert.ok(parsed.type === 'p2w-pkh', `address type mismatch: ${parsed.type} !== ${ADDR_TYPE$2}`);
-    return parsed;
-}
-
-const ADDR_TYPE$1 = 'p2w-sh';
-var P2WSH;
-(function (P2WSH) {
-    P2WSH.create = create_p2wsh_address;
-    P2WSH.encode = encode_p2wsh_address;
-    P2WSH.decode = decode_p2wsh_address;
-})(P2WSH || (P2WSH = {}));
-function create_p2wsh_address(script, network = 'main') {
-    const bytes = Buff.bytes(script);
-    const hash = sha256(bytes);
-    return encode_p2wsh_address(hash, network);
-}
-function encode_p2wsh_address(script_hash, network = 'main') {
-    const bytes = Buff.bytes(script_hash);
-    const config = get_address_config(network, ADDR_TYPE$1);
-    Assert.exists(config, `unrecognized address config: ${ADDR_TYPE$1} on ${network}`);
-    Assert.size(bytes, config.size, `invalid payload size: ${bytes.length} !== ${config.size}`);
-    return encode_address({
-        data: bytes,
-        format: 'bech32',
-        prefix: config.prefix
-    });
-}
-function decode_p2wsh_address(address) {
-    const parsed = parse_address(address);
-    Assert.ok(parsed.type === 'p2w-sh', `address type mismatch: ${parsed.type} !== ${ADDR_TYPE$1}`);
-    return parsed;
+class TransactionWitness {
+    constructor(witness) {
+        this._data = witness.map(e => Buff.bytes(e));
+        this._meta = parse_witness_data(witness);
+        this._size = get_witness_size(witness);
+    }
+    get annex() {
+        return this._meta.annex;
+    }
+    get cblock() {
+        return this._meta.cblock;
+    }
+    get data() {
+        return {
+            annex: this.annex,
+            cblock: this.cblock,
+            params: this.params,
+            script: this.script,
+            size: this.size,
+            stack: this.stack,
+            type: this.type,
+            version: this.version,
+            vsize: this.vsize
+        };
+    }
+    get params() {
+        return this._meta.params;
+    }
+    get script() {
+        if (this._meta.script === null)
+            return null;
+        return {
+            hex: this._meta.script,
+            asm: decode_script(this._meta.script)
+        };
+    }
+    get size() {
+        return this._size.size;
+    }
+    get stack() {
+        return this._data.map(e => e.hex);
+    }
+    get type() {
+        return this._meta.type;
+    }
+    get version() {
+        return this._meta.version;
+    }
+    get vsize() {
+        return this._size.vsize;
+    }
+    toJSON() { return this.data; }
+    toString() { return JSON.stringify(this.data); }
 }
 
-const ADDR_TYPE = 'p2tr';
-var P2TR;
-(function (P2TR) {
-    P2TR.encode = encode_p2tr_address;
-    P2TR.decode = decode_p2tr_address;
-})(P2TR || (P2TR = {}));
-function encode_p2tr_address(pubkey, network = 'main') {
-    const bytes = Buff.bytes(pubkey);
-    const config = get_address_config(network, ADDR_TYPE);
-    Assert.exists(config, `unrecognized address config: ${ADDR_TYPE} on ${network}`);
-    Assert.size(bytes, config.size, `invalid payload size: ${bytes.length} !== ${config.size}`);
-    return encode_address({
-        data: bytes,
-        format: 'bech32m',
-        prefix: config.prefix
-    });
-}
-function decode_p2tr_address(address) {
-    const parsed = parse_address(address);
-    Assert.ok(parsed.type === 'p2tr', `address type mismatch: ${parsed.type} !== ${ADDR_TYPE}`);
-    return parsed;
+class TransactionInput {
+    constructor(txin) {
+        this._size = get_txin_size(txin);
+        this._txin = txin;
+        this._witness = txin.witness.length > 0
+            ? new TransactionWitness(txin.witness)
+            : null;
+    }
+    get coinbase() {
+        return this._txin.coinbase;
+    }
+    get data() {
+        return {
+            coinbase: this.coinbase,
+            prevout: this.prevout?.data ?? null,
+            script_sig: this.script_sig,
+            sequence: this.sequence,
+            size: this.size,
+            txid: this.txid,
+            vout: this.vout,
+            witness: this.witness?.data ?? null
+        };
+    }
+    get has_prevout() {
+        return this._txin.prevout !== null;
+    }
+    get is_coinbase() {
+        return this._txin.coinbase !== null;
+    }
+    get prevout() {
+        return this._txin.prevout
+            ? new TransactionOutput(this._txin.prevout)
+            : null;
+    }
+    get script_sig() {
+        if (this._txin.script_sig === null)
+            return null;
+        return {
+            asm: decode_script(this._txin.script_sig),
+            hex: this._txin.script_sig
+        };
+    }
+    get sequence() {
+        return {
+            hex: encode_txin_sequence(this._txin.sequence).hex,
+            data: SequenceUtil.decode(this._txin.sequence),
+            value: this._txin.sequence
+        };
+    }
+    get size() {
+        return this._size;
+    }
+    get txid() {
+        return this._txin.txid;
+    }
+    get vout() {
+        return this._txin.vout;
+    }
+    get witness() {
+        return this._witness;
+    }
+    toJSON() { return this.data; }
+    toString() { return JSON.stringify(this.data); }
 }
 
-var AddressTool;
-(function (AddressTool) {
-    AddressTool.P2PKH = P2PKH;
-    AddressTool.P2SH = P2SH;
-    AddressTool.P2WPKH = P2WPKH;
-    AddressTool.P2WSH = P2WSH;
-    AddressTool.P2TR = P2TR;
-    AddressTool.parse = parse_address;
-})(AddressTool || (AddressTool = {}));
-
-var index$4 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    get AddressTool () { return AddressTool; },
-    get P2PKH () { return P2PKH; },
-    get P2SH () { return P2SH; },
-    get P2TR () { return P2TR; },
-    get P2WPKH () { return P2WPKH; },
-    get P2WSH () { return P2WSH; },
-    parse_address: parse_address
-});
+let Transaction$1 = class Transaction {
+    constructor(txdata) {
+        this._tx = (typeof txdata !== 'string')
+            ? parse_tx(txdata)
+            : decode_tx(txdata);
+        this._vin = this._tx.vin.map(txin => new TransactionInput(txin));
+        this._vout = this._tx.vout.map(txout => new TransactionOutput(txout));
+        this._size = get_txsize(this._tx);
+        this._hash = get_txhash(this._tx);
+        this._value = get_tx_value(this._tx);
+    }
+    get data() {
+        return {
+            hash: this.hash,
+            locktime: this.locktime,
+            return: this.return,
+            size: this.size,
+            spends: this.spends,
+            txid: this.txid,
+            value: this.value,
+            version: this.version,
+            vin: this.vin.map(txin => txin.data),
+            vout: this.vout.map(txout => txout.data)
+        };
+    }
+    get hash() {
+        return this._hash;
+    }
+    get locktime() {
+        return {
+            hex: encode_tx_locktime(this._tx.locktime).hex,
+            data: LocktimeUtil.decode(this._tx.locktime),
+            value: this._tx.locktime
+        };
+    }
+    get return() {
+        return this._tx.vout.find(txout => is_return_script(txout.script_pk)) || null;
+    }
+    get size() {
+        return {
+            ...this._size,
+            segwit: this._vin.reduce((acc, txin) => acc + (txin.witness?.vsize ?? 0), 0),
+            vin: this._vin.reduce((acc, txin) => acc + txin.size, 0),
+            vout: this._vout.reduce((acc, txout) => acc + txout.size, 0),
+            witness: this._vin.reduce((acc, txin) => acc + (txin.witness?.size ?? 0), 0)
+        };
+    }
+    get spends() {
+        return this._tx.vin
+            .filter(txin => txin.prevout !== null)
+            .map(txin => new TransactionOutput(txin.prevout));
+    }
+    get txid() {
+        return get_txid(this._tx);
+    }
+    get value() {
+        return this._value;
+    }
+    get version() {
+        return this._tx.version;
+    }
+    get vin() {
+        return this._vin;
+    }
+    get vout() {
+        return this._vout;
+    }
+    toJSON() { return this.data; }
+    toString() { return JSON.stringify(this.data); }
+};
 
-var TxPointer;
-(function (TxPointer) {
-    TxPointer.outpoint = {
-        encode: encode_outpoint,
-        decode: decode_outpoint,
-        verify: verify_outpoint,
-        assert: assert_outpoint,
-    };
-    TxPointer.record_id = {
-        encode: encode_inscription_id,
-        decode: decode_inscription_id,
-        verify: verify_inscription_id,
-        assert: assert_inscription_id,
-    };
-    TxPointer.rune_id = {
-        encode: encode_rune_id,
-        decode: decode_rune_id,
-        verify: verify_rune_id,
-        assert: assert_rune_id,
-    };
-})(TxPointer || (TxPointer = {}));
-function encode_inscription_id(txid, order = 0) {
-    return `${txid}i${order}`;
-}
-function decode_inscription_id(inscription_id) {
-    assert_inscription_id(inscription_id);
-    const [txid, order] = inscription_id.split('i');
-    return { txid, order: parseInt(order) };
+const ENCODING_REGEX = {
+    base58: /^[13mn2][a-km-zA-HJ-NP-Z1-9]{25,34}$/,
+    bech32: /^(bc|tb|bcrt)1q[ac-hj-np-z02-9]{6,87}$/,
+    bech32m: /^(bc|tb|bcrt)1p[ac-hj-np-z02-9]{6,87}$/
+};
+const VERSION = {
+    bech32: 0,
+    bech32m: 1
+};
+function decode_address(address) {
+    const format = get_address_format(address);
+    if (format === null)
+        throw new Error('unrecognized address format: ' + format);
+    if (format === 'base58')
+        return base58_decode(address);
+    if (format === 'bech32')
+        return bech32_decode(address);
+    if (format === 'bech32m')
+        return bech32m_decode(address);
+    throw new Error('unable to find a matching address configuration');
 }
-function verify_inscription_id(inscription_id) {
-    return inscription_id.match(/^[a-f0-9]{64}i\d+$/) !== null;
+function encode_address(config) {
+    if (config.format === 'base58')
+        return base58_encode(config);
+    if (config.format === 'bech32')
+        return bech32_encode(config);
+    if (config.format === 'bech32m')
+        return bech32m_encode(config);
+    throw new Error('unrecognized encoding format: ' + config.format);
 }
-function assert_inscription_id(inscription_id) {
-    if (!verify_inscription_id(inscription_id)) {
-        throw new Error(`invalid inscription id: ${inscription_id}`);
+function get_address_format(address) {
+    for (const [format, regex] of Object.entries(ENCODING_REGEX)) {
+        if (regex.test(address))
+            return format;
     }
+    return null;
 }
-function encode_rune_id(block_height, block_index) {
-    return `${block_height}:${block_index}`;
-}
-function decode_rune_id(rune_id) {
-    assert_rune_id(rune_id);
-    const [block_height, block_index] = rune_id.split(':');
-    return { block_height: parseInt(block_height), block_index: parseInt(block_index) };
+function base58_encode(config) {
+    Assert.ok(config.format === 'base58', 'encoding mismatch');
+    Assert.exists(config.version, 'must specify a version');
+    const bytes = Buff.join([config.version, config.data]);
+    return B58chk.encode(bytes);
 }
-function verify_rune_id(rune_id) {
-    return rune_id.match(/^\d+:\d+$/) !== null;
+function base58_decode(encoded) {
+    const bytes = B58chk.decode(encoded);
+    const data = bytes.slice(1);
+    const version = bytes[0];
+    return { data, format: 'base58', version };
 }
-function assert_rune_id(rune_id) {
-    if (!verify_rune_id(rune_id)) {
-        throw new Error(`invalid rune id: ${rune_id}`);
-    }
+function bech32_encode(config) {
+    Assert.ok(config.format === 'bech32', 'encoding mismatch');
+    Assert.exists(config.prefix, 'prefix is required');
+    const bytes = Buff.bytes(config.data);
+    const words = Bech32.to_words(bytes);
+    return Bech32.encode(config.prefix, [VERSION.bech32, ...words]);
 }
-function encode_outpoint(txid, vout) {
-    return `${txid}:${vout}`;
+function bech32_decode(encoded) {
+    const { prefix, words } = Bech32.decode(encoded);
+    const [version, ...rest] = words;
+    Assert.ok(version === VERSION.bech32, 'bech32 version mismatch');
+    const data = Bech32.to_bytes(rest);
+    return { data, format: 'bech32', prefix, version };
 }
-function decode_outpoint(outpoint) {
-    assert_outpoint(outpoint);
-    const [txid, vout] = outpoint.split(':');
-    return { txid, vout: parseInt(vout) };
+function bech32m_encode(config) {
+    Assert.ok(config.format === 'bech32m', 'encoding mismatch');
+    Assert.exists(config.prefix, 'prefix is required');
+    const bytes = Buff.bytes(config.data);
+    const words = Bech32m.to_words(bytes);
+    return Bech32m.encode(config.prefix, [VERSION.bech32m, ...words]);
 }
-function verify_outpoint(outpoint) {
-    return outpoint.match(/^[a-f0-9]{64}:[0-9]+$/) !== null;
+function bech32m_decode(encoded) {
+    const { prefix, words } = Bech32m.decode(encoded);
+    const [version, ...rest] = words;
+    Assert.ok(version === VERSION.bech32m, 'bech32m version mismatch');
+    const data = Bech32m.to_bytes(rest);
+    return { data, format: 'bech32m', prefix, version };
 }
-function assert_outpoint(outpoint) {
-    if (!verify_outpoint(outpoint)) {
-        throw new Error(`invalid outpoint: ${outpoint}`);
+
+function get_address_script(script_key, script_type) {
+    switch (script_type) {
+        case 'p2pkh':
+            return get_p2pkh_script(script_key);
+        case 'p2sh':
+            return get_p2sh_script(script_key);
+        case 'p2w-pkh':
+            return get_p2w_pkh_script(script_key);
+        case 'p2w-sh':
+            return get_p2w_sh_script(script_key);
+        case 'p2tr':
+            return get_p2tr_script(script_key);
+        default:
+            throw new Error('unrecognized script type: ' + script_type);
     }
 }
-
-const _0n = BigInt(0);
-const _1n = BigInt(1);
-const _26n = BigInt(26);
-var Inscription;
-(function (Inscription) {
-    Inscription.encode = encode_inscription;
-    Inscription.decode = decode_inscription;
-})(Inscription || (Inscription = {}));
-function decode_inscription(script) {
-    const envelopes = parse_envelopes(script);
-    return envelopes.map(parse_record);
+function get_p2pkh_script(script_key) {
+    return {
+        script_hex: '76a914' + script_key + '88ac',
+        script_asm: ['OP_DUP', 'OP_HASH160', script_key, 'OP_EQUALVERIFY', 'OP_CHECKSIG']
+    };
 }
-function encode_inscription(data) {
-    return data.map(create_envelope).join('');
+function get_p2sh_script(script_key) {
+    return {
+        script_hex: 'a914' + script_key + '87',
+        script_asm: ['OP_HASH160', script_key, 'OP_EQUAL']
+    };
 }
-function create_envelope(data) {
-    let asm = ['OP_0', 'OP_IF', '6f7264'];
-    if (typeof data.delegate === 'string') {
-        const id = encode_id(data.delegate);
-        asm.push('OP_11', id);
-    }
-    if (typeof data.ref === 'string') {
-        asm.push('OP_WITHIN', data.ref);
-    }
-    if (typeof data.parent === 'string') {
-        const id = encode_id(data.parent);
-        asm.push('OP_3', id);
-    }
-    if (typeof data.opcode === 'number') {
-        const code = encode_pointer(data.opcode);
-        asm.push('OP_NOP', code);
-    }
-    if (typeof data.pointer === 'number') {
-        const ptr = encode_pointer(data.pointer);
-        asm.push('OP_2', ptr);
-    }
-    if (typeof data.rune === 'string') {
-        const label = encode_rune_label(data.rune);
-        asm.push('OP_13', label);
-    }
-    if (typeof data.mimetype === 'string') {
-        const label = encode_label(data.mimetype);
-        asm.push('OP_1', label);
-    }
-    if (typeof data.content === 'string') {
-        const chunks = encode_content(data.content);
-        asm.push('OP_0', ...chunks);
-    }
-    asm.push('OP_ENDIF');
-    return encode_script(asm);
+function get_p2w_pkh_script(script_key) {
+    return {
+        script_hex: '0014' + script_key,
+        script_asm: ['OP_0', script_key]
+    };
 }
-function parse_envelopes(script) {
-    const words = decode_script(script);
-    const start_idx = words.findIndex(e => e === 'OP_0');
-    Assert.ok(start_idx !== -1, 'inscription envelope not found');
-    const envelopes = [];
-    for (let idx = start_idx; idx < words.length; idx++) {
-        Assert.ok(words[idx + 1] === 'OP_IF', 'OP_IF missing from envelope');
-        Assert.ok(words[idx + 2] === '6f7264', 'magic bytes missing from envelope');
-        const stop_idx = words.findIndex(e => e === 'OP_ENDIF');
-        Assert.ok(stop_idx !== -1, 'inscription envelope missing END_IF statement');
-        const env = words.slice(idx + 3, stop_idx);
-        envelopes.push(env);
-        idx += stop_idx;
+function get_p2w_sh_script(script_key) {
+    return {
+        script_hex: '0020' + script_key,
+        script_asm: ['OP_0', script_key]
+    };
+}
+function get_p2tr_script(script_key) {
+    return {
+        script_hex: '5120' + script_key,
+        script_asm: ['OP_1', script_key]
+    };
+}
+
+const CONFIG_TABLE = [
+    ['1', 'p2pkh', 'main', 20, 'base58', 0x00],
+    ['3', 'p2sh', 'main', 20, 'base58', 0x05],
+    ['m', 'p2pkh', 'testnet', 20, 'base58', 0x6F],
+    ['n', 'p2pkh', 'testnet', 20, 'base58', 0x6F],
+    ['2', 'p2sh', 'testnet', 20, 'base58', 0xC4],
+    ['m', 'p2pkh', 'regtest', 20, 'base58', 0x6F],
+    ['n', 'p2pkh', 'regtest', 20, 'base58', 0x6F],
+    ['2', 'p2sh', 'regtest', 20, 'base58', 0xC4],
+    ['bc', 'p2w-pkh', 'main', 20, 'bech32', 0],
+    ['tb', 'p2w-pkh', 'testnet', 20, 'bech32', 0],
+    ['bcrt', 'p2w-pkh', 'regtest', 20, 'bech32', 0],
+    ['bc', 'p2w-sh', 'main', 32, 'bech32', 0],
+    ['tb', 'p2w-sh', 'testnet', 32, 'bech32', 0],
+    ['bcrt', 'p2w-sh', 'regtest', 32, 'bech32', 0],
+    ['bc', 'p2tr', 'main', 32, 'bech32m', 1],
+    ['tb', 'p2tr', 'testnet', 32, 'bech32m', 1],
+    ['bcrt', 'p2tr', 'regtest', 32, 'bech32m', 1]
+];
+function get_address_config(address_network, address_type) {
+    for (const [prefix, type, network, size, format, version] of CONFIG_TABLE) {
+        if (type === address_type && network === address_network) {
+            return { type, prefix, network, size, format, version };
+        }
     }
-    return envelopes;
+    return null;
 }
-function parse_record(envelope) {
-    const record = {};
-    for (let i = 0; i < envelope.length; i++) {
-        switch (envelope[i]) {
-            case 'OP_1':
-                record.mimetype = decode_label(envelope[i + 1]);
-                i += 1;
-                break;
-            case 'OP_2':
-                record.pointer = decode_pointer(envelope[i + 1]);
-                i += 1;
-                break;
-            case 'OP_3':
-                record.parent = decode_id(envelope[i + 1]);
-                i += 1;
-                break;
-            case 'OP_11':
-                record.delegate = decode_id(envelope[i + 1]);
-                i += 1;
-                break;
-            case 'OP_13':
-                record.rune = decode_rune_label(envelope[i + 1]);
-                i += 1;
-                break;
-            case 'OP_WITHIN':
-                record.ref = envelope[i + 1];
-                i += 1;
-                break;
-            case 'OP_NOP':
-                record.opcode = decode_pointer(envelope[i + 1]);
-                i += 1;
-                break;
-            case 'OP_0':
-                record.content = decode_content(envelope.slice(i + 1));
-                return record;
+function get_address_ctx(address) {
+    const dec = decode_address(address);
+    for (const [prefix, type, network, size, format, version] of CONFIG_TABLE) {
+        if (format !== dec.format)
+            continue;
+        if (size !== dec.data.length)
+            continue;
+        if (version !== dec.version)
+            continue;
+        if (dec.prefix) {
+            if (prefix !== dec.prefix)
+                continue;
         }
+        else {
+            if (!address.startsWith(prefix))
+                continue;
+        }
+        const hex = Buff.uint(dec.data).hex;
+        return { data: dec.data, hex, type, prefix, network, size, format, version };
     }
-    return record;
+    throw new Error('address configuration is invalid');
 }
-function encode_id(identifier) {
-    Assert.ok(identifier.includes('i'), 'identifier must include an index');
-    const parts = identifier.split('i');
-    const bytes = Buff.hex(parts[0]);
-    const idx = Number(parts[1]);
-    const txid = bytes.reverse().hex;
-    return (idx !== 0) ? txid + Buff.num(idx).hex : txid;
+function parse_address(address) {
+    const ctx = get_address_ctx(address);
+    const script = get_address_script(ctx.hex, ctx.type);
+    return { ...ctx, ...script };
 }
-function decode_id(hexstr) {
-    const bytes = Buff.hex(hexstr);
-    const idx = bytes.at(-1) ?? 0;
-    const txid = bytes.slice(0, -1).reverse().hex;
-    return txid + 'i' + String(idx);
+
+const ADDR_TYPE$4 = 'p2pkh';
+var P2PKH;
+(function (P2PKH) {
+    P2PKH.create = create_p2pkh_address;
+    P2PKH.encode = encode_p2pkh_address;
+    P2PKH.decode = decode_p2pkh_address;
+})(P2PKH || (P2PKH = {}));
+function create_p2pkh_address(script, network = 'main') {
+    const bytes = Buff.bytes(script);
+    const hash = hash160$1(bytes);
+    return encode_p2pkh_address(hash, network);
 }
-function encode_pointer(pointer) {
-    return Buff.num(pointer).reverse().hex;
+function encode_p2pkh_address(pk_hash, network = 'main') {
+    const bytes = Buff.bytes(pk_hash);
+    const config = get_address_config(network, ADDR_TYPE$4);
+    Assert.exists(config, `unrecognized address config: ${ADDR_TYPE$4} on ${network}`);
+    Assert.size(bytes, config.size, `invalid payload size: ${bytes.length} !== ${config.size}`);
+    return encode_address({
+        data: bytes,
+        format: 'base58',
+        version: config.version
+    });
 }
-function decode_pointer(hexstr) {
-    return Buff.hex(hexstr).reverse().num;
+function decode_p2pkh_address(address) {
+    const parsed = parse_address(address);
+    Assert.ok(parsed.type === 'p2pkh', `address type mismatch: ${parsed.type} !== ${ADDR_TYPE$4}`);
+    return parsed;
 }
-function encode_label(label) {
-    return Buff.str(label).hex;
+
+const ADDR_TYPE$3 = 'p2sh';
+var P2SH;
+(function (P2SH) {
+    P2SH.create = create_p2sh_address;
+    P2SH.encode = encode_p2sh_address;
+    P2SH.decode = decode_p2sh_address;
+})(P2SH || (P2SH = {}));
+function create_p2sh_address(script, network = 'main') {
+    const bytes = Buff.bytes(script);
+    const hash = hash160$1(bytes);
+    return encode_p2sh_address(hash, network);
 }
-function decode_label(hexstr) {
-    return Buff.hex(hexstr).str;
+function encode_p2sh_address(script_hash, network = 'main') {
+    const bytes = Buff.bytes(script_hash);
+    const config = get_address_config(network, ADDR_TYPE$3);
+    Assert.exists(config, `unrecognized address config: ${ADDR_TYPE$3} on ${network}`);
+    Assert.size(bytes, config.size, `invalid payload size: ${bytes.length} !== ${config.size}`);
+    return encode_address({
+        data: bytes,
+        format: 'base58',
+        version: config.version
+    });
 }
-function encode_content(content) {
-    const bytes = Buff.is_hex(content)
-        ? Buff.hex(content)
-        : Buff.str(content);
-    const stream = new Stream(bytes);
-    const chunks = [];
-    while (stream.size > 0) {
-        if (stream.size > 520) {
-            const chunk = stream.read(520);
-            chunks.push(chunk.hex);
-        }
-        else {
-            const chunk = stream.read(stream.size);
-            chunks.push(chunk.hex);
-        }
-    }
-    return chunks;
+function decode_p2sh_address(address) {
+    const parsed = parse_address(address);
+    Assert.ok(parsed.type === 'p2sh', `address type mismatch: ${parsed.type} !== ${ADDR_TYPE$3}`);
+    return parsed;
 }
-function decode_content(hexstrs, type = 'hex') {
-    const data = Buff.join(hexstrs);
-    return (type === 'hex')
-        ? data.hex
-        : data.str;
+
+const ADDR_TYPE$2 = 'p2w-pkh';
+var P2WPKH;
+(function (P2WPKH) {
+    P2WPKH.create = create_p2wpkh_address;
+    P2WPKH.encode = encode_p2wpkh_address;
+    P2WPKH.decode = decode_p2wpkh_address;
+})(P2WPKH || (P2WPKH = {}));
+function create_p2wpkh_address(pubkey, network = 'main') {
+    const bytes = Buff.bytes(pubkey);
+    Assert.size(bytes, 33, `invalid payload size: ${bytes.length} !== 33`);
+    const hash = hash160$1(bytes);
+    return encode_p2wpkh_address(hash, network);
 }
-function encode_rune_label(label) {
-    const str = label.toUpperCase();
-    let big = _0n;
-    for (const char of str) {
-        if (char >= 'A' && char <= 'Z') {
-            big = big * _26n + BigInt(char.charCodeAt(0) - ('A'.charCodeAt(0) - 1));
-        }
-        else {
-            continue;
-        }
-    }
-    big = big - _1n;
-    return Buff.big(big).reverse().hex;
+function encode_p2wpkh_address(pk_hash, network = 'main') {
+    const bytes = Buff.bytes(pk_hash);
+    const config = get_address_config(network, ADDR_TYPE$2);
+    Assert.exists(config, `unrecognized address config: ${ADDR_TYPE$2} on ${network}`);
+    Assert.size(bytes, config.size, `invalid payload size: ${bytes.length} !== ${config.size}`);
+    return encode_address({
+        data: bytes,
+        format: 'bech32',
+        prefix: config.prefix
+    });
 }
-function decode_rune_label(hex) {
-    let big = Buff.hex(hex).reverse().big;
-    big = big + _1n;
-    let result = '';
-    while (big > _0n) {
-        const mod = big % _26n;
-        if (mod === _0n) {
-            result = 'Z' + result;
-            big = big / _26n - _1n;
-        }
-        else {
-            const charCode = Number(mod) + 'A'.charCodeAt(0) - 1;
-            result = String.fromCharCode(charCode) + result;
-            big = big / _26n;
-        }
-    }
-    return result;
+function decode_p2wpkh_address(address) {
+    const parsed = parse_address(address);
+    Assert.ok(parsed.type === 'p2w-pkh', `address type mismatch: ${parsed.type} !== ${ADDR_TYPE$2}`);
+    return parsed;
 }
 
-var index$3 = /*#__PURE__*/Object.freeze({
+const ADDR_TYPE$1 = 'p2w-sh';
+var P2WSH;
+(function (P2WSH) {
+    P2WSH.create = create_p2wsh_address;
+    P2WSH.encode = encode_p2wsh_address;
+    P2WSH.decode = decode_p2wsh_address;
+})(P2WSH || (P2WSH = {}));
+function create_p2wsh_address(script, network = 'main') {
+    const bytes = Buff.bytes(script);
+    const hash = sha256(bytes);
+    return encode_p2wsh_address(hash, network);
+}
+function encode_p2wsh_address(script_hash, network = 'main') {
+    const bytes = Buff.bytes(script_hash);
+    const config = get_address_config(network, ADDR_TYPE$1);
+    Assert.exists(config, `unrecognized address config: ${ADDR_TYPE$1} on ${network}`);
+    Assert.size(bytes, config.size, `invalid payload size: ${bytes.length} !== ${config.size}`);
+    return encode_address({
+        data: bytes,
+        format: 'bech32',
+        prefix: config.prefix
+    });
+}
+function decode_p2wsh_address(address) {
+    const parsed = parse_address(address);
+    Assert.ok(parsed.type === 'p2w-sh', `address type mismatch: ${parsed.type} !== ${ADDR_TYPE$1}`);
+    return parsed;
+}
+
+const ADDR_TYPE = 'p2tr';
+var P2TR;
+(function (P2TR) {
+    P2TR.encode = encode_p2tr_address;
+    P2TR.decode = decode_p2tr_address;
+})(P2TR || (P2TR = {}));
+function encode_p2tr_address(pubkey, network = 'main') {
+    const bytes = Buff.bytes(pubkey);
+    const config = get_address_config(network, ADDR_TYPE);
+    Assert.exists(config, `unrecognized address config: ${ADDR_TYPE} on ${network}`);
+    Assert.size(bytes, config.size, `invalid payload size: ${bytes.length} !== ${config.size}`);
+    return encode_address({
+        data: bytes,
+        format: 'bech32m',
+        prefix: config.prefix
+    });
+}
+function decode_p2tr_address(address) {
+    const parsed = parse_address(address);
+    Assert.ok(parsed.type === 'p2tr', `address type mismatch: ${parsed.type} !== ${ADDR_TYPE}`);
+    return parsed;
+}
+
+var AddressTool;
+(function (AddressTool) {
+    AddressTool.P2PKH = P2PKH;
+    AddressTool.P2SH = P2SH;
+    AddressTool.P2WPKH = P2WPKH;
+    AddressTool.P2WSH = P2WSH;
+    AddressTool.P2TR = P2TR;
+    AddressTool.parse = parse_address;
+})(AddressTool || (AddressTool = {}));
+
+var index$4 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    get Inscription () { return Inscription; },
-    get TxPointer () { return TxPointer; },
-    decode_inscription: decode_inscription,
-    encode_inscription: encode_inscription
+    get AddressTool () { return AddressTool; },
+    get P2PKH () { return P2PKH; },
+    get P2SH () { return P2SH; },
+    get P2TR () { return P2TR; },
+    get P2WPKH () { return P2WPKH; },
+    get P2WSH () { return P2WSH; },
+    parse_address: parse_address
 });
 
 /**
@@ -14420,7 +14425,7 @@ function assert_psbt_is_funded(psbt) {
     Assert.ok(vin_amt >= out_amt, `value in (${vin_amt}) < value out (${out_amt})`);
 }
 
-var index$2 = /*#__PURE__*/Object.freeze({
+var index$3 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     assert_psbt_is_funded: assert_psbt_is_funded,
     collect_prevouts: collect_prevouts,
@@ -14434,7 +14439,7 @@ var index$2 = /*#__PURE__*/Object.freeze({
     parse_psbt: parse_psbt
 });
 
-var index$1 = /*#__PURE__*/Object.freeze({
+var index$2 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     format_sigflag: format_sigflag,
     hash_amounts: hash_amounts,
@@ -14445,9 +14450,24 @@ var index$1 = /*#__PURE__*/Object.freeze({
     hash_segwit_tx: hash_segwit_tx,
     hash_sequence: hash_sequence,
     hash_taproot_tx: hash_taproot_tx,
-    parse_txinput: parse_txinput,
+    parse_txinput: parse_txinput
+});
+
+function verify_segwit_tx(_txdata, _config = {}) {
+    console.warn('verify_segwit_tx is not implemented');
+    return true;
+}
+function verify_taproot_tx(_txdata, _config = {}) {
+    console.warn('verify_taproot_tx is not implemented');
+    return true;
+}
+
+var index$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
     sign_segwit_tx: sign_segwit_tx,
-    sign_taproot_tx: sign_taproot_tx
+    sign_taproot_tx: sign_taproot_tx,
+    verify_segwit_tx: verify_segwit_tx,
+    verify_taproot_tx: verify_taproot_tx
 });
 
 function get_merkle_root(leaves) {
@@ -14608,18 +14628,20 @@ var index = /*#__PURE__*/Object.freeze({
     verify_taproot: verify_taproot
 });
 
-exports.Address = index$4;
+exports.ADDRESS = index$4;
 exports.CONST = _const;
-exports.Meta = index$3;
-exports.PSBT = index$2;
-exports.SCHEMA = index$7;
-exports.Script = index$6;
-exports.Sighash = index$1;
-exports.Taproot = index;
+exports.META = index$6;
+exports.PSBT = index$3;
+exports.SCHEMA = index$9;
+exports.SCRIPT = index$8;
+exports.SIGHASH = index$2;
+exports.SIGNER = index$1;
+exports.TAPROOT = index;
+exports.TX = index$7;
 exports.Transaction = Transaction$1;
 exports.TransactionInput = TransactionInput;
 exports.TransactionOutput = TransactionOutput;
 exports.TransactionWitness = TransactionWitness;
-exports.Tx = index$5;
 exports.TxSigner = TxSigner;
+exports.WITNESS = index$5;
 //# sourceMappingURL=main.cjs.map