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

package/dist/esm/asset/assetGroup.js

@@ -0,0 +1,137 @@
+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.
+ */
+export class AssetGroup {
+    constructor(assetId, controlAsset, inputs, outputs, metadata) {
+        this.assetId = assetId;
+        this.controlAsset = controlAsset;
+        this.inputs = inputs;
+        this.outputs = outputs;
+        this.metadataList = new 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 = 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 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 === AssetInputType.Local ? i.input.amount : 0n,
+        }))
+            .reduce(sumReducer, 0n);
+        return !this.isIssuance() && sumInputs < sumOutputs;
+    }
+    serialize() {
+        this.validate();
+        const writer = new 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.createIntent(hex.encode(intentTxid), 0, 0);
+        return new AssetGroup(this.assetId, this.controlAsset, [leafInput], this.outputs, this.metadataList.items);
+    }
+    toString() {
+        return hex.encode(this.serialize());
+    }
+    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;
+    }
+    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/asset/assetId.js

@@ -0,0 +1,84 @@
+import { hex } from "@scure/base";
+import { TX_HASH_SIZE, ASSET_ID_SIZE } from './types.js';
+import { BufferReader, BufferWriter, isZeroBytes } from './utils.js';
+/**
+ * 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
+ */
+export 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 = 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;
+    }
+    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);
+    }
+    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() {
+        const writer = new BufferWriter();
+        this.serializeTo(writer);
+        return writer.toBytes();
+    }
+    toString() {
+        return hex.encode(this.serialize());
+    }
+    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]`);
+        }
+    }
+    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;
+    }
+    serializeTo(writer) {
+        writer.write(this.txid);
+        writer.writeUint16LE(this.groupIndex);
+    }
+}

package/dist/esm/asset/assetInput.js

@@ -0,0 +1,199 @@
+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;
+    }
+    get vin() {
+        return this.input.vin;
+    }
+    get amount() {
+        return this.input.amount;
+    }
+    static create(vin, amount) {
+        const input = new AssetInput({
+            type: 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 = 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;
+    }
+    static fromString(s) {
+        let buf;
+        try {
+            buf = hex.decode(s);
+        }
+        catch {
+            throw new Error("invalid format, must be hex");
+        }
+        return AssetInput.fromBytes(buf);
+    }
+    static fromBytes(buf) {
+        const reader = new BufferReader(buf);
+        return AssetInput.fromReader(reader);
+    }
+    serialize() {
+        const writer = new BufferWriter();
+        this.serializeTo(writer);
+        return writer.toBytes();
+    }
+    toString() {
+        return hex.encode(this.serialize());
+    }
+    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;
+        }
+    }
+    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;
+    }
+    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;
+    }
+    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 = hex.decode(s);
+        }
+        catch {
+            throw new Error("invalid asset inputs format, must be hex");
+        }
+        const reader = new BufferReader(buf);
+        return AssetInputs.fromReader(reader);
+    }
+    serialize() {
+        const writer = new BufferWriter();
+        this.serializeTo(writer);
+        return writer.toBytes();
+    }
+    toString() {
+        return hex.encode(this.serialize());
+    }
+    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;
+            }
+        }
+    }
+    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);
+        }
+    }
+}

package/dist/esm/asset/assetOutput.js

@@ -0,0 +1,154 @@
+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;
+    }
+    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 = 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 BufferReader(buf);
+        const output = AssetOutput.fromReader(reader);
+        output.validate();
+        return output;
+    }
+    serialize() {
+        const writer = new BufferWriter();
+        this.serializeTo(writer);
+        return writer.toBytes();
+    }
+    toString() {
+        return 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);
+    }
+}
+// 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;
+    }
+    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 = hex.decode(s);
+        }
+        catch {
+            throw new Error("invalid asset outputs format, must be hex");
+        }
+        const reader = new BufferReader(buf);
+        return AssetOutputs.fromReader(reader);
+    }
+    serialize() {
+        const writer = new BufferWriter();
+        this.serializeTo(writer);
+        return writer.toBytes();
+    }
+    toString() {
+        return 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);
+        }
+    }
+}

package/dist/esm/asset/assetRef.js

@@ -0,0 +1,78 @@
+import { hex } from "@scure/base";
+import { AssetRefType } from './types.js';
+import { AssetId } from './assetId.js';
+import { BufferReader, BufferWriter } from './utils.js';
+export class AssetRef {
+    constructor(ref) {
+        this.ref = ref;
+    }
+    get type() {
+        return this.ref.type;
+    }
+    static fromId(assetId) {
+        return new AssetRef({ type: AssetRefType.ByID, assetId });
+    }
+    static fromGroupIndex(groupIndex) {
+        return new AssetRef({ type: AssetRefType.ByGroup, groupIndex });
+    }
+    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);
+    }
+    static fromBytes(buf) {
+        if (!buf || buf.length === 0) {
+            throw new Error("missing asset ref");
+        }
+        const reader = new BufferReader(buf);
+        return AssetRef.fromReader(reader);
+    }
+    serialize() {
+        const writer = new BufferWriter();
+        this.serializeTo(writer);
+        return writer.toBytes();
+    }
+    toString() {
+        return hex.encode(this.serialize());
+    }
+    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;
+    }
+    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/asset/index.js

@@ -0,0 +1,8 @@
+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, AssetPacketNotFoundError } from './packet.js';