@vbyte/btc-dev/dist/lib/meta/ref.js

Batteries-included toolset for plebian bitcoin development

export var RefPointer;
(function (RefPointer) {
    RefPointer.outpoint = {
        encode: encode_outpoint,
        decode: decode_outpoint,
        verify: verify_outpoint,
        assert: assert_outpoint,
    };
    RefPointer.record_id = {
        encode: encode_inscription_id,
        decode: decode_inscription_id,
        verify: verify_inscription_id,
        assert: assert_inscription_id,
    };
    RefPointer.rune_id = {
        encode: encode_rune_id,
        decode: decode_rune_id,
        verify: verify_rune_id,
        assert: assert_rune_id,
    };
})(RefPointer || (RefPointer = {}));
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}`);
    }
}