@arkade-os/sdk 0.4.26 → 0.4.28

package/dist/esm/extension/asset/assetOutput.js

@@ -1,169 +0,0 @@
-import { hex } from "@scure/base";
-import { BufferReader, BufferWriter } from "./utils.js";
-/**
- * AssetOutput references a real transaction output and specify the amount in satoshis.
- * it must be present in an AssetGroup.
- *
- * @param vout - the output index in the transaction
- * @param amount - asset amount in satoshis
- */
-export class AssetOutput {
-    constructor(vout, amount) {
-        this.vout = vout;
-        this.amount = amount;
-    }
-    /** Create a local asset output referencing a transaction output index. */
-    static create(vout, amount) {
-        const output = new AssetOutput(vout, typeof amount === "number" ? BigInt(amount) : amount);
-        output.validate();
-        return output;
-    }
-    /** Decode an asset output from its hex string form. */
-    static fromString(s) {
-        let buf;
-        try {
-            buf = hex.decode(s);
-        }
-        catch {
-            throw new Error("invalid asset output format, must be hex");
-        }
-        return AssetOutput.fromBytes(buf);
-    }
-    /** Decode an asset output from its serialized bytes. */
-    static fromBytes(buf) {
-        if (!buf || buf.length === 0) {
-            throw new Error("missing asset output");
-        }
-        const reader = new BufferReader(buf);
-        const output = AssetOutput.fromReader(reader);
-        output.validate();
-        return output;
-    }
-    /** Serialize the asset output to raw bytes. */
-    serialize() {
-        const writer = new BufferWriter();
-        this.serializeTo(writer);
-        return writer.toBytes();
-    }
-    /** Encode the asset output to a hex string. */
-    toString() {
-        return hex.encode(this.serialize());
-    }
-    /** Validate the asset output fields. */
-    validate() {
-        if (!Number.isInteger(this.vout) ||
-            this.vout < 0 ||
-            this.vout > 0xffff) {
-            throw new Error("asset output vout must be an integer in range [0, 65535]");
-        }
-        if (this.amount <= 0n) {
-            throw new Error("asset output amount must be greater than 0");
-        }
-    }
-    /** Decode an asset output from a buffer reader. */
-    static fromReader(reader) {
-        if (reader.remaining() < 2) {
-            throw new Error("invalid asset output vout length");
-        }
-        const type = reader.readByte();
-        if (type !== AssetOutput.TYPE_LOCAL) {
-            if (type === 0x00) {
-                throw new Error("output type unspecified");
-            }
-            throw new Error("unknown asset output type");
-        }
-        let vout;
-        try {
-            vout = reader.readUint16LE();
-        }
-        catch {
-            throw new Error("invalid asset output vout length");
-        }
-        const amount = reader.readVarUint();
-        return new AssetOutput(vout, amount);
-    }
-    /** Serialize the asset output into an existing buffer writer. */
-    serializeTo(writer) {
-        writer.writeByte(0x01);
-        writer.writeUint16LE(this.vout);
-        writer.writeVarUint(this.amount);
-    }
-}
-// 0x01 means local output, there is only 1 local output type currently
-// however we serialize it for future upgrades
-AssetOutput.TYPE_LOCAL = 0x01;
-/**
- * AssetOutputs is a list of AssetOutput references.
- * it must be present in an AssetGroup.
- *
- * @param outputs - the list of asset outputs
- */
-export class AssetOutputs {
-    constructor(outputs) {
-        this.outputs = outputs;
-    }
-    /** Create a validated list of asset outputs. */
-    static create(outputs) {
-        const list = new AssetOutputs(outputs);
-        list.validate();
-        return list;
-    }
-    /** Decode an asset output list from its hex string form. */
-    static fromString(s) {
-        if (!s || s.length === 0) {
-            throw new Error("missing asset outputs");
-        }
-        let buf;
-        try {
-            buf = hex.decode(s);
-        }
-        catch {
-            throw new Error("invalid asset outputs format, must be hex");
-        }
-        const reader = new BufferReader(buf);
-        return AssetOutputs.fromReader(reader);
-    }
-    /** Serialize the asset output list to raw bytes. */
-    serialize() {
-        const writer = new BufferWriter();
-        this.serializeTo(writer);
-        return writer.toBytes();
-    }
-    /** Encode the asset output list to a hex string. */
-    toString() {
-        return hex.encode(this.serialize());
-    }
-    /** Validate the asset output list. */
-    validate() {
-        const seen = new Set();
-        for (const output of this.outputs) {
-            output.validate();
-            if (seen.has(output.vout)) {
-                throw new Error(`duplicated output vout ${output.vout}`);
-            }
-            seen.add(output.vout);
-        }
-    }
-    /** Decode an asset output list from a buffer reader. */
-    static fromReader(reader) {
-        const count = Number(reader.readVarUint());
-        if (count === 0) {
-            return new AssetOutputs([]);
-        }
-        const outputs = [];
-        for (let i = 0; i < count; i++) {
-            outputs.push(AssetOutput.fromReader(reader));
-        }
-        const result = new AssetOutputs(outputs);
-        result.validate();
-        return result;
-    }
-    /** Serialize the asset output list into an existing buffer writer. */
-    serializeTo(writer) {
-        this.validate();
-        writer.writeVarUint(this.outputs.length);
-        for (const output of this.outputs) {
-            output.serializeTo(writer);
-        }
-    }
-}

package/dist/esm/extension/asset/assetRef.js

@@ -1,144 +0,0 @@
-import { hex } from "@scure/base";
-import { AssetRefType } from "./types.js";
-import { AssetId } from "./assetId.js";
-import { BufferReader, BufferWriter } from "./utils.js";
-/**
- * Reference to either an explicit asset id or another asset group in the same packet.
- *
- * @see AssetId
- *
- * @example
- * ```typescript
- * const refById = AssetRef.fromId(assetId)
- * const refByGroup = AssetRef.fromGroupIndex(0)
- * ```
- */
-export class AssetRef {
-    constructor(ref) {
-        this.ref = ref;
-    }
-    /** Reference type discriminator. */
-    get type() {
-        return this.ref.type;
-    }
-    /**
-     * Create an asset reference that points to a specific asset id.
-     *
-     * @param assetId - Asset id referenced by this pointer
-     * @returns Asset reference by id
-     * @see fromGroupIndex
-     */
-    static fromId(assetId) {
-        return new AssetRef({ type: AssetRefType.ByID, assetId });
-    }
-    /**
-     * Create an asset reference that points to another asset group by index.
-     *
-     * @param groupIndex - Zero-based asset group index in the packet
-     * @returns Asset reference by group index
-     * @see fromId
-     */
-    static fromGroupIndex(groupIndex) {
-        return new AssetRef({ type: AssetRefType.ByGroup, groupIndex });
-    }
-    /**
-     * Decode an asset reference from its hex string form.
-     *
-     * @param s - Hex-encoded asset reference
-     * @returns Decoded asset reference
-     * @throws Error if the string is not valid hex or does not encode a valid asset reference
-     * @see toString
-     */
-    static fromString(s) {
-        let buf;
-        try {
-            buf = hex.decode(s);
-        }
-        catch {
-            throw new Error("invalid asset ref format, must be hex");
-        }
-        return AssetRef.fromBytes(buf);
-    }
-    /**
-     * Decode an asset reference from its serialized bytes.
-     *
-     * @param buf - Serialized asset reference bytes
-     * @returns Decoded asset reference
-     * @throws Error if the buffer is empty or malformed
-     */
-    static fromBytes(buf) {
-        if (!buf || buf.length === 0) {
-            throw new Error("missing asset ref");
-        }
-        const reader = new BufferReader(buf);
-        return AssetRef.fromReader(reader);
-    }
-    /**
-     * Serialize the asset reference to raw bytes.
-     *
-     * @returns Serialized asset reference bytes
-     * @see fromBytes
-     */
-    serialize() {
-        const writer = new BufferWriter();
-        this.serializeTo(writer);
-        return writer.toBytes();
-    }
-    /**
-     * Encode the asset reference to a hex string.
-     *
-     * @returns Hex-encoded asset reference
-     * @see fromString
-     */
-    toString() {
-        return hex.encode(this.serialize());
-    }
-    /**
-     * Decode an asset reference from a binary reader.
-     *
-     * @param reader - Reader positioned at an asset reference
-     * @returns Decoded asset reference
-     * @throws Error if the type is unknown or the reader does not contain enough bytes
-     */
-    static fromReader(reader) {
-        const type = reader.readByte();
-        let ref;
-        switch (type) {
-            case AssetRefType.ByID: {
-                const assetId = AssetId.fromReader(reader);
-                ref = new AssetRef({ type: AssetRefType.ByID, assetId });
-                break;
-            }
-            case AssetRefType.ByGroup: {
-                if (reader.remaining() < 2) {
-                    throw new Error("invalid asset ref length");
-                }
-                const groupIndex = reader.readUint16LE();
-                ref = new AssetRef({ type: AssetRefType.ByGroup, groupIndex });
-                break;
-            }
-            case AssetRefType.Unspecified:
-                throw new Error("asset ref type unspecified");
-            default:
-                throw new Error(`asset ref type unknown ${type}`);
-        }
-        return ref;
-    }
-    /**
-     * Serialize the asset reference into an existing binary writer.
-     *
-     * @param writer - Writer to append the asset reference to
-     * @see serialize
-     */
-    serializeTo(writer) {
-        writer.writeByte(this.ref.type);
-        switch (this.ref.type) {
-            case AssetRefType.ByID:
-                this.ref.assetId.serializeTo(writer);
-                break;
-            case AssetRefType.ByGroup:
-                writer.writeUint16LE(this.ref.groupIndex);
-                break;
-        }
-    }
-}

package/dist/esm/extension/asset/index.js

@@ -1,8 +0,0 @@
-export { AssetInputType, AssetRefType } from "./types.js";
-export { AssetId } from "./assetId.js";
-export { AssetRef } from "./assetRef.js";
-export { AssetInput, AssetInputs } from "./assetInput.js";
-export { AssetOutput, AssetOutputs } from "./assetOutput.js";
-export { Metadata, MetadataList } from "./metadata.js";
-export { AssetGroup } from "./assetGroup.js";
-export { Packet } from "./packet.js";

package/dist/esm/extension/asset/metadata.js

@@ -1,182 +0,0 @@
-import { schnorr } from "@noble/curves/secp256k1.js";
-import { hex } from "@scure/base";
-import { compareBytes } from "@scure/btc-signer/utils.js";
-import { BufferReader, BufferWriter } from "./utils.js";
-/**
- * Metadata represents a key-value pair.
- * @param key - the key
- * @param value - the value
- */
-export class Metadata {
-    constructor(key, value) {
-        this.key = key;
-        this.value = value;
-    }
-    /** Create a metadata entry from raw key and value bytes. */
-    static create(key, value) {
-        const md = new Metadata(key, value);
-        md.validate();
-        return md;
-    }
-    /** Decode metadata from its hex string form. */
-    static fromString(s) {
-        let buf;
-        try {
-            buf = hex.decode(s);
-        }
-        catch {
-            throw new Error("invalid metadata format, must be hex");
-        }
-        return Metadata.fromBytes(buf);
-    }
-    /** Decode metadata from its serialized bytes. */
-    static fromBytes(buf) {
-        if (!buf || buf.length === 0) {
-            throw new Error("missing metadata");
-        }
-        const reader = new BufferReader(buf);
-        return Metadata.fromReader(reader);
-    }
-    /** Serialize metadata to raw bytes. */
-    serialize() {
-        const writer = new BufferWriter();
-        this.serializeTo(writer);
-        return writer.toBytes();
-    }
-    /** Encode metadata to a hex string. */
-    toString() {
-        return hex.encode(this.serialize());
-    }
-    get keyString() {
-        return new TextDecoder().decode(this.key);
-    }
-    get valueString() {
-        return new TextDecoder().decode(this.value);
-    }
-    /** Validate the metadata key and value. */
-    validate() {
-        if (this.key.length === 0) {
-            throw new Error("missing metadata key");
-        }
-        if (this.value.length === 0) {
-            throw new Error("missing metadata value");
-        }
-    }
-    /** Decode metadata from a buffer reader. */
-    static fromReader(reader) {
-        let key;
-        let value;
-        try {
-            key = reader.readVarSlice();
-        }
-        catch {
-            throw new Error("invalid metadata length");
-        }
-        try {
-            value = reader.readVarSlice();
-        }
-        catch {
-            throw new Error("invalid metadata length");
-        }
-        const md = new Metadata(key, value);
-        md.validate();
-        return md;
-    }
-    /** Serialize metadata into an existing buffer writer. */
-    serializeTo(writer) {
-        writer.writeVarSlice(this.key);
-        writer.writeVarSlice(this.value);
-    }
-}
-export class MetadataList {
-    constructor(items) {
-        this.items = items;
-    }
-    /** Create a metadata list from its hex string form. */
-    static fromString(s) {
-        let buf;
-        try {
-            buf = hex.decode(s);
-        }
-        catch {
-            throw new Error("invalid metadata list format");
-        }
-        return MetadataList.fromBytes(buf);
-    }
-    /** Decode a metadata list from its serialized bytes. */
-    static fromBytes(buf) {
-        if (!buf || buf.length === 0) {
-            throw new Error("missing metadata list");
-        }
-        const reader = new BufferReader(buf);
-        return MetadataList.fromReader(reader);
-    }
-    /** Decode a metadata list from a buffer reader. */
-    static fromReader(reader) {
-        const count = Number(reader.readVarUint());
-        const items = Array.from({ length: count }, () => Metadata.fromReader(reader));
-        return new MetadataList(items);
-    }
-    /** Serialize the metadata list into an existing buffer writer. */
-    serializeTo(writer) {
-        writer.writeVarUint(this.items.length);
-        for (const item of this) {
-            item.serializeTo(writer);
-        }
-    }
-    /** Serialize the metadata list to raw bytes. */
-    serialize() {
-        const writer = new BufferWriter();
-        this.serializeTo(writer);
-        return writer.toBytes();
-    }
-    /** Iterate through metadata entries in insertion order. */
-    [Symbol.iterator]() {
-        return this.items[Symbol.iterator]();
-    }
-    get length() {
-        return this.items.length;
-    }
-    /** Compute the tagged Merkle root for the metadata list. */
-    hash() {
-        if (this.items.length === 0)
-            throw new Error("missing metadata list");
-        const levels = buildMetadataMerkleTree(this.items);
-        return levels[levels.length - 1][0]; // the last level is the root
-    }
-}
-MetadataList.ARK_LEAF_TAG = "ArkadeAssetLeaf";
-MetadataList.ARK_BRANCH_TAG = "ArkadeAssetBranch";
-MetadataList.ARK_LEAF_VERSION = 0x00;
-function computeMetadataLeafHash(md) {
-    const writer = new BufferWriter();
-    writer.writeByte(MetadataList.ARK_LEAF_VERSION);
-    writer.writeVarSlice(md.key);
-    writer.writeVarSlice(md.value);
-    return schnorr.utils.taggedHash(MetadataList.ARK_LEAF_TAG, writer.toBytes());
-}
-function computeMetadataBranchHash(a, b) {
-    const [smaller, larger] = compareBytes(a, b) === -1 ? [a, b] : [b, a];
-    return schnorr.utils.taggedHash(MetadataList.ARK_BRANCH_TAG, smaller, larger);
-}
-function buildMetadataMerkleTree(leaves) {
-    if (leaves.length === 0)
-        return [];
-    const leafHashes = leaves.map(computeMetadataLeafHash);
-    const levels = [leafHashes];
-    let current = leafHashes;
-    while (current.length > 1) {
-        const next = [];
-        for (let i = 0; i < current.length; i += 2) {
-            if (i + 1 < current.length) {
-                next.push(computeMetadataBranchHash(current[i], current[i + 1]));
-            }
-            else {
-                next.push(current[i]);
-            }
-        }
-        levels.push(next);
-        current = next;
-    }
-    return levels;
-}

package/dist/esm/extension/asset/packet.js

@@ -1,110 +0,0 @@
-import { hex } from "@scure/base";
-import { AssetRefType } from "./types.js";
-import { AssetGroup } from "./assetGroup.js";
-import { BufferReader, BufferWriter } from "./utils.js";
-/**
- * Packet represents a collection of asset groups.
- * It encodes/decodes as raw bytes only — OP_RETURN framing is handled by the Extension module.
- */
-export class Packet {
-    constructor(groups) {
-        this.groups = groups;
-    }
-    /** Create a validated asset packet from a list of asset groups. */
-    static create(groups) {
-        const p = new Packet(groups);
-        p.validate();
-        return p;
-    }
-    /**
-     * fromBytes parses a Packet from raw bytes.
-     */
-    static fromBytes(buf) {
-        return Packet.fromReader(new BufferReader(buf));
-    }
-    /**
-     * fromString parses a Packet from a raw hex string (not an OP_RETURN script).
-     */
-    static fromString(s) {
-        if (!s) {
-            throw new Error("missing packet data");
-        }
-        let buf;
-        try {
-            buf = hex.decode(s);
-        }
-        catch {
-            throw new Error("invalid packet format, must be hex");
-        }
-        return Packet.fromBytes(buf);
-    }
-    /**
-     * type returns the TLV packet type tag. Implements ExtensionPacket interface.
-     */
-    type() {
-        return Packet.PACKET_TYPE;
-    }
-    /** Convert the packet into the batch-leaf form for a specific intent transaction id. */
-    leafTxPacket(intentTxid) {
-        const leafGroups = this.groups.map((group) => group.toBatchLeafAssetGroup(intentTxid));
-        return new Packet(leafGroups);
-    }
-    /**
-     * serialize encodes the packet as raw bytes (varint group count + group data).
-     * Does NOT include OP_RETURN, Arkade magic bytes (`ARK`), or TLV type/length; those are
-     * added by the Extension module.
-     */
-    serialize() {
-        if (this.groups.length === 0) {
-            return new Uint8Array(0);
-        }
-        const writer = new BufferWriter();
-        writer.writeVarUint(this.groups.length);
-        for (const group of this.groups) {
-            group.serializeTo(writer);
-        }
-        return writer.toBytes();
-    }
-    /**
-     * toString returns the hex-encoded raw packet bytes.
-     */
-    toString() {
-        return hex.encode(this.serialize());
-    }
-    /** Validate packet structure and cross-group references. */
-    validate() {
-        if (this.groups.length === 0) {
-            throw new Error("missing assets");
-        }
-        const seenAssetIds = new Set();
-        for (const group of this.groups) {
-            if (group.assetId !== null) {
-                const key = group.assetId.toString();
-                if (seenAssetIds.has(key)) {
-                    throw new Error(`duplicate asset group for asset ${key}`);
-                }
-                seenAssetIds.add(key);
-            }
-            if (group.controlAsset !== null &&
-                group.controlAsset.ref.type === AssetRefType.ByGroup &&
-                group.controlAsset.ref.groupIndex >= this.groups.length) {
-                throw new Error(`invalid control asset group index, ${group.controlAsset.ref.groupIndex} out of range [0, ${this.groups.length - 1}]`);
-            }
-        }
-    }
-    static fromReader(reader) {
-        const count = Number(reader.readVarUint());
-        const groups = [];
-        for (let i = 0; i < count; i++) {
-            groups.push(AssetGroup.fromReader(reader));
-        }
-        if (reader.remaining() > 0) {
-            throw new Error(`invalid packet length, left ${reader.remaining()} unknown bytes to read`);
-        }
-        const packet = new Packet(groups);
-        packet.validate();
-        return packet;
-    }
-}
-/** PACKET_TYPE is the 1-byte TLV type tag used in the Extension envelope. */
-Packet.PACKET_TYPE = 0;

package/dist/esm/extension/asset/types.js

@@ -1,19 +0,0 @@
-export const TX_HASH_SIZE = 32;
-export const ASSET_ID_SIZE = 34;
-export const ASSET_VERSION = 0x01;
-export var AssetInputType;
-(function (AssetInputType) {
-    AssetInputType[AssetInputType["Unspecified"] = 0] = "Unspecified";
-    AssetInputType[AssetInputType["Local"] = 1] = "Local";
-    AssetInputType[AssetInputType["Intent"] = 2] = "Intent";
-})(AssetInputType || (AssetInputType = {}));
-export var AssetRefType;
-(function (AssetRefType) {
-    AssetRefType[AssetRefType["Unspecified"] = 0] = "Unspecified";
-    AssetRefType[AssetRefType["ByID"] = 1] = "ByID";
-    AssetRefType[AssetRefType["ByGroup"] = 2] = "ByGroup";
-})(AssetRefType || (AssetRefType = {}));
-// Presence byte masks for AssetGroup
-export const MASK_ASSET_ID = 0x01;
-export const MASK_CONTROL_ASSET = 0x02;
-export const MASK_METADATA = 0x04;