phantasma-sdk-ts 0.7.0 → 0.8.0

package/dist/esm/types/phantasma-keys.js

@@ -0,0 +1,93 @@
+import { Address } from './address.js';
+import base58 from 'bs58';
+import { encode as encodeWif } from 'wif';
+import { bytesToHex } from '../utils/index.js';
+import { Ed25519Signature } from './ed25519-signature.js';
+import { Entropy } from './entropy.js';
+import { getEd25519PublicKey } from './ed25519.js';
+export class PhantasmaKeys {
+    get privateKey() {
+        return this._privateKey;
+    }
+    /** @deprecated Use `privateKey` instead. This alias will be removed in v1.0. */
+    get PrivateKey() {
+        return this.privateKey;
+    }
+    get publicKey() {
+        return this._publicKey;
+    }
+    /** @deprecated Use `publicKey` instead. This alias will be removed in v1.0. */
+    get PublicKey() {
+        return this.publicKey;
+    }
+    get address() {
+        return this._address;
+    }
+    /** @deprecated Use `address` instead. This alias will be removed in v1.0. */
+    get Address() {
+        return this.address;
+    }
+    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);
+        this._publicKey = getEd25519PublicKey(this._privateKey);
+        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 = encodeWif({
+            version: 128,
+            privateKey: Uint8Array.from(privatekeyBuffer),
+            compressed: 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) {
+        return Ed25519Signature.generate(this, msg);
+    }
+    /** @deprecated Use `sign` instead. This alias will be removed in v1.0. */
+    Sign(msg, customSignFunction) {
+        void customSignFunction;
+        return this.sign(msg);
+    }
+}
+PhantasmaKeys.PrivateKeyLength = 32;

package/dist/esm/types/serialization.js

@@ -0,0 +1,221 @@
+import { PBinaryReader, PBinaryWriter } from './extensions/index.js';
+import { Timestamp } from './timestamp.js';
+import { isSerializableLike, serializeSerializable, unserializeSerializable, } from '../interfaces/index.js';
+import { stringToUint8Array } from '../utils/index.js';
+export class CustomSerializer {
+    constructor(reader, writer) {
+        this.read = reader;
+        this.write = writer;
+    }
+    /** @deprecated Use `read` instead. This alias will be removed in v1.0. */
+    get Read() {
+        return this.read;
+    }
+    /** @deprecated Use `write` instead. This alias will be removed in v1.0. */
+    get Write() {
+        return this.write;
+    }
+}
+export class Serialization {
+    static registerType(type, reader, writer) {
+        Serialization._customSerializers.set(typeof type, new CustomSerializer(reader, writer));
+    }
+    /** @deprecated Use `registerType` instead. This alias will be removed in v1.0. */
+    static RegisterType(type, reader, writer) {
+        this.registerType(type, reader, writer);
+    }
+    static serializeEnum(obj) {
+        if (!obj) {
+            return new Uint8Array();
+        }
+        if (obj instanceof Uint8Array) {
+            return obj;
+        }
+        const writer = new PBinaryWriter();
+        writer.writeEnum(Number(obj));
+        return writer.toUint8Array();
+    }
+    /** @deprecated Use `serializeEnum` instead. This alias will be removed in v1.0. */
+    static SerializeEnum(obj) {
+        return this.serializeEnum(obj);
+    }
+    static serialize(obj) {
+        if (!obj) {
+            return new Uint8Array();
+        }
+        if (obj instanceof Uint8Array) {
+            return obj;
+        }
+        //let jsonString = JSON.stringify(obj);
+        const writer = new PBinaryWriter();
+        this.serializeObject(writer, obj, typeof obj);
+        //let jsonAsUint8 = new TextEncoder().encode(jsonString);
+        return writer.toUint8Array();
+    }
+    /** @deprecated Use `serialize` instead. This alias will be removed in v1.0. */
+    static Serialize(obj) {
+        return this.serialize(obj);
+    }
+    static serializeObject(writer, obj, type) {
+        if (type == null || type == undefined) {
+            type = typeof obj;
+            this.serializeObject(writer, obj, type);
+            return;
+        }
+        const serializer = Serialization._customSerializers.get(typeof type);
+        if (serializer !== undefined) {
+            serializer.write(writer, obj);
+            return;
+        }
+        /*if (typeof obj == "void") {
+          return;
+        }*/
+        if (obj instanceof Boolean || typeof obj == 'boolean') {
+            writer.writeByte(obj ? 1 : 0);
+            return;
+        }
+        else if (obj instanceof Number || typeof obj == 'number') {
+            writer.writeByte(stringToUint8Array(obj.toString()).length);
+            writer.writeVarInt(obj);
+            return;
+        }
+        else if (typeof obj == 'bigint') {
+            writer.writeBigInteger(obj);
+            return;
+        }
+        else if (obj instanceof String || typeof obj == 'string') {
+            writer.writeString(obj);
+            return;
+        }
+        else if (obj instanceof Timestamp) {
+            writer.writeTimestamp(obj);
+            return;
+        }
+        else if (obj instanceof Date) {
+            writer.writeDateTime(obj);
+            return;
+        }
+        else if (isSerializableLike(obj)) {
+            serializeSerializable(obj, writer);
+            return;
+        }
+        else if (Array.isArray(obj)) {
+            writer.writeVarInt(obj.length);
+            obj.forEach((entry) => {
+                this.serializeObject(writer, entry, typeof entry);
+            });
+            return;
+        }
+        else if (Object.getPrototypeOf(type) == 'enum') {
+            writer.writeByte(obj);
+            return;
+        }
+        else if (obj instanceof Uint8Array) {
+            writer.writeByteArray(Array.from(obj));
+            return;
+        }
+        else {
+            // Plain-object serialization is intentionally field-value only. The wire
+            // format is not self-describing, so callers must deserialize with a known type.
+            const fields = Object.keys(obj);
+            fields.forEach((field) => {
+                const value = obj[field];
+                this.serializeObject(writer, value, typeof value);
+            });
+        }
+    }
+    /** @deprecated Use `serializeObject` instead. This alias will be removed in v1.0. */
+    static SerializeObject(writer, obj, type) {
+        this.serializeObject(writer, obj, type);
+    }
+    static deserialize(bytesOrBytes, type) {
+        if (bytesOrBytes instanceof PBinaryReader) {
+            return Serialization.deserializeObject(bytesOrBytes, type);
+        }
+        if (!bytesOrBytes || bytesOrBytes.length === 0) {
+            return null;
+        }
+        //let type = Object.prototype.propertyIsEnumerable(T);
+        const stream = new PBinaryReader(bytesOrBytes);
+        return Serialization.deserializeObject(stream, type);
+    }
+    /** @deprecated Use `deserialize` instead. This alias will be removed in v1.0. */
+    static Unserialize(bytesOrBytes, type) {
+        return this.deserialize(bytesOrBytes, type);
+    }
+    static deserializeObject(reader, type) {
+        const serializer = Serialization._customSerializers.get(typeof type);
+        if (serializer !== undefined) {
+            return serializer.read(reader);
+        }
+        if (type == null || type == undefined) {
+            return null;
+        }
+        let localType; //: typeof type;
+        const constructorType = type;
+        if (typeof type === 'function' &&
+            constructorType.name !== 'Boolean' &&
+            constructorType.name !== 'Number' &&
+            constructorType.name !== 'BigInt' &&
+            constructorType.name !== 'String' &&
+            constructorType.name !== 'Timestamp') {
+            localType = new constructorType();
+        }
+        if (localType instanceof Boolean ||
+            typeof localType == 'boolean' ||
+            constructorType.name == 'Boolean') {
+            return reader.readBoolean();
+        }
+        else if (localType instanceof Number ||
+            typeof localType == 'number' ||
+            constructorType.name == 'Number') {
+            return reader.readVarInt();
+        }
+        else if (localType instanceof BigInt ||
+            typeof localType == 'bigint' ||
+            constructorType.name == 'BigInt') {
+            return reader.readBigInteger();
+        }
+        else if (localType instanceof String ||
+            typeof localType == 'string' ||
+            constructorType.name == 'String') {
+            return reader.readVarString();
+        }
+        else if (localType instanceof Timestamp || constructorType.name == 'Timestamp') {
+            return new Timestamp(reader.readVarInt());
+        }
+        else if (isSerializableLike(localType)) {
+            const obj = localType;
+            unserializeSerializable(obj, reader);
+            return obj;
+        }
+        else if (Array.isArray(type)) {
+            const len = reader.readByte();
+            const arr = new Array(len);
+            for (let i = 0; i < len; i++) {
+                arr[i] = this.deserializeObject(reader, type[i]);
+            }
+            return arr;
+        }
+        else if (Object.getPrototypeOf(type) == 'enum') {
+            return reader.readByte();
+        }
+        else {
+            Object.keys(localType);
+            /*console.log(fields);
+            fields.forEach((field) => {
+              localType[field] = this.UnserializeObject(
+                reader,
+                typeof localType[field]
+              );
+            });
+            return localType as T;*/
+            return localType;
+        }
+    }
+    /** @deprecated Use `deserializeObject` instead. This alias will be removed in v1.0. */
+    static UnserializeObject(reader, type) {
+        return this.deserializeObject(reader, type);
+    }
+}
+Serialization._customSerializers = new Map(); //: { [key: string]: CustomSerializer };

package/dist/esm/types/stack.js

@@ -0,0 +1,36 @@
+export class Stack {
+    constructor(capacity = Infinity) {
+        this.capacity = capacity;
+        this.storage = [];
+    }
+    push(item) {
+        if (this.size() === this.capacity) {
+            throw Error('Stack has reached max capacity, you cannot add more items');
+        }
+        this.storage.push(item);
+    }
+    pop() {
+        return this.storage.pop();
+    }
+    peek() {
+        return this.storage[this.size() - 1];
+    }
+    size() {
+        return this.storage.length;
+    }
+    isEmpty() {
+        return this.size() === 0;
+    }
+    toArray() {
+        return this.storage;
+    }
+    clear() {
+        this.storage = [];
+    }
+    toString() {
+        return this.storage.toString();
+    }
+    isFull() {
+        return this.capacity === this.size();
+    }
+}

package/dist/esm/types/timestamp.js

@@ -0,0 +1,90 @@
+export class Timestamp {
+    constructor(value) {
+        this.value = value;
+    }
+    toString() {
+        return new Date(this.value * 1000).toUTCString();
+    }
+    toStringFormat(_format) {
+        void _format;
+        return new Date(this.value * 1000).toUTCString();
+    }
+    compareTo(other) {
+        if (other.value === this.value) {
+            return 0;
+        }
+        if (this.value < other.value) {
+            return -1;
+        }
+        return 1;
+    }
+    equals(obj) {
+        if (!(obj instanceof Timestamp)) {
+            return false;
+        }
+        return this.value === obj.value;
+    }
+    getHashCode() {
+        return this.value;
+    }
+    getSize() {
+        return 4;
+    }
+    static equal(A, B) {
+        return A.value === B.value;
+    }
+    static notEqual(A, B) {
+        return !(A.value === B.value);
+    }
+    static lessThan(A, B) {
+        return A.value < B.value;
+    }
+    static greaterThan(A, B) {
+        return A.value > B.value;
+    }
+    static lessThanOrEqual(A, B) {
+        return A.value <= B.value;
+    }
+    static greaterThanOrEqual(A, B) {
+        return A.value >= B.value;
+    }
+    static subtract(A, B) {
+        return A.value - B.value;
+    }
+    static fromNumber(ticks) {
+        return new Timestamp(ticks);
+    }
+    static fromDate(time) {
+        return new Timestamp(time.getTime() / 1000);
+    }
+    static addTimeSpan(A, B) {
+        return A.value + B;
+    }
+    static subtractTimeSpan(A, B) {
+        return A.value - B;
+    }
+    serializeData(writer) {
+        writer.writeTimestamp(this);
+    }
+    unserializeData(reader) {
+        this.value = reader.readTimestamp().value;
+    }
+    static serialize(timestamp, writer) {
+        timestamp.serializeData(writer);
+    }
+    static deserialize(reader) {
+        return reader.readTimestamp();
+    }
+    /** @deprecated Use `serializeData` or `Timestamp.serialize` instead. This alias will be removed in v1.0. */
+    static Serialize(timestamp, writer) {
+        if (timestamp !== undefined && writer !== undefined) {
+            Timestamp.serialize(timestamp, writer);
+        }
+    }
+    /** @deprecated Use `Timestamp.deserialize` instead. This alias will be removed in v1.0. */
+    static Unserialize(reader) {
+        return reader === undefined ? undefined : Timestamp.deserialize(reader);
+    }
+}
+Timestamp.now = Date.now();
+Timestamp.null = new Timestamp(0);

package/dist/esm/utils/hex.js

@@ -0,0 +1,33 @@
+const HEX_LUT = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
+const HEX_RE = /^[0-9a-fA-F]+$/;
+export function bytesToHex(bytes) {
+    const len = bytes.length >>> 0;
+    let out = '';
+    for (let i = 0; i < len; i++) {
+        const v = Number(bytes[i]);
+        if (!Number.isInteger(v) || v < 0 || v > 255) {
+            throw new Error(`Invalid byte at index ${i}: ${v}`);
+        }
+        out += HEX_LUT[v];
+    }
+    return out;
+}
+export function hexToBytes(hex) {
+    const trimmed = hex.trim();
+    const normalized = trimmed.startsWith('0x') || trimmed.startsWith('0X') ? trimmed.slice(2) : trimmed;
+    if (normalized.length === 0) {
+        return new Uint8Array();
+    }
+    if (normalized.length % 2 !== 0) {
+        throw new Error(`Invalid hex string length ${normalized.length} hex: ${normalized}`);
+    }
+    if (!HEX_RE.test(normalized)) {
+        throw new Error(`Invalid hex string: ${normalized}`);
+    }
+    // Validate input first so parsing never silently accepts non-hex characters.
+    const bytes = new Uint8Array(normalized.length / 2);
+    for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = parseInt(normalized.slice(i * 2, i * 2 + 2), 16);
+    }
+    return bytes;
+}

package/dist/esm/utils/index.js

@@ -0,0 +1,145 @@
+import { hexToBytes } from './hex.js';
+export * from './hex.js';
+export * from './validation-utils.js';
+export * from './logger.js';
+export function reverseHex(hex) {
+    let out = '';
+    for (let i = hex.length - 2; i >= 0; i -= 2) {
+        out += hex.substr(i, 2);
+    }
+    return out;
+}
+export function getDifficulty(transactionHash) {
+    const bytes = hexToBytes(transactionHash).reverse();
+    let result = 0;
+    for (let i = 0; i < bytes.length; i++) {
+        for (let j = 0; j < 8; j++) {
+            if ((bytes[i] & (1 << j)) != 0) {
+                result = 1 + (i << 3) + j;
+            }
+        }
+    }
+    return 256 - result;
+}
+export function decodeBase16(hex) {
+    let str = '';
+    for (let i = 0; i < hex.length; i += 2) {
+        str += String.fromCharCode(parseInt(hex.substr(i, 2), 16));
+    }
+    return str;
+}
+export function encodeBase16(str) {
+    return str
+        .split('')
+        .map((c) => c.charCodeAt(0).toString(16).padStart(2, '0'))
+        .join('')
+        .toUpperCase();
+}
+export function uint8ArrayToString(array) {
+    let result = '';
+    for (let i = 0; i < array.length; i++) {
+        result += String.fromCharCode(array[i]);
+    }
+    return result;
+}
+export function uint8ArrayToStringDefault(array) {
+    let result = '';
+    for (let i = 0; i < array.length; i++) {
+        result += array[i].toString(16);
+    }
+    return result;
+}
+export function uint8ArrayToNumberArray(array) {
+    const result = [];
+    for (let i = 0; i < array.length; i++) {
+        result.push(array[i]);
+    }
+    return result;
+}
+export function stringToUint8Array(str) {
+    const result = new Uint8Array(str.length);
+    for (let i = 0; i < str.length; i++) {
+        result[i] = str.charCodeAt(i);
+    }
+    return result;
+}
+export function hexStringToUint8Array(str) {
+    const result = new Uint8Array(str.length);
+    for (let i = 0; i < str.length; i++) {
+        result[i] = str.charCodeAt(i).toString(16).charCodeAt(0);
+    }
+    return result;
+}
+export function arrayNumberToUint8Array(arr) {
+    const result = new Uint8Array(arr.length);
+    for (let i = 0; i < arr.length; i++) {
+        result[i] = arr[i];
+    }
+    return result;
+}
+export function uint8ArrayToBytes(array) {
+    const result = [];
+    for (let i = 0; i < array.length; i++) {
+        result.push(array[i]);
+    }
+    return result;
+}
+export function numberToByteArray(num, size) {
+    if (size === undefined) {
+        if (num < 0xfd) {
+            size = 1;
+        }
+        else if (num <= 0xfffd) {
+            size = 2;
+        }
+        else if (num <= 0xffffd) {
+            size = 3;
+        }
+        else if (num <= 0xfffffffd) {
+            size = 4;
+        }
+        else if (num <= 0xffffffff) {
+            size = 5;
+        }
+        else if (num <= 0xffffffffffffffff) {
+            size = 9;
+        }
+        else {
+            throw new RangeError('number is too large to encode as a byte array');
+        }
+    }
+    const bytes = new Uint8Array(size);
+    let i = 0;
+    do {
+        bytes[i++] = num & 0xff;
+        num = num >> 8;
+    } while (num);
+    return bytes;
+}
+export function bigIntToByteArray(bigint) {
+    // Get a big-endian byte representation of the bigint
+    const bytes = bigint.toString(16).padStart(64, '0');
+    const byteArray = new Uint8Array(bytes.length / 2);
+    for (let i = 0; i < bytes.length; i += 2) {
+        byteArray[i / 2] = parseInt(bytes.substring(i, i + 2), 16);
+    }
+    return byteArray;
+}
+export const hex2ascii = (hexx) => {
+    const hex = hexx.toString();
+    let str = '';
+    for (let i = 0; i < hex.length; i += 2) {
+        const char = hex.substr(i, 2);
+        const charCode = String.fromCharCode(parseInt(char, 16));
+        // console.log('char', char, 'charCode', charCode);
+        str += charCode;
+    }
+    return str;
+};
+export const Int2Buffer = (i) => {
+    let hex = i.toString(16).toUpperCase();
+    if (hex.length % 2 === 1) {
+        hex = '0' + hex;
+    }
+    return Buffer.from(hex, 'hex');
+};

package/dist/esm/utils/logger.js

@@ -0,0 +1,19 @@
+const noop = () => { };
+// Default SDK logger: silent unless the consumer explicitly enables logging.
+export const logger = {
+    log: noop,
+    info: noop,
+    warn: noop,
+    error: noop,
+    debug: noop,
+    trace: noop,
+};
+// Use a custom logger (for example, setLogger(console)) to enable output.
+export function setLogger(custom) {
+    logger.log = custom?.log ?? noop;
+    logger.info = custom?.info ?? noop;
+    logger.warn = custom?.warn ?? noop;
+    logger.error = custom?.error ?? noop;
+    logger.debug = custom?.debug ?? noop;
+    logger.trace = custom?.trace ?? custom?.debug ?? custom?.log ?? noop;
+}