@vbyte/btc-dev 1.0.0

package/dist/lib/meta/scribe.js

@@ -0,0 +1,192 @@
+import { Buff, Stream } from '@vbyte/buff';
+import { Assert } from '@vbyte/micro-lib';
+import { encode_script } from '../../lib/script/encode.js';
+import { decode_script } from '../../lib/script/decode.js';
+const _0n = BigInt(0);
+const _1n = BigInt(1);
+const _26n = BigInt(26);
+export var Inscription;
+(function (Inscription) {
+    Inscription.encode = encode_inscription;
+    Inscription.decode = decode_inscription;
+})(Inscription || (Inscription = {}));
+export function decode_inscription(script) {
+    const envelopes = parse_envelopes(script);
+    return envelopes.map(parse_record);
+}
+export 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);
+    }
+    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 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;
+    }
+    return envelopes;
+}
+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;
+        }
+    }
+    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);
+        }
+    }
+    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;
+        }
+    }
+    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;
+}

package/dist/lib/psbt/encoder.d.ts

@@ -0,0 +1,5 @@
+import { Transaction } from '@scure/btc-signer';
+import type { PSBTData } from '../../types/index.js';
+export declare function decode_psbt(b64str: string): Transaction;
+export declare function encode_psbt(psbt: PSBTData): string;
+export declare function parse_psbt(psbt: string | PSBTData): Transaction;

package/dist/lib/psbt/encoder.js

@@ -0,0 +1,21 @@
+import { Base64 } from '@vbyte/micro-lib';
+import { Transaction } from '@scure/btc-signer';
+export function decode_psbt(b64str) {
+    const psbt = Base64.decode(b64str);
+    return Transaction.fromPSBT(psbt, { allowUnknownOutputs: true });
+}
+export function encode_psbt(psbt) {
+    const psbt_bytes = psbt.toPSBT(0);
+    return Base64.encode(psbt_bytes);
+}
+export function parse_psbt(psbt) {
+    if (psbt instanceof Transaction) {
+        return psbt;
+    }
+    else if (typeof psbt === 'string') {
+        return decode_psbt(psbt);
+    }
+    else {
+        throw new Error('invalid psbt input: ' + psbt);
+    }
+}

package/dist/lib/psbt/index.d.ts

@@ -0,0 +1,4 @@
+export * from './encoder.js';
+export * from './meta.js';
+export * from './util.js';
+export * from './validate.js';

package/dist/lib/psbt/index.js

@@ -0,0 +1,4 @@
+export * from './encoder.js';
+export * from './meta.js';
+export * from './util.js';
+export * from './validate.js';

package/dist/lib/psbt/meta.d.ts

@@ -0,0 +1,3 @@
+import { PSBTData } from '../../types/index.js';
+export declare function get_vsize(psbt: string | PSBTData): number;
+export declare function get_txhex(psbt: PSBTData): string;

package/dist/lib/psbt/meta.js

@@ -0,0 +1,11 @@
+import { parse_psbt } from './encoder.js';
+import { finalize_legacy_inputs } from './util.js';
+export function get_vsize(psbt) {
+    const pdata = parse_psbt(psbt);
+    return pdata.vsize;
+}
+export function get_txhex(psbt) {
+    let pdata = parse_psbt(psbt);
+    pdata = finalize_legacy_inputs(pdata);
+    return pdata.hex;
+}

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

@@ -0,0 +1,5 @@
+import type { PSBTData, PSBTInput, PSBTOutput, PSBTPrevouts } from '../../types/index.js';
+export declare function collect_vins(psbt: string | PSBTData): PSBTInput[];
+export declare function collect_vouts(psbt: string | PSBTData): PSBTOutput[];
+export declare function collect_prevouts(psbt: PSBTData): PSBTPrevouts;
+export declare function finalize_legacy_inputs(pdata: PSBTData): import("node_modules/@scure/btc-signer/transaction.js").Transaction;

package/dist/lib/psbt/util.js

@@ -0,0 +1,44 @@
+import { Assert } from '@vbyte/micro-lib';
+import { parse_psbt } from './encoder.js';
+export function collect_vins(psbt) {
+    const pdata = parse_psbt(psbt);
+    const count = pdata.inputsLength;
+    const vins = [];
+    for (let i = 0; i < count; i++) {
+        const vin = pdata.getInput(i);
+        vins.push(vin);
+    }
+    return vins;
+}
+export function collect_vouts(psbt) {
+    const pdata = parse_psbt(psbt);
+    const count = pdata.outputsLength;
+    const vouts = [];
+    for (let i = 0; i < count; i++) {
+        const vout = pdata.getOutput(i);
+        vouts.push(vout);
+    }
+    return vouts;
+}
+export function collect_prevouts(psbt) {
+    const amounts = [], scripts = [];
+    const pdata = parse_psbt(psbt);
+    for (let i = 0; i < pdata.inputsLength; i++) {
+        const txin = pdata.getInput(i);
+        Assert.exists(txin.witnessUtxo, `witness utxo does not exist for input ${i}`);
+        amounts.push(txin.witnessUtxo.amount);
+        scripts.push(txin.witnessUtxo.script);
+    }
+    return { amounts, scripts };
+}
+export function finalize_legacy_inputs(pdata) {
+    for (let i = 0; i < pdata.inputsLength; i++) {
+        const pvin = pdata.getInput(i);
+        const script = pvin.redeemScript;
+        const psig = pvin.partialSig?.at(0);
+        if (script !== undefined && psig !== undefined) {
+            pdata.finalizeIdx(i);
+        }
+    }
+    return pdata;
+}

package/dist/lib/psbt/validate.d.ts

@@ -0,0 +1,2 @@
+import type { PSBTData } from '../../types/index.js';
+export declare function assert_psbt_is_funded(psbt: string | PSBTData): void;

package/dist/lib/psbt/validate.js

@@ -0,0 +1,11 @@
+import { Assert } from '@vbyte/micro-lib';
+import { parse_psbt } from './encoder.js';
+import { collect_vins, collect_vouts } from './util.js';
+export function assert_psbt_is_funded(psbt) {
+    const pdata = parse_psbt(psbt);
+    const pvouts = collect_vins(pdata);
+    const txouts = collect_vouts(pdata);
+    const vin_amt = pvouts.reduce((p, n) => p + Number(n.witnessUtxo?.amount ?? 0), 0);
+    const out_amt = txouts.reduce((p, n) => p + Number(n.amount ?? 0), 0);
+    Assert.ok(vin_amt >= out_amt, `value in (${vin_amt}) < value out (${out_amt})`);
+}

package/dist/lib/script/decode.d.ts

@@ -0,0 +1,2 @@
+export declare function decode_script(script: string | Uint8Array): string[];
+export declare function is_valid_script(script: string | Uint8Array): boolean;

package/dist/lib/script/decode.js

@@ -0,0 +1,55 @@
+import { Stream } from '@vbyte/buff';
+import { get_op_code, get_op_type, is_valid_op } from './words.js';
+export function decode_script(script) {
+    const stream = new Stream(script);
+    const stack = [];
+    const stack_size = stream.size;
+    let word;
+    let word_type;
+    let word_size;
+    let count = 0;
+    while (count < stack_size) {
+        word = stream.read(1).num;
+        word_type = get_op_type(word);
+        count++;
+        switch (word_type) {
+            case 'varint':
+                stack.push(stream.read(word).hex);
+                count += word;
+                break;
+            case 'pushdata1':
+                word_size = stream.read(1).reverse().num;
+                stack.push(stream.read(word_size).hex);
+                count += word_size + 1;
+                break;
+            case 'pushdata2':
+                word_size = stream.read(2).reverse().num;
+                stack.push(stream.read(word_size).hex);
+                count += word_size + 2;
+                break;
+            case 'pushdata4':
+                word_size = stream.read(4).reverse().num;
+                stack.push(stream.read(word_size).hex);
+                count += word_size + 4;
+                break;
+            case 'opcode':
+                if (!is_valid_op(word)) {
+                    throw new Error(`Invalid OPCODE: ${word}`);
+                }
+                stack.push(get_op_code(word));
+                break;
+            default:
+                throw new Error(`Word type undefined: ${word}`);
+        }
+    }
+    return stack;
+}
+export function is_valid_script(script) {
+    try {
+        const stack = decode_script(script);
+        return stack.length > 0;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/lib/script/encode.d.ts

@@ -0,0 +1,6 @@
+import { Buff } from '@vbyte/buff';
+export declare function encode_script(words: (string | number | Uint8Array)[], varint?: boolean): string;
+export declare function encode_script_word(word: string | number | Uint8Array): Uint8Array;
+export declare function split_script_word(word: Uint8Array): Buff[];
+export declare function prefix_word_size(word: Uint8Array): Buff;
+export declare function get_size_varint(size: number): Buff;

package/dist/lib/script/encode.js

@@ -0,0 +1,80 @@
+import { Buff, Stream } from '@vbyte/buff';
+import { get_asm_code, } from './words.js';
+const MAX_WORD_SIZE = 520;
+export function encode_script(words, varint = false) {
+    if (words.length === 0)
+        return '00';
+    const bytes = [];
+    for (const word of words) {
+        bytes.push(encode_script_word(word));
+    }
+    const buffer = Buff.join(bytes);
+    return (varint)
+        ? buffer.prepend(Buff.varint(buffer.length, 'le')).hex
+        : buffer.hex;
+}
+export function encode_script_word(word) {
+    let buff;
+    if (typeof (word) === 'string') {
+        if (word.startsWith('OP_')) {
+            const asm_code = get_asm_code(word);
+            return Buff.num(asm_code, 1);
+        }
+        else if (Buff.is_hex(word)) {
+            buff = Buff.hex(word);
+        }
+        else {
+            buff = Buff.str(word);
+        }
+    }
+    else if (typeof (word) === 'number') {
+        buff = Buff.num(word);
+    }
+    else if (word instanceof Uint8Array) {
+        buff = new Buff(word);
+    }
+    else {
+        throw new Error('invalid word type:' + typeof (word));
+    }
+    if (buff.length === 1 && buff[0] <= 16) {
+        if (buff[0] !== 0)
+            buff[0] += 0x50;
+    }
+    else if (buff.length > MAX_WORD_SIZE) {
+        let words;
+        words = split_script_word(buff);
+        words = words.map(e => prefix_word_size(e));
+        buff = Buff.join(words);
+    }
+    else {
+        buff = prefix_word_size(buff);
+    }
+    return buff;
+}
+export function split_script_word(word) {
+    const words = [];
+    const buff = new Stream(word);
+    while (buff.size > MAX_WORD_SIZE) {
+        words.push(buff.read(MAX_WORD_SIZE));
+    }
+    words.push(buff.read(buff.size));
+    return words;
+}
+export function prefix_word_size(word) {
+    const varint = get_size_varint(word.length);
+    return Buff.join([varint, word]);
+}
+export function get_size_varint(size) {
+    const OP_PUSHDATA1 = Buff.num(0x4c, 1);
+    const OP_PUSHDATA2 = Buff.num(0x4d, 1);
+    switch (true) {
+        case (size <= 0x4b):
+            return Buff.num(size);
+        case (size > 0x4b && size < 0x100):
+            return Buff.join([OP_PUSHDATA1, Buff.num(size, 1, 'le')]);
+        case (size >= 0x100 && size <= MAX_WORD_SIZE):
+            return Buff.join([OP_PUSHDATA2, Buff.num(size, 2, 'le')]);
+        default:
+            throw new Error('Invalid word size:' + size.toString());
+    }
+}

package/dist/lib/script/index.d.ts

@@ -0,0 +1,126 @@
+import { encode_script } from './encode.js';
+import { decode_script, is_valid_script } from './decode.js';
+import { parse_script_pubkeys, prefix_script_size } from './util.js';
+export * from './decode.js';
+export * from './encode.js';
+export * from './util.js';
+export * from './words.js';
+export declare namespace ScriptUtil {
+    const prefix_size: typeof prefix_script_size;
+    const decode: typeof decode_script;
+    const encode: typeof encode_script;
+    const is_valid: typeof is_valid_script;
+    const get_pubkeys: typeof parse_script_pubkeys;
+    const OPCODES: {
+        OP_0: number;
+        OP_PUSHDATA1: number;
+        OP_PUSHDATA2: number;
+        OP_PUSHDATA4: number;
+        OP_1NEGATE: number;
+        OP_SUCCESS80: number;
+        OP_1: number;
+        OP_2: number;
+        OP_3: number;
+        OP_4: number;
+        OP_5: number;
+        OP_6: number;
+        OP_7: number;
+        OP_8: number;
+        OP_9: number;
+        OP_10: number;
+        OP_11: number;
+        OP_12: number;
+        OP_13: number;
+        OP_14: number;
+        OP_15: number;
+        OP_16: number;
+        OP_NOP: number;
+        OP_SUCCESS98: number;
+        OP_IF: number;
+        OP_NOTIF: number;
+        OP_ELSE: number;
+        OP_ENDIF: number;
+        OP_VERIFY: number;
+        OP_RETURN: number;
+        OP_TOALTSTACK: number;
+        OP_FROMALTSTACK: number;
+        OP_2DROP: number;
+        OP_2DUP: number;
+        OP_3DUP: number;
+        OP_2OVER: number;
+        OP_2ROT: number;
+        OP_2SWAP: number;
+        OP_IFDUP: number;
+        OP_DEPTH: number;
+        OP_DROP: number;
+        OP_DUP: number;
+        OP_NIP: number;
+        OP_OVER: number;
+        OP_PICK: number;
+        OP_ROLL: number;
+        OP_ROT: number;
+        OP_SWAP: number;
+        OP_TUCK: number;
+        OP_SUCCESS126: number;
+        OP_SUCCESS127: number;
+        OP_SUCCESS128: number;
+        OP_SUCCESS129: number;
+        OP_SIZE: number;
+        OP_SUCCESS131: number;
+        OP_SUCCESS132: number;
+        OP_SUCCESS133: number;
+        OP_SUCCESS134: number;
+        OP_EQUAL: number;
+        OP_EQUALVERIFY: number;
+        OP_SUCCESS137: number;
+        OP_SUCCESS138: number;
+        OP_1ADD: number;
+        OP_1SUB: number;
+        OP_SUCCESS141: number;
+        OP_SUCCESS142: number;
+        OP_NEGATE: number;
+        OP_ABS: number;
+        OP_NOT: number;
+        OP_0NOTEQUAL: number;
+        OP_ADD: number;
+        OP_SUB: number;
+        OP_SUCCESS149: number;
+        OP_SUCCESS150: number;
+        OP_SUCCESS151: number;
+        OP_SUCCESS152: number;
+        OP_SUCCESS153: number;
+        OP_BOOLAND: number;
+        OP_BOOLOR: number;
+        OP_NUMEQUAL: number;
+        OP_NUMEQUALVERIFY: number;
+        OP_NUMNOTEQUAL: number;
+        OP_LESSTHAN: number;
+        OP_GREATERTHAN: number;
+        OP_LESSTHANOREQUAL: number;
+        OP_GREATERTHANOREQUAL: number;
+        OP_MIN: number;
+        OP_MAX: number;
+        OP_WITHIN: number;
+        OP_RIPEMD160: number;
+        OP_SHA1: number;
+        OP_SHA256: number;
+        OP_HASH160: number;
+        OP_HASH256: number;
+        OP_CODESEPARATOR: number;
+        OP_CHECKSIG: number;
+        OP_CHECKSIGVERIFY: number;
+        OP_CHECKMULTISIG: number;
+        OP_CHECKMULTISIGVERIFY: number;
+        OP_NOP1: number;
+        OP_CHECKLOCKTIMEVERIFY: number;
+        OP_CHECKSEQUENCEVERIFY: number;
+        OP_NOP4: number;
+        OP_NOP5: number;
+        OP_NOP6: number;
+        OP_NOP7: number;
+        OP_NOP8: number;
+        OP_NOP9: number;
+        OP_NOP10: number;
+        OP_CHECKSIGADD: number;
+    };
+}

package/dist/lib/script/index.js

@@ -0,0 +1,17 @@
+import { OPCODE_MAP } from './words.js';
+import { encode_script } from './encode.js';
+import { decode_script, is_valid_script } from './decode.js';
+import { parse_script_pubkeys, prefix_script_size } from './util.js';
+export * from './decode.js';
+export * from './encode.js';
+export * from './util.js';
+export * from './words.js';
+export var ScriptUtil;
+(function (ScriptUtil) {
+    ScriptUtil.prefix_size = prefix_script_size;
+    ScriptUtil.decode = decode_script;
+    ScriptUtil.encode = encode_script;
+    ScriptUtil.is_valid = is_valid_script;
+    ScriptUtil.get_pubkeys = parse_script_pubkeys;
+    ScriptUtil.OPCODES = OPCODE_MAP;
+})(ScriptUtil || (ScriptUtil = {}));

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

@@ -0,0 +1,2 @@
+export declare function prefix_script_size(script: string | Uint8Array): string;
+export declare function parse_script_pubkeys(script: string | Uint8Array): string[];

package/dist/lib/script/util.js

@@ -0,0 +1,10 @@
+import { Buff } from '@vbyte/buff';
+export function prefix_script_size(script) {
+    return Buff.bytes(script).prefix_varint('le').hex;
+}
+export function parse_script_pubkeys(script) {
+    const scriptHex = typeof script === 'string' ? script : Buff.bytes(script).hex;
+    const pubkeyPattern = /20([0-9a-f]{64})(ac|ad|ba)/gi;
+    const matches = [...scriptHex.matchAll(pubkeyPattern)];
+    return matches.map(match => match[1]);
+}