phantasma-sdk-ts 0.1.76 → 0.2.0-rc.1

package/dist/core/types/Extensions/PBinaryReader.js

@@ -0,0 +1,235 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PBinaryReader = void 0;
+const big_integer_1 = __importDefault(require("big-integer"));
+const csharp_binary_stream_1 = require("csharp-binary-stream");
+const interfaces_1 = require("../../interfaces");
+const utils_1 = require("../../utils");
+const vm_1 = require("../../vm");
+const Ed25519Signature_1 = require("../Ed25519Signature");
+const Timestamp_1 = require("../Timestamp");
+class PBinaryReader {
+    get length() {
+        return this.reader.length;
+    }
+    get position() {
+        return this.reader.position;
+    }
+    set position(value) {
+        this.reader.position = value;
+    }
+    get isEndOfStream() {
+        return this.reader.isEndOfStream;
+    }
+    readBoolean() {
+        return this.reader.readBoolean();
+    }
+    readByte() {
+        return this.reader.readByte();
+    }
+    readBytes(bytesToRead) {
+        return this.reader.readBytes(bytesToRead);
+    }
+    readSignedByte() {
+        return this.reader.readSignedByte();
+    }
+    readShort() {
+        return this.reader.readShort();
+    }
+    readUnsignedShort() {
+        return this.reader.readUnsignedShort();
+    }
+    readInt() {
+        return this.reader.readInt();
+    }
+    readUnsignedInt() {
+        return this.reader.readUnsignedInt();
+    }
+    readLongString() {
+        return this.reader.readLongString();
+    }
+    readLong() {
+        return this.reader.readLong();
+    }
+    readUnsignedLongString() {
+        return this.reader.readUnsignedLongString();
+    }
+    readUnsignedLong() {
+        return this.reader.readUnsignedLong();
+    }
+    readFloat() {
+        return this.reader.readFloat();
+    }
+    readDouble() {
+        return this.reader.readDouble();
+    }
+    readChar(encoding) {
+        return this.reader.readChar(encoding);
+    }
+    readChars(charactersToRead, encoding) {
+        return this.reader.readChars(charactersToRead, encoding);
+    }
+    readCharBytes(bytesToRead, encoding) {
+        return this.reader.readCharBytes(bytesToRead, encoding);
+    }
+    constructor(arg1) {
+        this.reader = new csharp_binary_stream_1.BinaryReader(arg1);
+    }
+    read(numBytes) {
+        var res = (0, utils_1.bytesToHex)(this.readBytes(numBytes)).substr(0, numBytes * 2);
+        //this.position += numBytes;
+        return res;
+    }
+    readString() {
+        var len = this.readVarInt();
+        return this.readStringBytes(len);
+    }
+    readStringBytes(numBytes) {
+        var res = '';
+        for (var i = 0; i < numBytes; ++i) {
+            res += String.fromCharCode(this.readByte());
+        }
+        return res;
+    }
+    readBigInteger() {
+        // TO DO: implement negative numbers
+        var len = this.readVarInt();
+        var res = 0;
+        var stringBytes = this.read(len);
+        [...stringBytes.match(/.{1,2}/g)]
+            .reverse()
+            .forEach((c) => (res = res * 256 + parseInt(c, 16)));
+        let bigInt = BigInt(res);
+        return bigInt;
+    }
+    readBigIntAccurate() {
+        var len = this.readVarInt();
+        var res = (0, big_integer_1.default)();
+        var stringBytes = this.read(len);
+        [...stringBytes.match(/.{1,2}/g)].reverse().forEach((c) => {
+            res = res.times(256).plus(parseInt(c, 16));
+        });
+        return res.toString();
+    }
+    readSignatureV2() {
+        let kind = this.readByte();
+        let curve;
+        let signature = new Ed25519Signature_1.Ed25519Signature();
+        switch (kind) {
+            case interfaces_1.SignatureKind.None:
+                return null;
+            case interfaces_1.SignatureKind.Ed25519:
+                let len = this.readVarInt();
+                signature.Bytes = (0, utils_1.stringToUint8Array)(this.read(len));
+                break;
+            case interfaces_1.SignatureKind.ECDSA:
+                curve = this.readByte();
+                signature.Bytes = (0, utils_1.stringToUint8Array)(this.readString());
+                break;
+            default:
+                throw 'read signature: ' + kind;
+        }
+        return signature;
+    }
+    readSignature() {
+        let kind = this.readByte();
+        let signature = new Ed25519Signature_1.Ed25519Signature();
+        let curve;
+        signature.Kind = kind;
+        switch (kind) {
+            case interfaces_1.SignatureKind.None:
+                return null;
+            case interfaces_1.SignatureKind.Ed25519:
+                let len = this.readVarInt();
+                signature.Bytes = (0, utils_1.stringToUint8Array)(this.read(len));
+                break;
+            case interfaces_1.SignatureKind.ECDSA:
+                curve = this.readByte();
+                signature.Bytes = (0, utils_1.stringToUint8Array)(this.readString());
+                break;
+            default:
+                throw 'read signature: ' + kind;
+        }
+        return signature;
+    }
+    readByteArray() {
+        var res;
+        var length = this.readVarInt();
+        if (length == 0)
+            return [];
+        res = this.read(length);
+        return res;
+    }
+    readTimestamp() {
+        //var len = this.readByte();
+        let result = 0;
+        let bytes = this.read(4);
+        //[...(bytes.match(/.{1,2}/g) as any)];
+        bytes
+            .match(/.{1,2}/g)
+            .reverse()
+            .forEach((c) => (result = result * 256 + parseInt(c, 16)));
+        let timestamp = new Timestamp_1.Timestamp(result);
+        return timestamp;
+    }
+    readVarInt() {
+        var len = this.readByte();
+        var res = 0;
+        if (len === 0xfd) {
+            [...this.read(2).match(/.{1,2}/g)]
+                .reverse()
+                .forEach((c) => (res = res * 256 + parseInt(c, 16)));
+            return res;
+        }
+        else if (len === 0xfe) {
+            [...this.read(4).match(/.{1,2}/g)]
+                .reverse()
+                .forEach((c) => (res = res * 256 + parseInt(c, 16)));
+            return res;
+        }
+        else if (len === 0xff) {
+            [...this.read(8).match(/.{1,2}/g)]
+                .reverse()
+                .forEach((c) => (res = res * 256 + parseInt(c, 16)));
+            return res;
+        }
+        return len;
+    }
+    readVarString() {
+        var len = this.readVarInt();
+        if (len == 0)
+            return '';
+        return this.readStringBytes(len);
+    }
+    readVmObject() {
+        const type = this.readByte();
+        switch (type) {
+            case vm_1.VMType.String:
+                return this.readString();
+            case vm_1.VMType.Number:
+                return this.readBigIntAccurate();
+            case vm_1.VMType.Bool:
+                return this.readByte() != 0;
+            case vm_1.VMType.Struct:
+                const numFields = this.readVarInt();
+                let res = {};
+                for (let i = 0; i < numFields; ++i) {
+                    const key = this.readVmObject();
+                    const value = this.readVmObject();
+                    res[key] = value;
+                }
+                return res;
+            case vm_1.VMType.Enum:
+                return this.readVarInt();
+            case vm_1.VMType.Object:
+                const numBytes = this.readVarInt();
+                return this.read(numBytes);
+            default:
+                return 'unsupported type ' + type;
+        }
+    }
+}
+exports.PBinaryReader = PBinaryReader;

package/{core → dist/core}/types/Extensions/PBinaryWriter.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
-import { Encoding } from "csharp-binary-stream";
-import { Signature } from "../../interfaces";
-import { Timestamp } from "../Timestamp";
+import { Encoding } from 'csharp-binary-stream';
+import { Signature } from '../../interfaces';
+import { Timestamp } from '../Timestamp';
 type byte = number;
 export declare class PBinaryWriter {
     private writer;
@@ -30,7 +30,7 @@ export declare class PBinaryWriter {
     toArray(): number[];
     toUint8Array(): Uint8Array;
     appendByte(value: number): this;
-    appendBytes(bytes: byte[]): void;
+    appendBytes(bytes: Uint8Array): void;
     writeEnum(value: number): this;
     writeBytes(bytes: byte[]): this;
     writeVarInt(value: number): this;
@@ -43,7 +43,7 @@ export declare class PBinaryWriter {
     writeBigInteger(value: BigInt): this;
     writeBigIntegerString(value: string): this;
     writeSignature(signature: Signature): this;
-    AppendHexEncoded(bytes: string): this;
+    AppendHexEncoded(bytesHex: string): this;
 }
 export {};
 //# sourceMappingURL=PBinaryWriter.d.ts.map

package/dist/core/types/Extensions/PBinaryWriter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PBinaryWriter.d.ts","sourceRoot":"","sources":["../../../../src/core/types/Extensions/PBinaryWriter.ts"],"names":[],"mappings":";AAEA,OAAO,EAAgB,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAE9D,OAAO,EAAc,SAAS,EAAiB,MAAM,kBAAkB,CAAC;AACxE,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC,KAAK,IAAI,GAAG,MAAM,CAAC;AAEnB,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;gBACJ,IAAI,CAAC,EAAE,SAAS,GAAG,MAAM,GAAG,UAAU,GAAG,IAAI;IAIzD,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,IAAI,QAAQ,CAAC,KAAK,EAAE,MAAM,EAEzB;IAED,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IAIlC,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAG9B,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAGnD,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAGpC,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAG/B,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAGvC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAG7B,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAGrC,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAGvC,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAG/C,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAG/B,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAGhC,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAG/D,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAGnE,KAAK,IAAI,IAAI;IAGb,OAAO,IAAI,MAAM,EAAE;IAGnB,YAAY,IAAI,UAAU;IAInB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAK/B,WAAW,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAMpC,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAarC,UAAU,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,IAAI;IAOxB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAuChC,cAAc,CAAC,GAAG,EAAE,SAAS,GAAG,IAAI;IAapC,aAAa,CAAC,GAAG,EAAE,IAAI,GAAG,IAAI;IAarC,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE;IAQ3B,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,UAAU;IAS3C,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAO/B,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAkB/B,eAAe,CAAC,KAAK,EAAE,MAAM;IAI7B,qBAAqB,CAAC,KAAK,EAAE,MAAM;IAuBnC,cAAc,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI;IAU1C,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;CAMhD"}

package/dist/core/types/Extensions/PBinaryWriter.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PBinaryWriter = void 0;
+const csharp_binary_stream_1 = require("csharp-binary-stream");
+const __1 = require("../..");
+const interfaces_1 = require("../../interfaces");
+class PBinaryWriter {
+    constructor(arg1) {
+        this.writer = new csharp_binary_stream_1.BinaryWriter(arg1);
+    }
+    get length() {
+        return this.writer.length;
+    }
+    get position() {
+        return this.writer.position;
+    }
+    set position(value) {
+        this.writer.position = value;
+    }
+    writeBoolean(value) {
+        this.writer.writeBoolean(value);
+    }
+    writeByte(value) {
+        this.writer.writeByte(value);
+    }
+    writeSameByte(value, repeats) {
+        this.writer.writeSameByte(value, repeats);
+    }
+    writeSignedByte(value) {
+        this.writer.writeSignedByte(value);
+    }
+    writeShort(value) {
+        this.writer.writeShort(value);
+    }
+    writeUnsignedShort(value) {
+        this.writer.writeUnsignedShort(value);
+    }
+    writeInt(value) {
+        this.writer.writeInt(value);
+    }
+    writeUnsignedInt(value) {
+        this.writer.writeUnsignedInt(value);
+    }
+    writeLong(value) {
+        this.writer.writeLong(value);
+    }
+    writeUnsignedLong(value) {
+        this.writer.writeUnsignedLong(value);
+    }
+    writeFloat(value) {
+        this.writer.writeFloat(value);
+    }
+    writeDouble(value) {
+        this.writer.writeDouble(value);
+    }
+    writeChar(character, encoding) {
+        this.writer.writeChar(character, encoding);
+    }
+    writeChars(characters, encoding) {
+        this.writer.writeChars(characters, encoding);
+    }
+    clear() {
+        this.writer.clear();
+    }
+    toArray() {
+        return this.writer.toArray();
+    }
+    toUint8Array() {
+        return this.writer.toUint8Array();
+    }
+    appendByte(value) {
+        this.writeByte(value);
+        return this;
+    }
+    appendBytes(bytes) {
+        for (let i = 0; i < bytes.length; i++) {
+            this.appendByte(bytes[i]);
+        }
+    }
+    writeEnum(value) {
+        const bytes = new Uint8Array(4);
+        for (let i = 0; i < bytes.length; i++) {
+            const byte = value & 0xff;
+            bytes[i] = byte;
+            value = (value - byte) / 256;
+        }
+        this.appendBytes(bytes);
+        return this;
+    }
+    writeBytes(bytes) {
+        for (let i = 0; i < bytes.length; i++)
+            this.appendByte(bytes[i]);
+        // writer.Write(bytes);
+        return this;
+    }
+    writeVarInt(value) {
+        if (value < 0)
+            throw 'negative value invalid';
+        if (value < 0xfd) {
+            this.appendByte(value);
+        }
+        else if (value <= 0xffff) {
+            let B = (value & 0x0000ff00) >> 8;
+            let A = value & 0x000000ff;
+            // TODO check if the endianess is correct, might have to reverse order of appends
+            this.appendByte(0xfd);
+            this.appendByte(A);
+            this.appendByte(B);
+        }
+        else if (value <= 0xffffffff) {
+            let C = (value & 0x00ff0000) >> 16;
+            let B = (value & 0x0000ff00) >> 8;
+            let A = value & 0x000000ff;
+            // TODO check if the endianess is correct, might have to reverse order of appends
+            this.appendByte(0xfe);
+            this.appendByte(A);
+            this.appendByte(B);
+            this.appendByte(C);
+        }
+        else {
+            let D = (value & 0xff000000) >> 24;
+            let C = (value & 0x00ff0000) >> 16;
+            let B = (value & 0x0000ff00) >> 8;
+            let A = value & 0x000000ff;
+            // TODO check if the endianess is correct, might have to reverse order of appends
+            this.appendByte(0xff);
+            this.appendByte(A);
+            this.appendByte(B);
+            this.appendByte(C);
+            this.appendByte(D);
+        }
+        return this;
+    }
+    writeTimestamp(obj) {
+        let num = obj.value;
+        let a = (num & 0xff000000) >> 24;
+        let b = (num & 0x00ff0000) >> 16;
+        let c = (num & 0x0000ff00) >> 8;
+        let d = num & 0x000000ff;
+        let bytes = Uint8Array.from([d, c, b, a]);
+        this.appendBytes(bytes);
+        return this;
+    }
+    writeDateTime(obj) {
+        let num = (obj.getTime() / 1000) | 0;
+        let a = (num & 0xff000000) >> 24;
+        let b = (num & 0x00ff0000) >> 16;
+        let c = (num & 0x0000ff00) >> 8;
+        let d = num & 0x000000ff;
+        let bytes = Uint8Array.from([d, c, b, a]);
+        this.appendBytes(bytes);
+        return this;
+    }
+    rawString(value) {
+        var data = [];
+        for (var i = 0; i < value.length; i++) {
+            data.push(value.charCodeAt(i));
+        }
+        return data;
+    }
+    writeByteArray(bytes) {
+        if (bytes instanceof Uint8Array) {
+            bytes = Array.from(bytes);
+        }
+        this.writeVarInt(bytes.length);
+        this.writeBytes(bytes);
+        return this;
+    }
+    writeString(text) {
+        let bytes = this.rawString(text);
+        this.writeVarInt(bytes.length);
+        this.writeBytes(bytes);
+        return this;
+    }
+    emitUInt32(value) {
+        if (value < 0)
+            throw 'negative value invalid';
+        let D = (value & 0xff000000) >> 24;
+        let C = (value & 0x00ff0000) >> 16;
+        let B = (value & 0x0000ff00) >> 8;
+        let A = value & 0x000000ff;
+        // TODO check if the endianess is correct, might have to reverse order of appends
+        this.appendByte(0xff);
+        this.appendByte(A);
+        this.appendByte(B);
+        this.appendByte(C);
+        this.appendByte(D);
+        return this;
+    }
+    writeBigInteger(value) {
+        return this.writeBigIntegerString(value.toString());
+    }
+    writeBigIntegerString(value) {
+        let bytes = [];
+        if (value == '0') {
+            bytes = [0];
+        }
+        else if (value.startsWith('-1')) {
+            throw new Error('Unsigned bigint serialization not suppoted');
+        }
+        else {
+            let hex = BigInt(value).toString(16);
+            if (hex.length % 2)
+                hex = '0' + hex;
+            const len = hex.length / 2;
+            var i = 0;
+            var j = 0;
+            while (i < len) {
+                bytes.unshift(parseInt(hex.slice(j, j + 2), 16)); // little endian
+                i += 1;
+                j += 2;
+            }
+            bytes.push(0); // add sign at the end
+        }
+        return this.writeByteArray(bytes);
+    }
+    writeSignature(signature) {
+        if (!signature) {
+            this.writeByte(interfaces_1.SignatureKind.None);
+            return this;
+        }
+        this.writeByte(signature.Kind);
+        signature.SerializeData(this);
+        return this;
+    }
+    AppendHexEncoded(bytesHex) {
+        let bytes = (0, __1.hexToBytes)(bytesHex);
+        this.writeVarInt(bytes.length);
+        this.appendBytes(bytes);
+        return this;
+    }
+}
+exports.PBinaryWriter = PBinaryWriter;

package/dist/core/types/Extensions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/core/types/Extensions/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC"}

package/dist/core/types/PhantasmaBigIntSerialization.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Phantasma BigInt serialization (VarBytes-style)
+ *
+ * This module implements Phantasma serialization for signed big integers (bigint):
+ * - Representation is two's complement, little-endian (LE)
+ * - On the wire it follows the historical Phantasma/C# behavior:
+ *   1) Build a C#-compatible LE byte array for the integer (two's complement)
+ *      * Positive numbers get a leading 0x00 guard byte at the most significant side if needed
+ *      * Negative numbers get a two's complement form with MSB sign bit set (0x80) at the most significant byte
+ *   2) Apply Phantasma-specific trailing rule (aka tail guard):
+ *      * For positives: append 0x00 if the last byte is not already 0x00
+ *      * For negatives: append 0xFF to preserve sign extension (for -1 expects [FF,FF,FF])
+ *
+ * Reading (deserialization) reverses the process:
+ * - Decode two's complement from LE payload
+ * - For positives: treat the payload as a plain LE magnitude
+ * - For negatives: invert and add 1, then negate the resulting magnitude
+ *
+ * Notes
+ * - Little-endian (LE) means the least-significant byte comes first
+ * - Two's complement guarantees a unique representation for zero and correct ordering for negatives
+ * - This file intentionally mirrors Go/C# reference behavior for byte-for-byte compatibility
+ */
+/**
+ * Build a C#-compatible two's complement (LE) byte array for a signed bigint
+ * Steps:
+ * 1) Handle zero early as [0x00]
+ * 2) For positives:
+ *    - Extract magnitude bytes in LE order
+ *    - If the most significant byte (MSB) would imply a negative (bit 7 set), append 0x00 guard
+ * 3) For negatives:
+ *    - Start from magnitude of |n|, invert all bytes and add 1 (two's complement in LE)
+ *    - Ensure MSB has sign bit set (append 0xFF if needed)
+ * Result: a minimal LE two's complement array compatible with C# BigInteger byte layout
+ */
+export declare function bigIntToCsharpLE(n: bigint): Uint8Array;
+/**
+ * Serialize bigint to Phantasma byte array (LE two's complement with trailing tail guard)
+ * Process:
+ * - First, build the C#-style two's complement bytes (LE) via toCsharpLE
+ * - Then apply Phantasma tail rule:
+ *   * Positive: ensure the last byte is 0x00 by appending one if necessary
+ *   * Negative: append 0xFF to keep sign-extension stable; for -1 specifically
+ *     expectation is [FF, FF, FF] (single-byte 0xFF followed by two 0xFF guard bytes)
+ * The resulting array matches historical Go/C# Phantasma serialization byte-for-byte
+ */
+export declare function bigIntToTwosComplementLE_phantasma(n: bigint): Uint8Array;
+/**
+ * Deserialize Phantasma two's complement (LE) byte array back to bigint
+ * Logic:
+ * - Determine sign from the most significant byte's sign bit (bit 7)
+ * - For non-negative payloads:
+ *   * Interpret as a plain LE magnitude (ignore trailing 0x00 guard if present)
+ * - For negative payloads:
+ *   * Compute two's complement back in LE (invert bytes, add 1) and negate the magnitude
+ * This matches Go/C# reader behavior and roundtrips values produced by the serializer
+ */
+export declare function bigIntFromTwosComplementLE_phantasma(data: Uint8Array): bigint;
+//# sourceMappingURL=PhantasmaBigIntSerialization.d.ts.map

package/dist/core/types/PhantasmaBigIntSerialization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhantasmaBigIntSerialization.d.ts","sourceRoot":"","sources":["../../../src/core/types/PhantasmaBigIntSerialization.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;;;;;;;;GAWG;AAEH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU,CAmDtD;AAED;;;;;;;;;GASG;AAGH,wBAAgB,kCAAkC,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU,CAuBxE;AACD;;;;;;;;;GASG;AAGH,wBAAgB,oCAAoC,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CA+B7E"}