@arkade-os/sdk 0.3.13 → 0.4.0-next.1

package/dist/cjs/asset/assetGroup.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetGroup = void 0;
+const base_1 = require("@scure/base");
+const types_1 = require("./types");
+const assetId_1 = require("./assetId");
+const assetRef_1 = require("./assetRef");
+const assetInput_1 = require("./assetInput");
+const assetOutput_1 = require("./assetOutput");
+const metadata_1 = require("./metadata");
+const utils_1 = require("./utils");
+/**
+ * An asset group contains inputs/outputs and all data related to a given asset id.
+ */
+class AssetGroup {
+    constructor(assetId, controlAsset, inputs, outputs, metadata) {
+        this.assetId = assetId;
+        this.controlAsset = controlAsset;
+        this.inputs = inputs;
+        this.outputs = outputs;
+        this.metadataList = new metadata_1.MetadataList(metadata);
+    }
+    static create(assetId, controlAsset, inputs, outputs, metadata) {
+        const ag = new AssetGroup(assetId, controlAsset, inputs, outputs, metadata);
+        ag.validate();
+        return ag;
+    }
+    // from hex encoded
+    static fromString(s) {
+        let buf;
+        try {
+            buf = base_1.hex.decode(s);
+        }
+        catch {
+            throw new Error("invalid format, must be hex");
+        }
+        return AssetGroup.fromBytes(buf);
+    }
+    static fromBytes(buf) {
+        if (!buf || buf.length === 0) {
+            throw new Error("missing asset group");
+        }
+        const reader = new utils_1.BufferReader(buf);
+        return AssetGroup.fromReader(reader);
+    }
+    // an issuance is a group with null assetId
+    isIssuance() {
+        return this.assetId === null;
+    }
+    // a reissuance is a group that is not an issuance
+    // but where the sum of the outputs is greater than the sum of the inputs
+    isReissuance() {
+        const sumReducer = (s, { amount }) => s + amount;
+        const sumOutputs = this.outputs.reduce(sumReducer, 0n);
+        const sumInputs = this.inputs
+            .map((i) => ({
+            amount: i.input.type === types_1.AssetInputType.Local ? i.input.amount : 0n,
+        }))
+            .reduce(sumReducer, 0n);
+        return !this.isIssuance() && sumInputs < sumOutputs;
+    }
+    serialize() {
+        this.validate();
+        const writer = new utils_1.BufferWriter();
+        this.serializeTo(writer);
+        return writer.toBytes();
+    }
+    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");
+            }
+        }
+    }
+    toBatchLeafAssetGroup(intentTxid) {
+        const leafInput = assetInput_1.AssetInput.createIntent(base_1.hex.encode(intentTxid), 0, 0);
+        return new AssetGroup(this.assetId, this.controlAsset, [leafInput], this.outputs, this.metadataList.items);
+    }
+    toString() {
+        return base_1.hex.encode(this.serialize());
+    }
+    static fromReader(reader) {
+        const presence = reader.readByte();
+        let assetId = null;
+        let controlAsset = null;
+        let metadata = [];
+        if (presence & types_1.MASK_ASSET_ID) {
+            assetId = assetId_1.AssetId.fromReader(reader);
+        }
+        if (presence & types_1.MASK_CONTROL_ASSET) {
+            controlAsset = assetRef_1.AssetRef.fromReader(reader);
+        }
+        if (presence & types_1.MASK_METADATA) {
+            metadata = metadata_1.MetadataList.fromReader(reader).items;
+        }
+        const inputs = assetInput_1.AssetInputs.fromReader(reader);
+        const outputs = assetOutput_1.AssetOutputs.fromReader(reader);
+        const ag = new AssetGroup(assetId, controlAsset, inputs.inputs, outputs.outputs, metadata);
+        ag.validate();
+        return ag;
+    }
+    serializeTo(writer) {
+        let presence = 0;
+        if (this.assetId !== null) {
+            presence |= types_1.MASK_ASSET_ID;
+        }
+        if (this.controlAsset !== null) {
+            presence |= types_1.MASK_CONTROL_ASSET;
+        }
+        if (this.metadataList.length > 0) {
+            presence |= types_1.MASK_METADATA;
+        }
+        writer.writeByte(presence);
+        if (presence & types_1.MASK_ASSET_ID) {
+            this.assetId.serializeTo(writer);
+        }
+        if (presence & types_1.MASK_CONTROL_ASSET) {
+            this.controlAsset.serializeTo(writer);
+        }
+        if (presence & types_1.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);
+        }
+    }
+}
+exports.AssetGroup = AssetGroup;

package/dist/cjs/asset/assetId.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetId = void 0;
+const base_1 = require("@scure/base");
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+/**
+ * AssetId represents the id of an asset.
+ * @param txid - the genesis transaction id (decoded from hex)
+ * @param groupIndex - the asset group index in the genesis transaction
+ */
+class AssetId {
+    constructor(txid, groupIndex) {
+        this.txid = txid;
+        this.groupIndex = groupIndex;
+    }
+    static create(txid, groupIndex) {
+        if (!txid) {
+            throw new Error("missing txid");
+        }
+        let buf;
+        try {
+            buf = base_1.hex.decode(txid);
+        }
+        catch {
+            throw new Error("invalid txid format, must be hex");
+        }
+        if (buf.length !== types_1.TX_HASH_SIZE) {
+            throw new Error(`invalid txid length: got ${buf.length} bytes, want ${types_1.TX_HASH_SIZE} bytes`);
+        }
+        const assetId = new AssetId(buf, groupIndex);
+        assetId.validate();
+        return assetId;
+    }
+    static fromString(s) {
+        let buf;
+        try {
+            buf = base_1.hex.decode(s);
+        }
+        catch {
+            throw new Error("invalid asset id format, must be hex");
+        }
+        return AssetId.fromBytes(buf);
+    }
+    static fromBytes(buf) {
+        if (!buf || buf.length === 0) {
+            throw new Error("missing asset id");
+        }
+        if (buf.length !== types_1.ASSET_ID_SIZE) {
+            throw new Error(`invalid asset id length: got ${buf.length} bytes, want ${types_1.ASSET_ID_SIZE} bytes`);
+        }
+        const reader = new utils_1.BufferReader(buf);
+        return AssetId.fromReader(reader);
+    }
+    serialize() {
+        const writer = new utils_1.BufferWriter();
+        this.serializeTo(writer);
+        return writer.toBytes();
+    }
+    toString() {
+        return base_1.hex.encode(this.serialize());
+    }
+    validate() {
+        if ((0, utils_1.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]`);
+        }
+    }
+    static fromReader(reader) {
+        if (reader.remaining() < types_1.ASSET_ID_SIZE) {
+            throw new Error(`invalid asset id length: got ${reader.remaining()}, want ${types_1.ASSET_ID_SIZE}`);
+        }
+        const txid = reader.readSlice(types_1.TX_HASH_SIZE);
+        const index = reader.readUint16LE();
+        const assetId = new AssetId(txid, index);
+        assetId.validate();
+        return assetId;
+    }
+    serializeTo(writer) {
+        writer.write(this.txid);
+        writer.writeUint16LE(this.groupIndex);
+    }
+}
+exports.AssetId = AssetId;

package/dist/cjs/asset/assetInput.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetInputs = exports.AssetInput = void 0;
+const base_1 = require("@scure/base");
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+/**
+ * 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.
+ */
+class AssetInput {
+    constructor(input) {
+        this.input = input;
+    }
+    get vin() {
+        return this.input.vin;
+    }
+    get amount() {
+        return this.input.amount;
+    }
+    static create(vin, amount) {
+        const input = new AssetInput({
+            type: types_1.AssetInputType.Local,
+            vin,
+            amount: typeof amount === "number" ? BigInt(amount) : amount,
+        });
+        input.validate();
+        return input;
+    }
+    static createIntent(txid, vin, amount) {
+        if (!txid || txid.length === 0) {
+            throw new Error("missing input intent txid");
+        }
+        let buf;
+        try {
+            buf = base_1.hex.decode(txid);
+        }
+        catch {
+            throw new Error("invalid input intent txid format, must be hex");
+        }
+        if (buf.length !== types_1.TX_HASH_SIZE) {
+            throw new Error("invalid input intent txid length");
+        }
+        const input = new AssetInput({
+            type: types_1.AssetInputType.Intent,
+            txid: buf,
+            vin,
+            amount: typeof amount === "number" ? BigInt(amount) : amount,
+        });
+        input.validate();
+        return input;
+    }
+    static fromString(s) {
+        let buf;
+        try {
+            buf = base_1.hex.decode(s);
+        }
+        catch {
+            throw new Error("invalid format, must be hex");
+        }
+        return AssetInput.fromBytes(buf);
+    }
+    static fromBytes(buf) {
+        const reader = new utils_1.BufferReader(buf);
+        return AssetInput.fromReader(reader);
+    }
+    serialize() {
+        const writer = new utils_1.BufferWriter();
+        this.serializeTo(writer);
+        return writer.toBytes();
+    }
+    toString() {
+        return base_1.hex.encode(this.serialize());
+    }
+    validate() {
+        switch (this.input.type) {
+            case types_1.AssetInputType.Local:
+                break;
+            case types_1.AssetInputType.Intent:
+                if ((0, utils_1.isZeroBytes)(this.input.txid)) {
+                    throw new Error("missing input intent txid");
+                }
+                break;
+        }
+    }
+    static fromReader(reader) {
+        const type = reader.readByte();
+        let input;
+        switch (type) {
+            case types_1.AssetInputType.Local: {
+                const vin = reader.readUint16LE();
+                const amount = reader.readVarUint();
+                input = new AssetInput({
+                    type: types_1.AssetInputType.Local,
+                    vin,
+                    amount,
+                });
+                break;
+            }
+            case types_1.AssetInputType.Intent: {
+                if (reader.remaining() < types_1.TX_HASH_SIZE) {
+                    throw new Error("invalid input intent txid length");
+                }
+                const txid = reader.readSlice(types_1.TX_HASH_SIZE);
+                const vin = reader.readUint16LE();
+                const amount = reader.readVarUint();
+                input = new AssetInput({
+                    type: types_1.AssetInputType.Intent,
+                    txid: new Uint8Array(txid),
+                    vin,
+                    amount,
+                });
+                break;
+            }
+            case types_1.AssetInputType.Unspecified:
+                throw new Error("asset input type unspecified");
+            default:
+                throw new Error(`asset input type ${type} unknown`);
+        }
+        input.validate();
+        return input;
+    }
+    serializeTo(writer) {
+        writer.writeByte(this.input.type);
+        if (this.input.type === types_1.AssetInputType.Intent) {
+            writer.write(this.input.txid);
+        }
+        writer.writeUint16LE(this.input.vin);
+        writer.writeVarUint(this.input.amount);
+    }
+}
+exports.AssetInput = AssetInput;
+/**
+ * AssetInputs represents a list of asset inputs.
+ */
+class AssetInputs {
+    constructor(inputs) {
+        this.inputs = inputs;
+    }
+    static create(inputs) {
+        const list = new AssetInputs(inputs);
+        list.validate();
+        return list;
+    }
+    static fromString(s) {
+        if (!s || s.length === 0) {
+            throw new Error("missing asset inputs");
+        }
+        let buf;
+        try {
+            buf = base_1.hex.decode(s);
+        }
+        catch {
+            throw new Error("invalid asset inputs format, must be hex");
+        }
+        const reader = new utils_1.BufferReader(buf);
+        return AssetInputs.fromReader(reader);
+    }
+    serialize() {
+        const writer = new utils_1.BufferWriter();
+        this.serializeTo(writer);
+        return writer.toBytes();
+    }
+    toString() {
+        return base_1.hex.encode(this.serialize());
+    }
+    validate() {
+        const seen = new Set();
+        let listType = types_1.AssetInputType.Unspecified;
+        for (const assetInput of this.inputs) {
+            assetInput.validate();
+            if (listType === types_1.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 === types_1.AssetInputType.Local) {
+                if (seen.has(assetInput.input.vin)) {
+                    throw new Error(`duplicated input vin ${assetInput.input.vin}`);
+                }
+                seen.add(assetInput.input.vin);
+                continue;
+            }
+        }
+    }
+    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);
+    }
+    serializeTo(writer) {
+        writer.writeVarUint(this.inputs.length);
+        for (const input of this.inputs) {
+            input.serializeTo(writer);
+        }
+    }
+}
+exports.AssetInputs = AssetInputs;

package/dist/cjs/asset/assetOutput.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetOutputs = exports.AssetOutput = void 0;
+const base_1 = require("@scure/base");
+const utils_1 = require("./utils");
+/**
+ * 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
+ */
+class AssetOutput {
+    constructor(vout, amount) {
+        this.vout = vout;
+        this.amount = amount;
+    }
+    static create(vout, amount) {
+        const output = new AssetOutput(vout, typeof amount === "number" ? BigInt(amount) : amount);
+        output.validate();
+        return output;
+    }
+    static fromString(s) {
+        let buf;
+        try {
+            buf = base_1.hex.decode(s);
+        }
+        catch {
+            throw new Error("invalid asset output format, must be hex");
+        }
+        return AssetOutput.fromBytes(buf);
+    }
+    static fromBytes(buf) {
+        if (!buf || buf.length === 0) {
+            throw new Error("missing asset output");
+        }
+        const reader = new utils_1.BufferReader(buf);
+        const output = AssetOutput.fromReader(reader);
+        output.validate();
+        return output;
+    }
+    serialize() {
+        const writer = new utils_1.BufferWriter();
+        this.serializeTo(writer);
+        return writer.toBytes();
+    }
+    toString() {
+        return base_1.hex.encode(this.serialize());
+    }
+    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");
+        }
+    }
+    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);
+    }
+    serializeTo(writer) {
+        writer.writeByte(0x01);
+        writer.writeUint16LE(this.vout);
+        writer.writeVarUint(this.amount);
+    }
+}
+exports.AssetOutput = AssetOutput;
+// 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
+ */
+class AssetOutputs {
+    constructor(outputs) {
+        this.outputs = outputs;
+    }
+    static create(outputs) {
+        const list = new AssetOutputs(outputs);
+        list.validate();
+        return list;
+    }
+    static fromString(s) {
+        if (!s || s.length === 0) {
+            throw new Error("missing asset outputs");
+        }
+        let buf;
+        try {
+            buf = base_1.hex.decode(s);
+        }
+        catch {
+            throw new Error("invalid asset outputs format, must be hex");
+        }
+        const reader = new utils_1.BufferReader(buf);
+        return AssetOutputs.fromReader(reader);
+    }
+    serialize() {
+        const writer = new utils_1.BufferWriter();
+        this.serializeTo(writer);
+        return writer.toBytes();
+    }
+    toString() {
+        return base_1.hex.encode(this.serialize());
+    }
+    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);
+        }
+    }
+    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;
+    }
+    serializeTo(writer) {
+        this.validate();
+        writer.writeVarUint(this.outputs.length);
+        for (const output of this.outputs) {
+            output.serializeTo(writer);
+        }
+    }
+}
+exports.AssetOutputs = AssetOutputs;

package/dist/cjs/asset/assetRef.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetRef = void 0;
+const base_1 = require("@scure/base");
+const types_1 = require("./types");
+const assetId_1 = require("./assetId");
+const utils_1 = require("./utils");
+class AssetRef {
+    constructor(ref) {
+        this.ref = ref;
+    }
+    get type() {
+        return this.ref.type;
+    }
+    static fromId(assetId) {
+        return new AssetRef({ type: types_1.AssetRefType.ByID, assetId });
+    }
+    static fromGroupIndex(groupIndex) {
+        return new AssetRef({ type: types_1.AssetRefType.ByGroup, groupIndex });
+    }
+    static fromString(s) {
+        let buf;
+        try {
+            buf = base_1.hex.decode(s);
+        }
+        catch {
+            throw new Error("invalid asset ref format, must be hex");
+        }
+        return AssetRef.fromBytes(buf);
+    }
+    static fromBytes(buf) {
+        if (!buf || buf.length === 0) {
+            throw new Error("missing asset ref");
+        }
+        const reader = new utils_1.BufferReader(buf);
+        return AssetRef.fromReader(reader);
+    }
+    serialize() {
+        const writer = new utils_1.BufferWriter();
+        this.serializeTo(writer);
+        return writer.toBytes();
+    }
+    toString() {
+        return base_1.hex.encode(this.serialize());
+    }
+    static fromReader(reader) {
+        const type = reader.readByte();
+        let ref;
+        switch (type) {
+            case types_1.AssetRefType.ByID: {
+                const assetId = assetId_1.AssetId.fromReader(reader);
+                ref = new AssetRef({ type: types_1.AssetRefType.ByID, assetId });
+                break;
+            }
+            case types_1.AssetRefType.ByGroup: {
+                if (reader.remaining() < 2) {
+                    throw new Error("invalid asset ref length");
+                }
+                const groupIndex = reader.readUint16LE();
+                ref = new AssetRef({ type: types_1.AssetRefType.ByGroup, groupIndex });
+                break;
+            }
+            case types_1.AssetRefType.Unspecified:
+                throw new Error("asset ref type unspecified");
+            default:
+                throw new Error(`asset ref type unknown ${type}`);
+        }
+        return ref;
+    }
+    serializeTo(writer) {
+        writer.writeByte(this.ref.type);
+        switch (this.ref.type) {
+            case types_1.AssetRefType.ByID:
+                this.ref.assetId.serializeTo(writer);
+                break;
+            case types_1.AssetRefType.ByGroup:
+                writer.writeUint16LE(this.ref.groupIndex);
+                break;
+        }
+    }
+}
+exports.AssetRef = AssetRef;

package/dist/cjs/asset/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetPacketNotFoundError = exports.Packet = exports.AssetGroup = exports.MetadataList = exports.Metadata = exports.AssetOutputs = exports.AssetOutput = exports.AssetInputs = exports.AssetInput = exports.AssetRef = exports.AssetId = exports.AssetRefType = exports.AssetInputType = void 0;
+var types_1 = require("./types");
+Object.defineProperty(exports, "AssetInputType", { enumerable: true, get: function () { return types_1.AssetInputType; } });
+Object.defineProperty(exports, "AssetRefType", { enumerable: true, get: function () { return types_1.AssetRefType; } });
+var assetId_1 = require("./assetId");
+Object.defineProperty(exports, "AssetId", { enumerable: true, get: function () { return assetId_1.AssetId; } });
+var assetRef_1 = require("./assetRef");
+Object.defineProperty(exports, "AssetRef", { enumerable: true, get: function () { return assetRef_1.AssetRef; } });
+var assetInput_1 = require("./assetInput");
+Object.defineProperty(exports, "AssetInput", { enumerable: true, get: function () { return assetInput_1.AssetInput; } });
+Object.defineProperty(exports, "AssetInputs", { enumerable: true, get: function () { return assetInput_1.AssetInputs; } });
+var assetOutput_1 = require("./assetOutput");
+Object.defineProperty(exports, "AssetOutput", { enumerable: true, get: function () { return assetOutput_1.AssetOutput; } });
+Object.defineProperty(exports, "AssetOutputs", { enumerable: true, get: function () { return assetOutput_1.AssetOutputs; } });
+var metadata_1 = require("./metadata");
+Object.defineProperty(exports, "Metadata", { enumerable: true, get: function () { return metadata_1.Metadata; } });
+Object.defineProperty(exports, "MetadataList", { enumerable: true, get: function () { return metadata_1.MetadataList; } });
+var assetGroup_1 = require("./assetGroup");
+Object.defineProperty(exports, "AssetGroup", { enumerable: true, get: function () { return assetGroup_1.AssetGroup; } });
+var packet_1 = require("./packet");
+Object.defineProperty(exports, "Packet", { enumerable: true, get: function () { return packet_1.Packet; } });
+Object.defineProperty(exports, "AssetPacketNotFoundError", { enumerable: true, get: function () { return packet_1.AssetPacketNotFoundError; } });