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

package/dist/esm/core/tx/Transaction.js

@@ -0,0 +1,201 @@
+import pkg from 'elliptic';
+const { eddsa } = pkg;
+import { Decoder, ScriptBuilder } from '../vm';
+import { bytesToHex, hexToBytes, getDifficulty, uint8ArrayToStringDefault } from '../utils';
+import hexEncoding from 'crypto-js/enc-hex';
+import SHA256 from 'crypto-js/sha256';
+import { Base16, PBinaryReader, PBinaryWriter, PhantasmaKeys } from '../types';
+import { getWifFromPrivateKey } from './utils';
+const curve = new eddsa('ed25519');
+export class Transaction {
+    static FromBytes(serializedData) {
+        let transaction = new Transaction('', '', '', new Date(), '');
+        return transaction.unserialize(serializedData);
+    }
+    constructor(nexusName, chainName, script, // Should be HexString
+    expiration, payload // Should be HexString
+    ) {
+        this.nexusName = nexusName;
+        this.chainName = chainName;
+        this.script = script;
+        this.expiration = expiration;
+        this.payload = payload == null || payload == '' ? '7068616e7461736d612d7473' : payload;
+        this.signatures = [];
+    }
+    sign(wif) {
+        let _keys = PhantasmaKeys.fromWIF(wif);
+        const msg = this.ToByteAray(false);
+        let sig = _keys.Sign(msg);
+        let sigs = [];
+        if (this.signatures != null && this.signatures.length > 0) {
+            sigs = this.signatures;
+        }
+        sigs.push(sig);
+        this.signatures = sigs;
+        //const signature = this.getSign(this.toString(false), privateKey);
+        //this.signatures.unshift({ signature, kind: 1 });
+    }
+    signWithPrivateKey(privateKey) {
+        const msg = this.ToByteAray(false);
+        let sig = PhantasmaKeys.fromWIF(getWifFromPrivateKey(privateKey)).Sign(msg);
+        let sigs = [];
+        if (this.signatures != null && this.signatures.length > 0) {
+            sigs = this.signatures;
+        }
+        sigs.push(sig);
+        this.signatures = sigs;
+    }
+    signWithKeys(keys) {
+        const msg = this.ToByteAray(false);
+        let sig = keys.Sign(msg);
+        let sigs = [];
+        if (this.signatures != null && this.signatures.length > 0) {
+            sigs = this.signatures;
+        }
+        sigs.push(sig);
+        this.signatures = sigs;
+    }
+    ToByteAray(withSignature) {
+        let writer = new PBinaryWriter();
+        writer.writeString(this.nexusName);
+        writer.writeString(this.chainName);
+        writer.AppendHexEncoded(this.script);
+        writer.writeDateTime(this.expiration);
+        writer.AppendHexEncoded(this.payload);
+        if (withSignature) {
+            writer.writeVarInt(this.signatures.length);
+            this.signatures.forEach((sig) => {
+                writer.writeSignature(sig);
+                //writer.writeByte(sig.kind);
+                //writer.writeByteArray(stringToUint8Array(sig.signature));
+            });
+        }
+        return writer.toUint8Array();
+    }
+    UnserializeData(reader) {
+        this.nexusName = reader.readString();
+        this.chainName = reader.readString();
+        this.script = uint8ArrayToStringDefault(reader.readByteArray());
+        let time = reader.readTimestamp();
+        this.expiration = new Date(time.toString());
+        this.payload = uint8ArrayToStringDefault(reader.readByteArray());
+        let sigCount = reader.readVarInt();
+        for (let i = 0; i < sigCount; i++) {
+            let sig = reader.readSignatureV2();
+            this.signatures.push(sig);
+        }
+    }
+    SerializeData(writer) {
+        writer.writeString(this.nexusName);
+        writer.writeString(this.chainName);
+        writer.writeByteArray(Base16.decodeUint8Array(this.script));
+        writer.writeDateTime(this.expiration);
+        writer.writeByteArray(Base16.decodeUint8Array(this.payload));
+        writer.writeVarInt(this.signatures.length);
+        this.signatures.forEach((sig) => {
+            writer.writeSignature(sig);
+        });
+    }
+    toString(withSignature) {
+        /*const utc = Date.UTC(
+          this.expiration.getUTCFullYear(),
+          this.expiration.getUTCMonth(),
+          this.expiration.getUTCDate(),
+          this.expiration.getUTCHours(),
+          this.expiration.getUTCMinutes(),
+          this.expiration.getUTCSeconds()
+        );
+        let num = utc / 1000;
+    
+        let a = (num & 0xff000000) >> 24;
+        let b = (num & 0x00ff0000) >> 16;
+        let c = (num & 0x0000ff00) >> 8;
+        let d = num & 0x000000ff;
+    
+        let expirationBytes = [d, c, b, a];*/
+        let sb = new ScriptBuilder()
+            .EmitVarString(this.nexusName)
+            .EmitVarString(this.chainName)
+            .EmitVarInt(this.script.length / 2)
+            .AppendHexEncoded(this.script)
+            .EmitTimestamp(this.expiration)
+            .EmitVarInt(this.payload.length / 2)
+            .AppendHexEncoded(this.payload);
+        if (withSignature) {
+            sb.EmitVarInt(this.signatures.length);
+            this.signatures.forEach((sig) => {
+                console.log('adding signature ', sig);
+                if (sig.Kind == 1) {
+                    sb.AppendByte(1); // Signature Type
+                    sb.EmitVarInt(sig.Bytes.length / 2);
+                    sb.AppendHexEncoded(bytesToHex(sig.Bytes));
+                }
+                else if (sig.Kind == 2) {
+                    sb.AppendByte(2); // ECDSA Signature
+                    sb.AppendByte(1); // Curve type secp256k1
+                    sb.EmitVarInt(sig.Bytes.length / 2);
+                    sb.AppendHexEncoded(bytesToHex(sig.Bytes));
+                }
+            });
+        }
+        return sb.str;
+    }
+    ToStringEncoded(withSignature) {
+        return Base16.encodeUint8Array(this.ToByteAray(withSignature));
+    }
+    getHash() {
+        let generatedHash = SHA256(hexEncoding.parse(this.toString(false)));
+        this.hash = bytesToHex(hexToBytes(generatedHash.toString(hexEncoding)).reverse());
+        return this.hash;
+    }
+    mineTransaction(difficulty) {
+        if (difficulty < 0 || difficulty > 256) {
+            console.log('Error adding difficulty');
+            return;
+        }
+        let nonce = 0;
+        let deepCopy = new Transaction(JSON.parse(JSON.stringify(this.nexusName)), JSON.parse(JSON.stringify(this.chainName)), JSON.parse(JSON.stringify(this.script)), this.expiration, JSON.parse(JSON.stringify(this.payload)));
+        let payload = Buffer.alloc(4);
+        while (true) {
+            if (getDifficulty(deepCopy.getHash()) >= difficulty) {
+                this.payload = deepCopy.payload;
+                console.log('It took ' + nonce + ' iterations to get a difficulty of >' + difficulty);
+                return;
+            }
+            nonce++;
+            payload[0] = (nonce >> 0) & 0xff;
+            payload[1] = (nonce >> 8) & 0xff;
+            payload[2] = (nonce >> 16) & 0xff;
+            payload[3] = (nonce >> 24) & 0xff;
+            deepCopy.payload = bytesToHex(payload);
+        }
+    }
+    getSign(msgHex, privateKey) {
+        const msgHashHex = Buffer.from(msgHex, 'hex');
+        const privateKeyBuffer = Buffer.from(privateKey, 'hex');
+        const sig = curve.sign(msgHashHex, privateKeyBuffer);
+        return sig.toHex();
+    }
+    unserialize(serializedData) {
+        let dec = new Decoder(serializedData);
+        let nexusName = dec.readString();
+        let chainName = dec.readString();
+        let scriptLength = dec.readVarInt();
+        let script = dec.read(scriptLength);
+        let date = new Date(dec.readTimestamp() * 1000);
+        let payloadLength = dec.readVarInt();
+        let payload = dec.read(payloadLength);
+        let nTransaction = new Transaction(nexusName, chainName, script, date, payload);
+        let signatureCount = dec.readVarInt();
+        /*for (let i = 0; i < signatureCount; i++) {
+          nTransaction.signatures.push(dec.readSignature());
+        }*/
+        return nTransaction;
+    }
+    static Unserialize(serialized) {
+        let reader = new PBinaryReader(serialized);
+        let tx = new Transaction('', '', '', new Date(), '');
+        tx.UnserializeData(reader);
+        return tx;
+    }
+}

package/dist/esm/core/tx/index.js

@@ -0,0 +1,3 @@
+export * from './ExecutionState';
+export * from './Transaction';
+export * from './utils';

package/dist/esm/core/tx/utils.js

@@ -0,0 +1,87 @@
+import WIF from 'wif';
+import pkg from 'elliptic';
+import base58 from 'bs58';
+import * as bip39 from 'bip39';
+import crypto from 'crypto';
+const { eddsa } = pkg;
+const curve = new eddsa('ed25519');
+function ab2hexstring(arr) {
+    if (typeof arr !== 'object') {
+        throw new Error(`ab2hexstring expects an array.Input was ${arr}`);
+    }
+    let result = '';
+    const intArray = new Uint8Array(arr);
+    for (const i of intArray) {
+        let str = i.toString(16);
+        str = str.length === 0 ? '00' : str.length === 1 ? '0' + str : str;
+        result += str;
+    }
+    return result;
+}
+export function getPrivateKeyFromWif(wif) {
+    return ab2hexstring(WIF.decode(wif, 128).privateKey);
+}
+export function getAddressFromWif(wif) {
+    const curve = new eddsa('ed25519');
+    const privateKey = getPrivateKeyFromWif(wif);
+    const privateKeyBuffer = Buffer.from(privateKey, 'hex');
+    const publicKey = curve.keyFromSecret(privateKeyBuffer).getPublic('hex');
+    var addressHex = Buffer.from('0100' + publicKey, 'hex');
+    return 'P' + base58.encode(addressHex);
+}
+export function getPublicKeyFromPrivateKey(privateKey) {
+    const privateKeyBuffer = Buffer.from(privateKey, 'hex');
+    const publicKey = curve.keyFromSecret(privateKeyBuffer).getPublic('hex');
+    return publicKey;
+}
+export function generateNewSeed() {
+    let buffer = new Uint8Array(32);
+    let privateKey = Buffer.alloc(32);
+    crypto.getRandomValues(buffer);
+    for (let i = 0; i < 32; ++i) {
+        privateKey.writeUInt8(buffer[i], i);
+    }
+    const wif = WIF.encode(128, privateKey, true);
+    const mnemonic = bip39.generateMnemonic();
+    return mnemonic;
+}
+export function generateNewSeedWords() {
+    let buffer = new Uint8Array(32);
+    let privateKey = Buffer.alloc(32);
+    crypto.getRandomValues(buffer);
+    for (let i = 0; i < 32; ++i) {
+        privateKey.writeUInt8(buffer[i], i);
+    }
+    const wif = WIF.encode(128, privateKey, true);
+    const mnemonic = bip39.generateMnemonic();
+    const seedWords = mnemonic.split(' ');
+    return seedWords;
+}
+export function generateNewWif() {
+    let buffer = new Uint8Array(32);
+    let privateKey = Buffer.alloc(32);
+    crypto.getRandomValues(buffer);
+    for (let i = 0; i < 32; ++i) {
+        privateKey.writeUInt8(buffer[i], i);
+    }
+    const wif = WIF.encode(128, privateKey, true);
+    return wif;
+}
+export function getWifFromPrivateKey(privateKey) {
+    const privateKeyBuffer = Buffer.from(privateKey, 'hex');
+    const wif = WIF.encode(128, privateKeyBuffer, true);
+    return wif;
+}
+export function signData(msgHex, privateKey) {
+    const msgHashHex = Buffer.from(msgHex, 'hex');
+    const privateKeyBuffer = Buffer.from(privateKey, 'hex');
+    const sig = curve.sign(msgHashHex, privateKeyBuffer);
+    const numBytes = sig.toBytes().length;
+    return '01' + (numBytes < 16 ? '0' : '') + numBytes.toString(16) + sig.toHex();
+}
+export function verifyData(msgHex, phaSig, address) {
+    const msgBytes = Buffer.from(msgHex, 'hex');
+    const realSig = phaSig.substring(4);
+    const pubKey = base58.decode(address.substring(1)).slice(2);
+    return curve.verify(msgBytes, realSig, ab2hexstring(pubKey));
+}

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

@@ -0,0 +1,250 @@
+import base58 from 'bs58';
+import { uint8ArrayToString } from '../utils';
+import SHA256 from 'crypto-js/sha256';
+import hexEncoding from 'crypto-js/enc-hex';
+import { getPrivateKeyFromWif, getPublicKeyFromPrivateKey } from '../tx';
+import pkg from 'elliptic';
+const { eddsa } = pkg;
+const curve = new eddsa('ed25519');
+export var AddressKind;
+(function (AddressKind) {
+    AddressKind[AddressKind["Invalid"] = 0] = "Invalid";
+    AddressKind[AddressKind["User"] = 1] = "User";
+    AddressKind[AddressKind["System"] = 2] = "System";
+    AddressKind[AddressKind["Interop"] = 3] = "Interop";
+})(AddressKind || (AddressKind = {}));
+export class Address {
+    /*public get Kind(): AddressKind {
+          return this.IsNull ? AddressKind.System : (this._bytes[0] >= 3) ? AddressKind.Interop
+              : (AddressKind)this._bytes[0];
+      }*/
+    get Kind() {
+        if (this.IsNull) {
+            return AddressKind.System;
+        }
+        else if (this._bytes[0] >= 3) {
+            return AddressKind.Interop;
+        }
+        else {
+            return this._bytes[0];
+        }
+    }
+    get IsSystem() {
+        return this.Kind == AddressKind.System;
+    }
+    get IsInterop() {
+        return this.Kind == AddressKind.Interop;
+    }
+    get IsUser() {
+        return this.Kind == AddressKind.User;
+    }
+    /*public get TendermintAddress(): string {
+          return encodeBase16(this._bytes.slice(2).SHA256().slice(0, 20));
+      }
+      public get TendermintAddress() {
+          return SHA256(this._bytes.slice(2)).slice(0, 20).toString('hex');
+      }
+      */
+    get IsNull() {
+        if (this._bytes == null || this._bytes.length == 0) {
+            return true;
+        }
+        for (let i = 1; i < this._bytes.length; i++) {
+            if (this._bytes[i] != 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+    get Text() {
+        if (this.IsNull) {
+            return Address.NullText;
+        }
+        if (!this._text) {
+            if (Address._keyToTextCache.has(this._bytes)) {
+                this._text = Address._keyToTextCache.get(this._bytes);
+            }
+            if (!this._text) {
+                let prefix;
+                switch (this.Kind) {
+                    case AddressKind.User:
+                        prefix = 'P';
+                        break;
+                    case AddressKind.Interop:
+                        prefix = 'X';
+                        break;
+                    default:
+                        prefix = 'S';
+                        break;
+                }
+                this._text = prefix + base58.encode(this._bytes);
+                Address._keyToTextCache.set(this._bytes, this._text);
+            }
+        }
+        return this._text;
+    }
+    constructor(publicKey) {
+        let pkFromArray = Array.from(publicKey);
+        if (publicKey.length != Address.LengthInBytes) {
+            throw new Error(`publicKey length must be ${Address.LengthInBytes}, it was ${publicKey.length}}`);
+        }
+        this._bytes = new Uint8Array(Address.LengthInBytes);
+        this._bytes.set(publicKey);
+        this._text = null;
+    }
+    static FromPublickKey(publicKey) {
+        publicKey = publicKey.slice(0, 34);
+        return new Address(publicKey);
+    }
+    static FromText(text) {
+        return Address.Parse(text);
+    }
+    static Parse(text) {
+        if (text == null) {
+            return Address.Null;
+        }
+        if (text == Address.NullText) {
+            return Address.Null;
+        }
+        let addr;
+        let originalText = text;
+        let prefix = text[0];
+        text = text.slice(1);
+        var bytes = base58.decode(text);
+        addr = new Address(bytes);
+        switch (prefix) {
+            case 'P':
+                if (addr.Kind != AddressKind.User) {
+                    throw new Error(`Invalid address prefix. Expected 'P', got '${prefix}'`);
+                }
+                break;
+            case 'S':
+                if (addr.Kind != AddressKind.System) {
+                    throw new Error(`Invalid address prefix. Expected 'S', got '${prefix}'`);
+                }
+                break;
+            case 'X':
+                if (addr.Kind < AddressKind.Interop) {
+                    throw new Error(`Invalid address prefix. Expected 'X', got '${prefix}'`);
+                }
+                break;
+            default:
+                throw new Error(`Invalid address prefix. Expected 'P', 'S' or 'X', got '${prefix}'`);
+        }
+        /*this._keyToTextCache.values().forEach((value) => {
+          if (value == text) {
+            return Address.FromHash(this._keyToTextCache(value));
+          }*/
+        return addr;
+    }
+    static IsValidAddress(text) {
+        try {
+            Address.FromText(text);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    static FromBytes(bytes) {
+        return new Address(bytes);
+    }
+    static FromKey(key) {
+        const bytes = new Uint8Array(Address.LengthInBytes);
+        bytes[0] = AddressKind.User;
+        if (key.PublicKey.length == 32) {
+            bytes.set(key.PublicKey, 2);
+        }
+        else if (key.PublicKey.length == 33) {
+            bytes.set(key.PublicKey, 1);
+        }
+        else if (key.PublicKey.length == 64) {
+            bytes.set(key.PublicKey.slice(0, 32), 1);
+        }
+        else {
+            throw new Error('Invalid public key length: ' + key.PublicKey.length);
+        }
+        return new Address(bytes);
+    }
+    static FromHash(input) {
+        let bytes;
+        if (typeof input === 'string') {
+            bytes = new TextEncoder().encode(input);
+        }
+        else {
+            bytes = input;
+        }
+        const hash = SHA256(hexEncoding.parse(uint8ArrayToString(bytes)));
+        bytes = new Uint8Array(Address.LengthInBytes);
+        bytes[0] = AddressKind.User;
+        bytes.set(hash.words.slice(0, 32), 2);
+        return new Address(bytes);
+    }
+    static FromWif(wif) {
+        const privateKey = getPrivateKeyFromWif(wif);
+        const publicKey = getPublicKeyFromPrivateKey(privateKey);
+        var addressHex = Buffer.from('0100' + publicKey, 'hex');
+        return this.FromBytes(addressHex);
+    }
+    compareTo(other) {
+        for (let i = 0; i < Address.LengthInBytes; i++) {
+            if (this._bytes[i] < other._bytes[i]) {
+                return -1;
+            }
+            else if (this._bytes[i] > other._bytes[i]) {
+                return 1;
+            }
+        }
+        return 0;
+    }
+    equals(other) {
+        if (!(other instanceof Address)) {
+            return false;
+        }
+        const address = other;
+        return this._bytes.toString() === address._bytes.toString();
+    }
+    toString() {
+        if (this.IsNull) {
+            return Address.NullText;
+        }
+        if (!this._text) {
+            let prefix;
+            switch (this.Kind) {
+                case AddressKind.User:
+                    prefix = 'P';
+                    break;
+                case AddressKind.Interop:
+                    prefix = 'X';
+                    break;
+                default:
+                    prefix = 'S';
+                    break;
+            }
+            this._text = prefix + base58.encode(this._bytes);
+        }
+        return this._text;
+    }
+    GetPublicKey() {
+        if (!this._bytes || this._bytes.length !== Address.LengthInBytes) {
+            throw new Error('invalid address byte length');
+        }
+        return this._bytes.slice(2, 34);
+    }
+    ToByteArray() {
+        return this._bytes;
+    }
+    SerializeData(writer) {
+        writer.writeByteArray(this._bytes);
+    }
+    UnserializeData(reader) {
+        this._bytes = reader.readByteArray();
+        this._text = null;
+    }
+}
+Address.NullText = 'NULL';
+Address.LengthInBytes = 34;
+Address.MaxPlatformNameLength = 10;
+Address.NullPublicKey = new Uint8Array(Address.LengthInBytes);
+Address.Null = new Address(Address.NullPublicKey);
+Address._keyToTextCache = new Map();

package/dist/esm/core/types/Carbon/Blockchain/CarbonTokenFlags.js

@@ -0,0 +1,6 @@
+export var CarbonTokenFlags;
+(function (CarbonTokenFlags) {
+    CarbonTokenFlags[CarbonTokenFlags["None"] = 0] = "None";
+    CarbonTokenFlags[CarbonTokenFlags["BigFungible"] = 1] = "BigFungible";
+    CarbonTokenFlags[CarbonTokenFlags["NonFungible"] = 2] = "NonFungible";
+})(CarbonTokenFlags || (CarbonTokenFlags = {}));

package/dist/esm/core/types/Carbon/Blockchain/Extensions/TxMsgSigner.js

@@ -0,0 +1,19 @@
+import { CarbonBinaryWriter } from '../../../CarbonSerialization';
+import { Ed25519Signature } from '../../../Ed25519Signature';
+import { Bytes32 } from '../../Bytes32';
+import { Bytes64 } from '../../Bytes64';
+import { CarbonBlob } from '../../CarbonBlob';
+import { Witness } from '../../Witness';
+import { SignedTxMsg } from '../SignedTxMsg';
+export class TxMsgSigner {
+    static sign(msg, key) {
+        const sig = new Bytes64(Ed25519Signature.Generate(key, CarbonBlob.Serialize(msg)).Bytes);
+        return new SignedTxMsg(msg, [new Witness(new Bytes32(key.PublicKey), sig)]);
+    }
+    static signAndSerialize(msg, key) {
+        const signed = this.sign(msg, key);
+        const w = new CarbonBinaryWriter();
+        signed.write(w);
+        return w.toUint8Array();
+    }
+}

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

@@ -0,0 +1 @@
+export * from "./TxMsgSigner";

package/dist/esm/core/types/Carbon/Blockchain/ModuleId.js

@@ -0,0 +1,7 @@
+export var ModuleId;
+(function (ModuleId) {
+    ModuleId[ModuleId["Governance"] = 0] = "Governance";
+    ModuleId[ModuleId["Token"] = 1] = "Token";
+    ModuleId[ModuleId["PhantasmaVm"] = 2] = "PhantasmaVm";
+    ModuleId[ModuleId["Organization"] = 3] = "Organization";
+})(ModuleId || (ModuleId = {}));

package/dist/esm/core/types/Carbon/Blockchain/Modules/Builders/IdHelper.js

@@ -0,0 +1,20 @@
+/**
+ * Generates a random 256-bit unsigned bigint (like C# BigInteger with isUnsigned=true, isBigEndian=true)
+ */
+export async function getRandomPhantasmaId() {
+    const bytes = new Uint8Array(32);
+    if (typeof globalThis.crypto?.getRandomValues === 'function') {
+        // Browser or Node >=19 with webcrypto
+        globalThis.crypto.getRandomValues(bytes);
+    }
+    else {
+        // Node without webcrypto (import dynamically)
+        const { randomFillSync } = await import('crypto');
+        randomFillSync(bytes);
+    }
+    let out = 0n;
+    for (const b of bytes) {
+        out = (out << 8n) | BigInt(b);
+    }
+    return out;
+}