@arkade-os/sdk 0.4.26 → 0.4.28

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

@@ -1,224 +0,0 @@
-import { hex } from "@scure/base";
-import { AssetInputType, MASK_ASSET_ID, MASK_CONTROL_ASSET, MASK_METADATA, } from "./types.js";
-import { AssetId } from "./assetId.js";
-import { AssetRef } from "./assetRef.js";
-import { AssetInput, AssetInputs } from "./assetInput.js";
-import { AssetOutputs } from "./assetOutput.js";
-import { MetadataList } from "./metadata.js";
-import { BufferReader, BufferWriter } from "./utils.js";
-/**
- * An asset group contains inputs, outputs, and all data related to a given asset id.
- *
- * @see Packet
- * @see AssetId
- * @see AssetRef
- *
- * @example
- * ```typescript
- * const group = AssetGroup.create(
- *   null,                              // asset ID: null for new issuance
- *   null,                              // control asset ID: null when reissuance not needed
- *   [],                                // asset inputs: empty for new issuance
- *   [AssetOutput.create(0, 1000)],     // asset outputs: 1000 units at vout index 0
- *   []                                 // metadata: can be empty
- * )
- * ```
- */
-export class AssetGroup {
-    /** @see create */
-    constructor(assetId, controlAsset, inputs, outputs, metadata) {
-        this.assetId = assetId;
-        this.controlAsset = controlAsset;
-        this.inputs = inputs;
-        this.outputs = outputs;
-        this.metadataList = new MetadataList(metadata);
-    }
-    /**
-     * Create and validate an asset group.
-     *
-     * @param assetId - Asset id for this group, or `null` for fresh issuance
-     * @param controlAsset - Optional control asset reference for (re) issuance
-     * @param inputs - Asset inputs in the group
-     * @param outputs - Asset outputs in the group
-     * @param metadata - Metadata entries associated with the group
-     * @returns A validated asset group
-     * @throws Error if the group fails validation
-     * @see validate
-     */
-    static create(assetId, controlAsset, inputs, outputs, metadata) {
-        const ag = new AssetGroup(assetId, controlAsset, inputs, outputs, metadata);
-        ag.validate();
-        return ag;
-    }
-    /**
-     * Decode an asset group from its hex string form.
-     *
-     * @param s - Hex-encoded asset group
-     * @returns Decoded asset group
-     * @throws Error if the string is not valid hex or does not encode a valid asset group
-     * @see toString
-     */
-    static fromString(s) {
-        let buf;
-        try {
-            buf = hex.decode(s);
-        }
-        catch {
-            throw new Error("invalid format, must be hex");
-        }
-        return AssetGroup.fromBytes(buf);
-    }
-    /**
-     * Decode an asset group from its serialized bytes.
-     *
-     * @param buf - Serialized asset group bytes
-     * @returns Decoded asset group
-     * @throws Error if the buffer is empty or malformed
-     */
-    static fromBytes(buf) {
-        if (!buf || buf.length === 0) {
-            throw new Error("missing asset group");
-        }
-        const reader = new BufferReader(buf);
-        return AssetGroup.fromReader(reader);
-    }
-    /**
-     * Return true when the group represents an issuance.
-     *
-     * @returns `true` when the group has no asset id
-     */
-    isIssuance() {
-        return this.assetId === null;
-    }
-    /**
-     * Return true when the group represents a reissuance.
-     *
-     * @returns `true` when the group has an asset id and outputs exceed local inputs
-     * @remarks
-     * Only local inputs contribute to the comparison; intent-backed inputs contribute `0` here.
-     */
-    isReissuance() {
-        const sumReducer = (s, { amount }) => s + amount;
-        const sumOutputs = this.outputs.reduce(sumReducer, 0n);
-        const sumInputs = this.inputs
-            .map((i) => ({
-            amount: i.input.type === AssetInputType.Local ? i.input.amount : 0n,
-        }))
-            .reduce(sumReducer, 0n);
-        return !this.isIssuance() && sumInputs < sumOutputs;
-    }
-    /**
-     * Serialize the asset group to raw bytes.
-     *
-     * @returns Serialized asset group bytes
-     * @see fromBytes
-     */
-    serialize() {
-        this.validate();
-        const writer = new BufferWriter();
-        this.serializeTo(writer);
-        return writer.toBytes();
-    }
-    /**
-     * Validate the asset group and its child structures.
-     *
-     * @throws Error if the group is empty or violates issuance invariants
-     */
-    validate() {
-        if (this.inputs.length === 0 && this.outputs.length === 0) {
-            throw new Error("empty asset group");
-        }
-        if (this.isIssuance()) {
-            if (this.inputs.length !== 0) {
-                throw new Error("issuance must have no inputs");
-            }
-        }
-        else {
-            if (this.controlAsset !== null) {
-                throw new Error("only issuance can have a control asset");
-            }
-        }
-    }
-    /**
-     * Convert the group into its batch-leaf representation for the given intent txid.
-     *
-     * @param intentTxid - Intent transaction id used to build the leaf input reference
-     * @returns Batch-leaf asset group
-     * @see AssetInput.createIntent
-     */
-    toBatchLeafAssetGroup(intentTxid) {
-        const leafInput = AssetInput.createIntent(hex.encode(intentTxid), 0, 0);
-        return new AssetGroup(this.assetId, this.controlAsset, [leafInput], this.outputs, this.metadataList.items);
-    }
-    /**
-     * Encode the asset group to a hex string.
-     *
-     * @returns Hex-encoded asset group
-     * @see fromString
-     */
-    toString() {
-        return hex.encode(this.serialize());
-    }
-    /**
-     * Decode an asset group from a binary reader.
-     *
-     * @param reader - Reader positioned at an asset group
-     * @returns Decoded asset group
-     * @throws Error if the encoded group is malformed
-     */
-    static fromReader(reader) {
-        const presence = reader.readByte();
-        let assetId = null;
-        let controlAsset = null;
-        let metadata = [];
-        if (presence & MASK_ASSET_ID) {
-            assetId = AssetId.fromReader(reader);
-        }
-        if (presence & MASK_CONTROL_ASSET) {
-            controlAsset = AssetRef.fromReader(reader);
-        }
-        if (presence & MASK_METADATA) {
-            metadata = MetadataList.fromReader(reader).items;
-        }
-        const inputs = AssetInputs.fromReader(reader);
-        const outputs = AssetOutputs.fromReader(reader);
-        const ag = new AssetGroup(assetId, controlAsset, inputs.inputs, outputs.outputs, metadata);
-        ag.validate();
-        return ag;
-    }
-    /**
-     * Serialize the asset group into an existing binary writer.
-     *
-     * @param writer - Writer to append the asset group to
-     */
-    serializeTo(writer) {
-        let presence = 0;
-        if (this.assetId !== null) {
-            presence |= MASK_ASSET_ID;
-        }
-        if (this.controlAsset !== null) {
-            presence |= MASK_CONTROL_ASSET;
-        }
-        if (this.metadataList.length > 0) {
-            presence |= MASK_METADATA;
-        }
-        writer.writeByte(presence);
-        if (presence & MASK_ASSET_ID) {
-            this.assetId.serializeTo(writer);
-        }
-        if (presence & MASK_CONTROL_ASSET) {
-            this.controlAsset.serializeTo(writer);
-        }
-        if (presence & MASK_METADATA) {
-            this.metadataList.serializeTo(writer);
-        }
-        writer.writeVarUint(this.inputs.length);
-        for (const input of this.inputs) {
-            input.serializeTo(writer);
-        }
-        writer.writeVarUint(this.outputs.length);
-        for (const output of this.outputs) {
-            output.serializeTo(writer);
-        }
-    }
-}

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

@@ -1,148 +0,0 @@
-import { hex } from "@scure/base";
-import { TX_HASH_SIZE, ASSET_ID_SIZE } from "./types.js";
-import { BufferReader, BufferWriter, isZeroBytes } from "./utils.js";
-/**
- * AssetId identifies a specific asset.
- *
- * @remarks
- * Asset ids are derived from the genesis transaction id plus the asset group index.
- *
- * @see AssetRef
- *
- * @example
- * ```typescript
- * const assetId = AssetId.create('00'.repeat(32), 0)
- * const encoded = assetId.toString()
- * const decoded = AssetId.fromString(encoded)
- * ```
- */
-export class AssetId {
-    constructor(txid, groupIndex) {
-        this.txid = txid;
-        this.groupIndex = groupIndex;
-    }
-    /**
-     * Create an asset id from a genesis transaction id and group index.
-     *
-     * @param txid - Hex-encoded genesis transaction id
-     * @param groupIndex - Asset group index within the genesis transaction
-     * @returns A validated asset id
-     * @throws Error if the txid is missing, malformed, or not 32 bytes long
-     * @see fromString
-     */
-    static create(txid, groupIndex) {
-        if (!txid) {
-            throw new Error("missing txid");
-        }
-        let buf;
-        try {
-            buf = hex.decode(txid);
-        }
-        catch {
-            throw new Error("invalid txid format, must be hex");
-        }
-        if (buf.length !== TX_HASH_SIZE) {
-            throw new Error(`invalid txid length: got ${buf.length} bytes, want ${TX_HASH_SIZE} bytes`);
-        }
-        const assetId = new AssetId(buf, groupIndex);
-        assetId.validate();
-        return assetId;
-    }
-    /**
-     * Decode an asset id from its hex string representation.
-     *
-     * @param s - Hex-encoded asset id
-     * @returns Decoded asset id
-     * @throws Error if the string is not valid hex or does not encode a valid asset id
-     * @see toString
-     */
-    static fromString(s) {
-        let buf;
-        try {
-            buf = hex.decode(s);
-        }
-        catch {
-            throw new Error("invalid asset id format, must be hex");
-        }
-        return AssetId.fromBytes(buf);
-    }
-    /**
-     * Decode an asset id from its serialized bytes.
-     *
-     * @param buf - Serialized asset id bytes
-     * @returns Decoded asset id
-     * @throws Error if the buffer length is invalid
-     */
-    static fromBytes(buf) {
-        if (!buf || buf.length === 0) {
-            throw new Error("missing asset id");
-        }
-        if (buf.length !== ASSET_ID_SIZE) {
-            throw new Error(`invalid asset id length: got ${buf.length} bytes, want ${ASSET_ID_SIZE} bytes`);
-        }
-        const reader = new BufferReader(buf);
-        return AssetId.fromReader(reader);
-    }
-    /**
-     * Serialize the asset id to raw bytes.
-     *
-     * @returns Serialized asset id bytes
-     * @see fromBytes
-     */
-    serialize() {
-        const writer = new BufferWriter();
-        this.serializeTo(writer);
-        return writer.toBytes();
-    }
-    /**
-     * Encode the asset id to a hex string.
-     *
-     * @returns Hex-encoded asset id
-     * @see fromString
-     */
-    toString() {
-        return hex.encode(this.serialize());
-    }
-    /**
-     * Validate the asset id fields.
-     *
-     * @throws Error if the txid is empty or the group index is out of range
-     */
-    validate() {
-        if (isZeroBytes(this.txid)) {
-            throw new Error("empty txid");
-        }
-        if (!Number.isInteger(this.groupIndex) ||
-            this.groupIndex < 0 ||
-            this.groupIndex > 0xffff) {
-            throw new Error(`invalid group index: ${this.groupIndex}, must be in range [0, 65535]`);
-        }
-    }
-    /**
-     * Decode an asset id from a binary reader.
-     *
-     * @param reader - Reader positioned at an asset id
-     * @returns Decoded asset id
-     * @throws Error if the reader does not contain enough bytes
-     */
-    static fromReader(reader) {
-        if (reader.remaining() < ASSET_ID_SIZE) {
-            throw new Error(`invalid asset id length: got ${reader.remaining()}, want ${ASSET_ID_SIZE}`);
-        }
-        const txid = reader.readSlice(TX_HASH_SIZE);
-        const index = reader.readUint16LE();
-        const assetId = new AssetId(txid, index);
-        assetId.validate();
-        return assetId;
-    }
-    /**
-     * Serialize the asset id into an existing binary writer.
-     *
-     * @param writer - Writer to append the asset id to
-     * @see serialize
-     */
-    serializeTo(writer) {
-        writer.write(this.txid);
-        writer.writeUint16LE(this.groupIndex);
-    }
-}

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

@@ -1,217 +0,0 @@
-import { hex } from "@scure/base";
-import { AssetInputType, TX_HASH_SIZE } from "./types.js";
-import { BufferReader, BufferWriter, isZeroBytes } from "./utils.js";
-/**
- * AssetInput represents an input of an asset group.
- * a local input references a real transaction input and specify the amount in satoshis.
- * an intent input references an external intent transaction. It is created by the server to handle batch leaf transaction.
- */
-export class AssetInput {
-    constructor(input) {
-        this.input = input;
-    }
-    /** Gets the transaction input index for an asset input, e.g. 0 */
-    get vin() {
-        return this.input.vin;
-    }
-    /** Gets the amount for an input (in most cases, 330 sats) */
-    get amount() {
-        return this.input.amount;
-    }
-    /** Create a local asset input that points at a transaction input index. */
-    static create(vin, amount) {
-        const input = new AssetInput({
-            type: AssetInputType.Local,
-            vin,
-            amount: typeof amount === "number" ? BigInt(amount) : amount,
-        });
-        input.validate();
-        return input;
-    }
-    /** Create an intent-backed asset input referencing an external intent transaction. */
-    static createIntent(txid, vin, amount) {
-        if (!txid || txid.length === 0) {
-            throw new Error("missing input intent txid");
-        }
-        let buf;
-        try {
-            buf = hex.decode(txid);
-        }
-        catch {
-            throw new Error("invalid input intent txid format, must be hex");
-        }
-        if (buf.length !== TX_HASH_SIZE) {
-            throw new Error("invalid input intent txid length");
-        }
-        const input = new AssetInput({
-            type: AssetInputType.Intent,
-            txid: buf,
-            vin,
-            amount: typeof amount === "number" ? BigInt(amount) : amount,
-        });
-        input.validate();
-        return input;
-    }
-    /** Decode an asset input from its hex string form. */
-    static fromString(s) {
-        let buf;
-        try {
-            buf = hex.decode(s);
-        }
-        catch {
-            throw new Error("invalid format, must be hex");
-        }
-        return AssetInput.fromBytes(buf);
-    }
-    /** Decode an asset input from its serialized bytes. */
-    static fromBytes(buf) {
-        const reader = new BufferReader(buf);
-        return AssetInput.fromReader(reader);
-    }
-    /** Serialize the asset input to raw bytes. */
-    serialize() {
-        const writer = new BufferWriter();
-        this.serializeTo(writer);
-        return writer.toBytes();
-    }
-    /** Encode the asset input to a hex string. */
-    toString() {
-        return hex.encode(this.serialize());
-    }
-    /** Validate the asset input fields. */
-    validate() {
-        switch (this.input.type) {
-            case AssetInputType.Local:
-                break;
-            case AssetInputType.Intent:
-                if (isZeroBytes(this.input.txid)) {
-                    throw new Error("missing input intent txid");
-                }
-                break;
-        }
-    }
-    /** Decode an asset input from a buffer reader. */
-    static fromReader(reader) {
-        const type = reader.readByte();
-        let input;
-        switch (type) {
-            case AssetInputType.Local: {
-                const vin = reader.readUint16LE();
-                const amount = reader.readVarUint();
-                input = new AssetInput({
-                    type: AssetInputType.Local,
-                    vin,
-                    amount,
-                });
-                break;
-            }
-            case AssetInputType.Intent: {
-                if (reader.remaining() < TX_HASH_SIZE) {
-                    throw new Error("invalid input intent txid length");
-                }
-                const txid = reader.readSlice(TX_HASH_SIZE);
-                const vin = reader.readUint16LE();
-                const amount = reader.readVarUint();
-                input = new AssetInput({
-                    type: AssetInputType.Intent,
-                    txid: new Uint8Array(txid),
-                    vin,
-                    amount,
-                });
-                break;
-            }
-            case AssetInputType.Unspecified:
-                throw new Error("asset input type unspecified");
-            default:
-                throw new Error(`asset input type ${type} unknown`);
-        }
-        input.validate();
-        return input;
-    }
-    /** Serialize the asset input into an existing buffer writer. */
-    serializeTo(writer) {
-        writer.writeByte(this.input.type);
-        if (this.input.type === AssetInputType.Intent) {
-            writer.write(this.input.txid);
-        }
-        writer.writeUint16LE(this.input.vin);
-        writer.writeVarUint(this.input.amount);
-    }
-}
-/**
- * AssetInputs represents a list of asset inputs.
- */
-export class AssetInputs {
-    constructor(inputs) {
-        this.inputs = inputs;
-    }
-    /** Create a validated list of asset inputs. */
-    static create(inputs) {
-        const list = new AssetInputs(inputs);
-        list.validate();
-        return list;
-    }
-    /** Decode an asset input list from its hex string form. */
-    static fromString(s) {
-        if (!s || s.length === 0) {
-            throw new Error("missing asset inputs");
-        }
-        let buf;
-        try {
-            buf = hex.decode(s);
-        }
-        catch {
-            throw new Error("invalid asset inputs format, must be hex");
-        }
-        const reader = new BufferReader(buf);
-        return AssetInputs.fromReader(reader);
-    }
-    /** Serialize the asset input list to raw bytes. */
-    serialize() {
-        const writer = new BufferWriter();
-        this.serializeTo(writer);
-        return writer.toBytes();
-    }
-    /** Encode the asset input list to a hex string. */
-    toString() {
-        return hex.encode(this.serialize());
-    }
-    /** Validate the asset input list. */
-    validate() {
-        const seen = new Set();
-        let listType = AssetInputType.Unspecified;
-        for (const assetInput of this.inputs) {
-            assetInput.validate();
-            if (listType === AssetInputType.Unspecified) {
-                listType = assetInput.input.type;
-            }
-            else if (listType !== assetInput.input.type) {
-                throw new Error("all inputs must be of the same type");
-            }
-            // verify the same input vin is not duplicated
-            if (assetInput.input.type === AssetInputType.Local) {
-                if (seen.has(assetInput.input.vin)) {
-                    throw new Error(`duplicated input vin ${assetInput.input.vin}`);
-                }
-                seen.add(assetInput.input.vin);
-                continue;
-            }
-        }
-    }
-    /** Decode an asset input list from a buffer reader. */
-    static fromReader(reader) {
-        const count = Number(reader.readVarUint());
-        const inputs = [];
-        for (let i = 0; i < count; i++) {
-            inputs.push(AssetInput.fromReader(reader));
-        }
-        return AssetInputs.create(inputs);
-    }
-    /** Serialize the asset input list into an existing buffer writer. */
-    serializeTo(writer) {
-        writer.writeVarUint(this.inputs.length);
-        for (const input of this.inputs) {
-            input.serializeTo(writer);
-        }
-    }
-}