@vbyte/btc-dev 1.0.0

package/dist/lib/address/encode.js

@@ -0,0 +1,79 @@
+import { Buff } from '@vbyte/buff';
+import { Assert, B58chk, Bech32, Bech32m } from '@vbyte/micro-lib';
+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
+};
+export 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');
+}
+export 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 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 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 };
+}

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

@@ -0,0 +1,20 @@
+import { P2PKH as P2PKH_TOOL } from './p2pkh.js';
+import { P2SH as P2SH_TOOL } from './p2sh.js';
+import { P2WPKH as P2WPKH_TOOL } from './p2wpkh.js';
+import { P2WSH as P2WSH_TOOL } from './p2wsh.js';
+import { P2TR as P2TR_TOOL } from './p2tr.js';
+import { parse_address } from './util.js';
+export { P2PKH } from './p2pkh.js';
+export { P2SH } from './p2sh.js';
+export { P2WPKH } from './p2wpkh.js';
+export { P2WSH } from './p2wsh.js';
+export { P2TR } from './p2tr.js';
+export { parse_address } from './util.js';
+export declare namespace AddressTool {
+    const P2PKH: typeof P2PKH_TOOL;
+    const P2SH: typeof P2SH_TOOL;
+    const P2WPKH: typeof P2WPKH_TOOL;
+    const P2WSH: typeof P2WSH_TOOL;
+    const P2TR: typeof P2TR_TOOL;
+    const parse: typeof parse_address;
+}

package/dist/lib/address/index.js

@@ -0,0 +1,21 @@
+import { P2PKH as P2PKH_TOOL } from './p2pkh.js';
+import { P2SH as P2SH_TOOL } from './p2sh.js';
+import { P2WPKH as P2WPKH_TOOL } from './p2wpkh.js';
+import { P2WSH as P2WSH_TOOL } from './p2wsh.js';
+import { P2TR as P2TR_TOOL } from './p2tr.js';
+import { parse_address } from './util.js';
+export { P2PKH } from './p2pkh.js';
+export { P2SH } from './p2sh.js';
+export { P2WPKH } from './p2wpkh.js';
+export { P2WSH } from './p2wsh.js';
+export { P2TR } from './p2tr.js';
+export { parse_address } from './util.js';
+export var AddressTool;
+(function (AddressTool) {
+    AddressTool.P2PKH = P2PKH_TOOL;
+    AddressTool.P2SH = P2SH_TOOL;
+    AddressTool.P2WPKH = P2WPKH_TOOL;
+    AddressTool.P2WSH = P2WSH_TOOL;
+    AddressTool.P2TR = P2TR_TOOL;
+    AddressTool.parse = parse_address;
+})(AddressTool || (AddressTool = {}));

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

@@ -0,0 +1,10 @@
+import type { AddressData, ChainNetwork } from '../../types/index.js';
+export declare namespace P2PKH {
+    const create: typeof create_p2pkh_address;
+    const encode: typeof encode_p2pkh_address;
+    const decode: typeof decode_p2pkh_address;
+}
+declare function create_p2pkh_address(script: string | Uint8Array, network?: ChainNetwork): string;
+declare function encode_p2pkh_address(pk_hash: string | Uint8Array, network?: ChainNetwork): string;
+declare function decode_p2pkh_address(address: string): AddressData;
+export {};

package/dist/lib/address/p2pkh.js

@@ -0,0 +1,33 @@
+import { Buff } from '@vbyte/buff';
+import { Assert } from '@vbyte/micro-lib';
+import { hash160 } from '@vbyte/micro-lib/hash';
+import { encode_address } from './encode.js';
+import { get_address_config, parse_address } from './util.js';
+const ADDR_TYPE = 'p2pkh';
+export 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(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);
+    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: '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}`);
+    return parsed;
+}

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

@@ -0,0 +1,10 @@
+import type { ChainNetwork, AddressData } from '../../types/index.js';
+export declare namespace P2SH {
+    const create: typeof create_p2sh_address;
+    const encode: typeof encode_p2sh_address;
+    const decode: typeof decode_p2sh_address;
+}
+declare function create_p2sh_address(script: string | Uint8Array, network?: ChainNetwork): string;
+declare function encode_p2sh_address(script_hash: string | Uint8Array, network?: ChainNetwork): string;
+declare function decode_p2sh_address(address: string): AddressData;
+export {};

package/dist/lib/address/p2sh.js

@@ -0,0 +1,33 @@
+import { Buff } from '@vbyte/buff';
+import { Assert } from '@vbyte/micro-lib';
+import { hash160 } from '@vbyte/micro-lib/hash';
+import { encode_address } from './encode.js';
+import { get_address_config, parse_address } from './util.js';
+const ADDR_TYPE = 'p2sh';
+export 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(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);
+    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: '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}`);
+    return parsed;
+}

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

@@ -0,0 +1,8 @@
+import type { ChainNetwork, AddressData } from '../../types/index.js';
+export declare namespace P2TR {
+    const encode: typeof encode_p2tr_address;
+    const decode: typeof decode_p2tr_address;
+}
+declare function encode_p2tr_address(pubkey: string | Uint8Array, network?: ChainNetwork): string;
+declare function decode_p2tr_address(address: string): AddressData;
+export {};

package/dist/lib/address/p2tr.js

@@ -0,0 +1,26 @@
+import { Buff } from '@vbyte/buff';
+import { Assert } from '@vbyte/micro-lib';
+import { encode_address } from './encode.js';
+import { get_address_config, parse_address } from './util.js';
+const ADDR_TYPE = 'p2tr';
+export 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;
+}

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

@@ -0,0 +1,10 @@
+import type { AddressData, ChainNetwork } from '../../types/index.js';
+export declare namespace P2WPKH {
+    const create: typeof create_p2wpkh_address;
+    const encode: typeof encode_p2wpkh_address;
+    const decode: typeof decode_p2wpkh_address;
+}
+declare function create_p2wpkh_address(pubkey: string | Uint8Array, network?: ChainNetwork): string;
+declare function encode_p2wpkh_address(pk_hash: string | Uint8Array, network?: ChainNetwork): string;
+declare function decode_p2wpkh_address(address: string): AddressData;
+export {};

package/dist/lib/address/p2wpkh.js

@@ -0,0 +1,34 @@
+import { Buff } from '@vbyte/buff';
+import { Assert } from '@vbyte/micro-lib';
+import { hash160 } from '@vbyte/micro-lib/hash';
+import { encode_address } from './encode.js';
+import { get_address_config, parse_address } from './util.js';
+const ADDR_TYPE = 'p2w-pkh';
+export 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(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);
+    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: '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}`);
+    return parsed;
+}

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

@@ -0,0 +1,10 @@
+import type { ChainNetwork, AddressData } from '../../types/index.js';
+export declare namespace P2WSH {
+    const create: typeof create_p2wsh_address;
+    const encode: typeof encode_p2wsh_address;
+    const decode: typeof decode_p2wsh_address;
+}
+declare function create_p2wsh_address(script: string | Uint8Array, network?: ChainNetwork): string;
+declare function encode_p2wsh_address(script_hash: string | Uint8Array, network?: ChainNetwork): string;
+declare function decode_p2wsh_address(address: string): AddressData;
+export {};

package/dist/lib/address/p2wsh.js

@@ -0,0 +1,33 @@
+import { Buff } from '@vbyte/buff';
+import { Assert } from '@vbyte/micro-lib';
+import { sha256 } from '@vbyte/micro-lib/hash';
+import { encode_address } from './encode.js';
+import { get_address_config, parse_address } from './util.js';
+const ADDR_TYPE = 'p2w-sh';
+export 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);
+    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: '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}`);
+    return parsed;
+}

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

@@ -0,0 +1,5 @@
+import type { AddressType } from '../../types/index.js';
+export declare function get_address_script(script_key: string, script_type: AddressType): {
+    script_hex: string;
+    script_asm: string[];
+};

package/dist/lib/address/script.js

@@ -0,0 +1,46 @@
+export 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);
+    }
+}
+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]
+    };
+}

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

@@ -0,0 +1,4 @@
+import type { AddressConfig, AddressType, ChainNetwork, AddressContext, AddressData } from '../../types/index.js';
+export declare function get_address_config(address_network: ChainNetwork, address_type: AddressType): AddressConfig | null;
+export declare function get_address_ctx(address: string): AddressContext;
+export declare function parse_address(address: string): AddressData;

package/dist/lib/address/util.js

@@ -0,0 +1,57 @@
+import { Buff } from '@vbyte/buff';
+import { decode_address } from './encode.js';
+import { get_address_script } from './script.js';
+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]
+];
+export 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 null;
+}
+export 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 };
+    }
+    throw new Error('address configuration is invalid');
+}
+export function parse_address(address) {
+    const ctx = get_address_ctx(address);
+    const script = get_address_script(ctx.hex, ctx.type);
+    return { ...ctx, ...script };
+}

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

@@ -0,0 +1,2 @@
+export * from './pointer.js';
+export * from './scribe.js';

package/dist/lib/meta/index.js

@@ -0,0 +1,2 @@
+export * from './pointer.js';
+export * from './scribe.js';

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

@@ -0,0 +1,42 @@
+export declare namespace TxPointer {
+    const outpoint: {
+        encode: typeof encode_outpoint;
+        decode: typeof decode_outpoint;
+        verify: typeof verify_outpoint;
+        assert: typeof assert_outpoint;
+    };
+    const record_id: {
+        encode: typeof encode_inscription_id;
+        decode: typeof decode_inscription_id;
+        verify: typeof verify_inscription_id;
+        assert: typeof assert_inscription_id;
+    };
+    const rune_id: {
+        encode: typeof encode_rune_id;
+        decode: typeof decode_rune_id;
+        verify: typeof verify_rune_id;
+        assert: typeof assert_rune_id;
+    };
+}
+declare function encode_inscription_id(txid: string, order?: number): string;
+declare function decode_inscription_id(inscription_id: string): {
+    txid: string;
+    order: number;
+};
+declare function verify_inscription_id(inscription_id: string): boolean;
+declare function assert_inscription_id(inscription_id: string): void;
+declare function encode_rune_id(block_height: number, block_index: number): string;
+declare function decode_rune_id(rune_id: string): {
+    block_height: number;
+    block_index: number;
+};
+declare function verify_rune_id(rune_id: string): boolean;
+declare function assert_rune_id(rune_id: string): void;
+declare function encode_outpoint(txid: string, vout: number): string;
+declare function decode_outpoint(outpoint: string): {
+    txid: string;
+    vout: number;
+};
+declare function verify_outpoint(outpoint: string): boolean;
+declare function assert_outpoint(outpoint: string): void;
+export {};

package/dist/lib/meta/pointer.js

@@ -0,0 +1,69 @@
+export 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) };
+}
+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}`);
+    }
+}
+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}`);
+    }
+}
+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}`);
+    }
+}

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

@@ -0,0 +1,7 @@
+import type { InscriptionData } from '../../types/index.js';
+export declare namespace Inscription {
+    const encode: typeof encode_inscription;
+    const decode: typeof decode_inscription;
+}
+export declare function decode_inscription(script: string): InscriptionData[];
+export declare function encode_inscription(data: InscriptionData[]): string;