phantasma-sdk-ts 0.7.0 → 0.8.0

package/dist/esm/types/address.js

@@ -0,0 +1,333 @@
+import base58 from 'bs58';
+import { uint8ArrayToString } from '../utils/index.js';
+import SHA256 from 'crypto-js/sha256.js';
+import hexEncoding from 'crypto-js/enc-hex.js';
+import { getPrivateKeyFromWif, getPublicKeyFromPrivateKey } from '../tx/index.js';
+import { Base16 } from './extensions/index.js';
+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];
+        }
+    }
+    /** @deprecated Use `kind` instead. This alias will be removed in v1.0. */
+    get Kind() {
+        return this.kind;
+    }
+    get isSystem() {
+        return this.kind == AddressKind.System;
+    }
+    /** @deprecated Use `isSystem` instead. This alias will be removed in v1.0. */
+    get IsSystem() {
+        return this.isSystem;
+    }
+    get isInterop() {
+        return this.kind == AddressKind.Interop;
+    }
+    /** @deprecated Use `isInterop` instead. This alias will be removed in v1.0. */
+    get IsInterop() {
+        return this.isInterop;
+    }
+    get isUser() {
+        return this.kind == AddressKind.User;
+    }
+    /** @deprecated Use `isUser` instead. This alias will be removed in v1.0. */
+    get IsUser() {
+        return this.isUser;
+    }
+    /*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;
+    }
+    /** @deprecated Use `isNull` instead. This alias will be removed in v1.0. */
+    get IsNull() {
+        return this.isNull;
+    }
+    get text() {
+        if (this.isNull) {
+            return Address.nullText;
+        }
+        if (!this._text) {
+            if (Address._keyToTextCache.has(this._bytes)) {
+                const cachedText = Address._keyToTextCache.get(this._bytes);
+                if (cachedText !== undefined) {
+                    this._text = cachedText;
+                }
+            }
+            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;
+    }
+    /** @deprecated Use `text` instead. This alias will be removed in v1.0. */
+    get Text() {
+        return this.text;
+    }
+    constructor(bytes) {
+        if (bytes.length != Address.lengthInBytes) {
+            throw new Error(`address byte length must be ${Address.lengthInBytes}, it was ${bytes.length}`);
+        }
+        this._bytes = new Uint8Array(Address.lengthInBytes);
+        this._bytes.set(bytes);
+        this._text = null;
+    }
+    static fromPublicKey(publicKey) {
+        if (publicKey.length !== 32) {
+            throw new Error(`publicKey length must be 32, it was ${publicKey.length}`);
+        }
+        const bytes = new Uint8Array(Address.lengthInBytes);
+        bytes[0] = AddressKind.User;
+        bytes.set(publicKey, 2);
+        return new Address(bytes);
+    }
+    /** @deprecated Use `fromBytes` for 34-byte address data. This typoed alias will be removed in v1.0. */
+    static FromPublickKey(bytes) {
+        return Address.fromBytes(bytes);
+    }
+    static fromText(text) {
+        return Address.parse(text);
+    }
+    /** @deprecated Use `fromText` instead. This alias will be removed in v1.0. */
+    static FromText(text) {
+        return Address.fromText(text);
+    }
+    static parse(text) {
+        if (text == null) {
+            return Address.nullAddress;
+        }
+        if (text == Address.nullText) {
+            return Address.nullAddress;
+        }
+        const prefix = text[0];
+        text = text.slice(1);
+        const bytes = base58.decode(text);
+        const 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;
+    }
+    /** @deprecated Use `parse` instead. This alias will be removed in v1.0. */
+    static Parse(text) {
+        return Address.parse(text);
+    }
+    static isValidAddress(text) {
+        try {
+            Address.fromText(text);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** @deprecated Use `isValidAddress` instead. This alias will be removed in v1.0. */
+    static IsValidAddress(text) {
+        return Address.isValidAddress(text);
+    }
+    static fromBytes(bytes) {
+        return new Address(bytes);
+    }
+    /** @deprecated Use `fromBytes` instead. This alias will be removed in v1.0. */
+    static FromBytes(bytes) {
+        return Address.fromBytes(bytes);
+    }
+    static fromKey(key) {
+        const publicKey = 'publicKey' in key ? key.publicKey : key.PublicKey;
+        if (publicKey.length == 32) {
+            return Address.fromPublicKey(publicKey);
+        }
+        const bytes = new Uint8Array(Address.lengthInBytes);
+        bytes[0] = AddressKind.User;
+        if (publicKey.length == 33) {
+            bytes.set(publicKey, 1);
+        }
+        else if (publicKey.length == 64) {
+            bytes.set(publicKey.slice(0, 32), 1);
+        }
+        else {
+            throw new Error('Invalid public key length: ' + publicKey.length);
+        }
+        return new Address(bytes);
+    }
+    /** @deprecated Use `fromKey` instead. This alias will be removed in v1.0. */
+    static FromKey(key) {
+        return Address.fromKey(key);
+    }
+    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 FromHash(input) {
+        return typeof input === 'string' ? Address.fromHash(input) : Address.fromHash(input);
+    }
+    static fromWif(wif) {
+        const privateKey = getPrivateKeyFromWif(wif);
+        const publicKey = getPublicKeyFromPrivateKey(privateKey);
+        const addressHex = Buffer.from('0100' + publicKey, 'hex');
+        return Address.fromBytes(addressHex);
+    }
+    /** @deprecated Use `fromWif` instead. This alias will be removed in v1.0. */
+    static FromWif(wif) {
+        return Address.fromWif(wif);
+    }
+    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, Address.lengthInBytes);
+    }
+    /** @deprecated Use `getPublicKey` instead. This alias will be removed in v1.0. */
+    GetPublicKey() {
+        return this.getPublicKey();
+    }
+    toByteArray() {
+        return this._bytes;
+    }
+    /** @deprecated Use `toByteArray` instead. This alias will be removed in v1.0. */
+    ToByteArray() {
+        return this.toByteArray();
+    }
+    serializeData(writer) {
+        writer.writeByteArray(this._bytes);
+    }
+    /** @deprecated Use `serializeData` instead. This alias will be removed in v1.0. */
+    SerializeData(writer) {
+        this.serializeData(writer);
+    }
+    unserializeData(reader) {
+        this._bytes = Base16.decodeUint8Array(reader.readByteArray());
+        this._text = null;
+    }
+    /** @deprecated Use `unserializeData` instead. This alias will be removed in v1.0. */
+    UnserializeData(reader) {
+        this.unserializeData(reader);
+    }
+}
+Address.nullText = 'NULL';
+/** @deprecated Use `nullText` instead. This alias will be removed in v1.0. */
+Address.NullText = Address.nullText;
+Address.lengthInBytes = 34;
+/** @deprecated Use `lengthInBytes` instead. This alias will be removed in v1.0. */
+Address.LengthInBytes = Address.lengthInBytes;
+Address.maxPlatformNameLength = 10;
+/** @deprecated Use `maxPlatformNameLength` instead. This alias will be removed in v1.0. */
+Address.MaxPlatformNameLength = Address.maxPlatformNameLength;
+Address.nullPublicKey = new Uint8Array(Address.lengthInBytes);
+Address.nullAddress = new Address(Address.nullPublicKey);
+/** @deprecated Use `nullAddress` instead. This alias will be removed in v1.0. */
+Address.Null = Address.nullAddress;
+Address._keyToTextCache = new Map();

package/dist/esm/types/carbon/blockchain/carbon-token-flags.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/types/carbon/blockchain/extensions/index.js

@@ -0,0 +1 @@
+export * from './tx-msg-signer.js';

package/dist/esm/types/carbon/blockchain/extensions/tx-msg-signer.js

@@ -0,0 +1,19 @@
+import { CarbonBinaryWriter } from '../../../carbon-serialization.js';
+import { Ed25519Signature } from '../../../ed25519-signature.js';
+import { Bytes32 } from '../../bytes32.js';
+import { Bytes64 } from '../../bytes64.js';
+import { CarbonBlob } from '../../carbon-blob.js';
+import { Witness } from '../../witness.js';
+import { SignedTxMsg } from '../signed-tx-msg.js';
+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/types/carbon/blockchain/index.js

@@ -0,0 +1,26 @@
+export * from './extensions/index.js';
+export * from './modules/index.js';
+export * from './tx-helpers/index.js';
+export * from './vm/index.js';
+export * from './carbon-token-flags.js';
+export * from './module-id.js';
+export * from './signed-tx-msg.js';
+export * from './tx-msg.js';
+export * from './tx-msg-call.js';
+export * from './tx-msg-call-multi.js';
+export * from './tx-msg-special-resolution.js';
+export * from './tx-msg-trade.js';
+export * from './tx-msg-mint-fungible.js';
+export * from './tx-msg-mint-non-fungible.js';
+export * from './tx-msg-burn-fungible.js';
+export * from './tx-msg-burn-fungible-gas-payer.js';
+export * from './tx-msg-burn-non-fungible.js';
+export * from './tx-msg-burn-non-fungible-gas-payer.js';
+export * from './tx-msg-transfer-fungible.js';
+export * from './tx-msg-transfer-fungible-gas-payer.js';
+export * from './tx-msg-transfer-non-fungible-single.js';
+export * from './tx-msg-transfer-non-fungible-single-gas-payer.js';
+export * from './tx-msg-transfer-non-fungible-multi.js';
+export * from './tx-msg-transfer-non-fungible-multi-gas-payer.js';
+export * from './tx-msg-phantasma.js';
+export * from './tx-msg-phantasma-raw.js';

package/dist/esm/types/carbon/blockchain/module-id.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/types/carbon/blockchain/modules/builders/id-helper.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;
+}

package/dist/esm/types/carbon/blockchain/modules/builders/index.js

@@ -0,0 +1,9 @@
+export * from './id-helper.js';
+export * from './nft-rom-builder.js';
+export * from './phantasma-nft-rom-builder.js';
+export * from './series-info-builder.js';
+export * from './token-info-builder.js';
+export * from './token-metadata-builder.js';
+export * from './token-schemas-builder.js';
+export * from './token-series-metadata-builder.js';
+export * from './metadata-helper.js';