@vbyte/btc-dev 1.1.5 → 1.1.7

package/dist/lib/address/api.d.ts

@@ -1,4 +1,4 @@
 import { Bytes } from '@vbyte/buff';
 import type { AddressInfo, ChainNetwork } from '../../types/index.js';
-export declare function create_address(script: Bytes, network?: ChainNetwork): string;
+export declare function get_address(script: Bytes, network?: ChainNetwork): string;
 export declare function parse_address(address: string): AddressInfo;

package/dist/lib/address/api.js

@@ -7,24 +7,24 @@ import { P2SH } from './p2sh.js';
 import { P2TR } from './p2tr.js';
 import { P2WPKH } from './p2wpkh.js';
 import { P2WSH } from './p2wsh.js';
-export function create_address(script, network = 'main') {
+export function get_address(script, network = 'main') {
     const bytes = Buff.bytes(script);
     const type = get_lock_script_type(bytes);
     if (type === null)
-        throw new Error('unrecognized script type: ' + bytes.hex);
+        throw new Error('unknown locking script: ' + bytes.hex);
     switch (type) {
         case LOCK_SCRIPT_TYPE.P2PKH:
-            return P2PKH.create_address(script, network);
+            return P2PKH.encode_address(script, network);
         case LOCK_SCRIPT_TYPE.P2SH:
-            return P2SH.create_address(script, network);
+            return P2SH.encode_address(script, network);
         case LOCK_SCRIPT_TYPE.P2WPKH:
-            return P2WPKH.create_address(script, network);
+            return P2WPKH.encode_address(script, network);
         case LOCK_SCRIPT_TYPE.P2WSH:
-            return P2WSH.create_address(script, network);
+            return P2WSH.encode_address(script, network);
         case LOCK_SCRIPT_TYPE.P2TR:
-            return P2TR.create_address(script, network);
+            return P2TR.encode_address(script, network);
         default:
-            throw new Error('unrecognized script type: ' + type);
+            throw new Error('unknown script type: ' + type);
     }
 }
 export function parse_address(address) {

package/dist/lib/tx/decode.js

@@ -6,9 +6,8 @@ export function decode_tx(txdata, use_segwit = true) {
     Assert.is_bytes(txdata, 'txdata must be hex or bytes');
     const stream = new Stream(txdata);
     const version = read_version(stream);
-    const has_witness = (use_segwit)
-        ? check_witness_flag(stream)
-        : false;
+    let has_witness = check_witness_flag(stream);
+    has_witness = (use_segwit) ? has_witness : false;
     const vin = read_inputs(stream);
     const vout = read_outputs(stream);
     if (has_witness) {

package/dist/lib/tx/util.d.ts

@@ -1,4 +1,6 @@
+import { Buff } from '@vbyte/buff';
 import type { TxData, TxOutput, TxOutputTemplate, TxValue } from '../../types/index.js';
+export declare function transcode_tx(txdata: string | Uint8Array, use_segwit?: boolean): Buff;
 export declare function get_txid(txdata: string | Uint8Array | TxData): string;
 export declare function get_txhash(txdata: string | Uint8Array | TxData): string;
 export declare function get_tx_value(txdata: string | Uint8Array | TxData): TxValue;

package/dist/lib/tx/util.js

@@ -2,16 +2,34 @@ import { Buff } from '@vbyte/buff';
 import { Test } from '@vbyte/micro-lib';
 import { Assert } from '@vbyte/micro-lib/assert';
 import { hash256 } from '@vbyte/micro-lib/hash';
+import { decode_tx } from './decode.js';
 import { encode_tx } from './encode.js';
 import { parse_tx } from './parse.js';
 import { assert_tx_template } from './validate.js';
 import { DEFAULT } from '../../const.js';
+export function transcode_tx(txdata, use_segwit = true) {
+    console.log('txdata:', txdata);
+    const decoded = decode_tx(txdata);
+    console.log('decoded:', decoded);
+    return encode_tx(decoded, use_segwit);
+}
 export function get_txid(txdata) {
-    if (typeof txdata === 'object') {
+    let buffer;
+    if (txdata instanceof Uint8Array) {
+        buffer = transcode_tx(txdata, false);
+    }
+    else if (typeof txdata === 'object') {
         assert_tx_template(txdata);
-        txdata = encode_tx(txdata, false);
+        buffer = encode_tx(txdata, false);
     }
-    return hash256(txdata).reverse().hex;
+    else if (typeof txdata === 'string') {
+        Assert.is_hex(txdata);
+        buffer = transcode_tx(txdata, false);
+    }
+    else {
+        throw new TypeError('invalid txdata type: ' + typeof txdata);
+    }
+    return hash256(buffer).reverse().hex;
 }
 export function get_txhash(txdata) {
     if (typeof txdata === 'object') {