phantasma-sdk-ts 0.2.0-rc.9 → 0.2.1

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

@@ -0,0 +1,228 @@
+import BigInteger from 'big-integer';
+import { BinaryReader } from 'csharp-binary-stream';
+import { SignatureKind } from '../../interfaces';
+import { bytesToHex, stringToUint8Array } from '../../utils';
+import { VMType } from '../../vm';
+import { Ed25519Signature } from '../Ed25519Signature';
+import { Timestamp } from '../Timestamp';
+export 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 BinaryReader(arg1);
+    }
+    read(numBytes) {
+        var res = 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 = BigInteger();
+        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();
+        switch (kind) {
+            case SignatureKind.None:
+                return null;
+            case SignatureKind.Ed25519:
+                let len = this.readVarInt();
+                signature.Bytes = stringToUint8Array(this.read(len));
+                break;
+            case SignatureKind.ECDSA:
+                curve = this.readByte();
+                signature.Bytes = stringToUint8Array(this.readString());
+                break;
+            default:
+                throw 'read signature: ' + kind;
+        }
+        return signature;
+    }
+    readSignature() {
+        let kind = this.readByte();
+        let signature = new Ed25519Signature();
+        let curve;
+        signature.Kind = kind;
+        switch (kind) {
+            case SignatureKind.None:
+                return null;
+            case SignatureKind.Ed25519:
+                let len = this.readVarInt();
+                signature.Bytes = stringToUint8Array(this.read(len));
+                break;
+            case SignatureKind.ECDSA:
+                curve = this.readByte();
+                signature.Bytes = 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(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 VMType.String:
+                return this.readString();
+            case VMType.Number:
+                return this.readBigIntAccurate();
+            case VMType.Bool:
+                return this.readByte() != 0;
+            case 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 VMType.Enum:
+                return this.readVarInt();
+            case VMType.Object:
+                const numBytes = this.readVarInt();
+                return this.read(numBytes);
+            default:
+                return 'unsupported type ' + type;
+        }
+    }
+}

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

@@ -0,0 +1,229 @@
+import { BinaryWriter } from 'csharp-binary-stream';
+import { hexToBytes } from '../..';
+import { SignatureKind } from '../../interfaces';
+export class PBinaryWriter {
+    constructor(arg1) {
+        this.writer = new 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(SignatureKind.None);
+            return this;
+        }
+        this.writeByte(signature.Kind);
+        signature.SerializeData(this);
+        return this;
+    }
+    AppendHexEncoded(bytesHex) {
+        let bytes = hexToBytes(bytesHex);
+        this.writeVarInt(bytes.length);
+        this.appendBytes(bytes);
+        return this;
+    }
+}

package/dist/esm/core/types/Extensions/index.js

@@ -0,0 +1,4 @@
+export * from "./PBinaryReader";
+export * from "./PBinaryWriter";
+export * from "./Base16";
+export * from "./Describer";

package/dist/esm/core/types/PhantasmaBigIntSerialization.js

@@ -0,0 +1,166 @@
+/**
+ * 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 function bigIntToCsharpLE(n) {
+    // Zero has a single-byte canonical representation in C# BigInteger: [0x00]
+    if (n === 0n) {
+        return new Uint8Array([0x00]);
+    }
+    // Determine the sign once; all subsequent steps depend on it
+    const negative = n < 0n;
+    // Work with magnitude |n|; two’s complement for negative values will be applied later
+    let x = negative ? -n : n;
+    const bytes = [];
+    // Extract magnitude in little-endian order: push least-significant byte first
+    while (x > 0n) {
+        bytes.push(Number(x & 0xffn));
+        x >>= 8n;
+    }
+    // Positive value path
+    if (!negative) {
+        // Ensure non-negative sign
+        // If MSB would set the sign bit, append 0x00 so the value stays non-negative in two’s complement
+        if ((bytes[bytes.length - 1] & 0x80) !== 0) {
+            bytes.push(0x00);
+        }
+        return Uint8Array.from(bytes);
+    }
+    // Negative value path: build two’s complement directly in little-endian representation
+    // Two's complement in LE
+    for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = ~bytes[i] & 0xff;
+    }
+    // Step 2: add 1 to complete two’s complement (propagate carry across bytes)
+    // Step 2: add 1 to obtain the magnitude in LE (two’s complement reversal)
+    let carry = 1;
+    for (let i = 0; i < bytes.length; i++) {
+        const s = bytes[i] + carry;
+        bytes[i] = s & 0xff;
+        carry = s >> 8;
+        if (!carry)
+            break;
+    }
+    // If an extra carry remains, append it as a new most-significant byte
+    if (carry) {
+        bytes.push(carry);
+    }
+    // Ensure negative sign bit at MSB
+    // Ensure the resulting most-significant byte has the sign bit set to mark the value as negative
+    if ((bytes[bytes.length - 1] & 0x80) === 0) {
+        bytes.push(0xff);
+    }
+    return Uint8Array.from(bytes);
+}
+/**
+ * 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
+ */
+// Serialize to Phantasma wire format: start from C# bytes then apply trailing-byte rule
+export function bigIntToTwosComplementLE_phantasma(n) {
+    // 1) Build C#-compatible bytes (LE + sign-guard)
+    // Build C#-style LE two’s complement bytes first (minimal, sign-correct)
+    const cs = Array.from(bigIntToCsharpLE(n));
+    // 2) Apply Phantasma tail rules
+    // Phantasma trailing rule for negative values
+    if (n < 0n) {
+        // Historical special-case: single-byte negative values (like -1) must be extended to [FF, FF, FF] on the wire
+        if (cs.length === 1) {
+            cs.push(0xff, 0xff); // -1 → [FF,FF,FF]
+        }
+        else if (cs[cs.length - 1] === 0xff) {
+            cs.push(0xff);
+        }
+        // Phantasma trailing rule for non-negative values
+    }
+    else {
+        // Ensure a terminating 0x00 guard exists at the most-significant side for positives
+        if (cs[cs.length - 1] !== 0x00) {
+            cs.push(0x00);
+        }
+    }
+    return Uint8Array.from(cs);
+}
+/**
+ * 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
+ */
+// Deserialize from Phantasma wire format: interpret two’s complement in LE
+export function bigIntFromTwosComplementLE_phantasma(data) {
+    if (data.length === 0)
+        return 0n;
+    // Sign is determined by the most significant byte’s bit 7 (1 → negative)
+    const neg = (data[data.length - 1] & 0x80) !== 0;
+    // Positive path: interpret as plain little-endian magnitude; trailing 0x00 is benign
+    if (!neg) {
+        // positive: plain LE magnitude (leading zero bytes are fine)
+        let x = 0n;
+        // Reconstruct BigInt by shifting left 8 and OR-ing each byte from MSB to LSB
+        for (let i = data.length - 1; i >= 0; i--) {
+            x = (x << 8n) | BigInt(data[i]);
+        }
+        return x;
+    }
+    // Negative path: compute two’s complement back (invert and add 1), then negate the magnitude
+    // negative: two's complement back (LE)
+    const a = new Uint8Array(data);
+    for (let i = 0; i < a.length; i++)
+        a[i] = ~a[i] & 0xff;
+    let carry = 1;
+    for (let i = 0; i < a.length; i++) {
+        const s = a[i] + carry;
+        a[i] = s & 0xff;
+        carry = s >> 8;
+        if (!carry)
+            break;
+    }
+    let x = 0n;
+    // Fold bytes back into a positive magnitude and then apply the negative sign
+    for (let i = a.length - 1; i >= 0; i--) {
+        x = (x << 8n) | BigInt(a[i]);
+    }
+    return -x;
+}

package/dist/esm/core/types/PhantasmaKeys.js

@@ -0,0 +1,76 @@
+import { Address } from './Address';
+import base58 from 'bs58';
+import WIF from 'wif';
+import { bytesToHex } from '../utils';
+import { Ed25519Signature } from './Ed25519Signature';
+import pkg from 'elliptic';
+import { Entropy } from './Entropy';
+import { getWifFromPrivateKey, } from '../tx';
+const { eddsa } = pkg;
+const ed25519 = new eddsa('ed25519');
+export class PhantasmaKeys {
+    get PrivateKey() {
+        return this._privateKey;
+    }
+    get PublicKey() {
+        return this._publicKey;
+    }
+    constructor(privateKey) {
+        if (privateKey.length == 64) {
+            privateKey = privateKey.slice(0, 32);
+        }
+        if (privateKey.length != PhantasmaKeys.PrivateKeyLength) {
+            throw new Error(`privateKey should have length ${PhantasmaKeys.PrivateKeyLength} but has ${privateKey.length}`);
+        }
+        this._privateKey = new Uint8Array(PhantasmaKeys.PrivateKeyLength);
+        this._privateKey.set(privateKey);
+        let wif = getWifFromPrivateKey(bytesToHex(privateKey));
+        const privateKeyString = bytesToHex(this._privateKey);
+        const privateKeyBuffer = Buffer.from(privateKeyString, 'hex');
+        const publicKey = ed25519.keyFromSecret(privateKeyBuffer).getPublic();
+        this._publicKey = publicKey;
+        this.Address = Address.FromKey(this);
+    }
+    toString() {
+        return this.Address.Text;
+    }
+    static generate() {
+        const privateKey = Entropy.GetRandomBytes(PhantasmaKeys.PrivateKeyLength);
+        const pair = new PhantasmaKeys(privateKey);
+        return pair;
+    }
+    static fromWIF(wif) {
+        if (!wif) {
+            throw new Error('WIF required');
+        }
+        let data = base58.decode(wif); // checkdecode
+        if (data.length == 38) {
+            data = data.slice(0, 34);
+        }
+        if (data.length != 34 || data[0] != 0x80 || data[33] != 0x01) {
+            throw new Error('Invalid WIF format');
+        }
+        const privateKey = data.slice(1, 33);
+        return new PhantasmaKeys(privateKey);
+    }
+    toWIF() {
+        const privateKeyString = bytesToHex(this._privateKey);
+        const privatekeyBuffer = Buffer.from(privateKeyString, 'hex');
+        const wif = WIF.encode(128, privatekeyBuffer, true); //uint8ArrayToHex(data); // .base58CheckEncode();
+        return wif;
+    }
+    static xor(x, y) {
+        if (x.length != y.length) {
+            throw new Error('x and y should have the same length');
+        }
+        const result = new Uint8Array(x.length);
+        for (let i = 0; i < x.length; i++) {
+            result[i] = x[i] ^ y[i];
+        }
+        return result;
+    }
+    Sign(msg, customSignFunction) {
+        return Ed25519Signature.Generate(this, msg);
+    }
+}
+PhantasmaKeys.PrivateKeyLength = 32;