@xelis/sdk 0.11.31 → 0.11.33

package/dist/cjs/contract/xvm_serializer.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createContractDeployment = exports.createContractInvocation = exports.createDeposits = exports.vmParam = exports.createVMParameter = void 0;
+exports.createContractDeployment = exports.createContractInvocation = exports.createDeposits = exports.createVMParameter = exports.typeRegistry = exports.defineStruct = exports.defineEnum = exports.VMParam = exports.serialize_optional = exports.serialize_map = exports.serialize_array = exports.createVMPrimitive = void 0;
 // Known opaque types that need special wrapping
-const OPAQUE_TYPES = new Set(['Hash', 'Address', 'PublicKey', 'Blob' /** TODO */]);
+const OPAQUE_TYPES = new Set(['Hash', 'Address', 'PublicKey', 'Blob']);
 // Type validation and conversion helpers
 const TYPE_VALIDATORS = {
     'u256': (v) => {
@@ -76,12 +76,12 @@ const TYPE_VALIDATORS = {
  * @param type - The type string (e.g., 'u64', 'Hash', 'string')
  * @param validate - Whether to validate and convert the value (default: true)
  */
-function createVMParameter(value, type, validate = true) {
-    let processedValue = value;
+function createVMPrimitive(value, type, validate = true) {
+    let processed_value = value;
     // Validate and convert value if requested
     if (validate && TYPE_VALIDATORS[type]) {
         try {
-            processedValue = TYPE_VALIDATORS[type](value);
+            processed_value = TYPE_VALIDATORS[type](value);
         }
         catch (error) {
             throw new Error(`Failed to create VM parameter for type ${type}: ${error}`);
@@ -90,64 +90,287 @@ function createVMParameter(value, type, validate = true) {
     // Handle opaque types (Hash, Address, PublicKey)
     if (OPAQUE_TYPES.has(type)) {
         return {
-            type: "default",
+            type: "primitive",
             value: {
                 type: "opaque",
                 value: {
                     type: type,
-                    value: processedValue
+                    value: processed_value
                 }
             }
         };
     }
     // Handle regular types
     return {
-        type: "default",
+        type: "primitive",
         value: {
             type: type,
-            value: processedValue
+            value: processed_value
         }
     };
 }
-exports.createVMParameter = createVMParameter;
+exports.createVMPrimitive = createVMPrimitive;
+/**
+ * Serialize an array of values
+ */
+function serialize_array(items, item_type) {
+    const serialized_items = items.map(item => createVMParameter(item, item_type));
+    return {
+        type: "array",
+        value: serialized_items
+    };
+}
+exports.serialize_array = serialize_array;
+/**
+ * Serialize a map
+ */
+function serialize_map(map, keyType, valueType) {
+    const entries = [];
+    for (const [key, value] of Object.entries(map)) {
+        const serialized_key = createVMParameter(key, keyType);
+        const serialized_value = createVMParameter(value, valueType);
+        entries.push([serialized_key, serialized_value]);
+    }
+    return {
+        type: "map",
+        value: entries
+    };
+}
+exports.serialize_map = serialize_map;
+/**
+ * Serialize an optional value
+ */
+function serialize_optional(value, inner_type) {
+    if (value === null || value === undefined) {
+        return {
+            type: "option",
+            value: null
+        };
+    }
+    return {
+        type: "option",
+        value: createVMParameter(value, inner_type)
+    };
+}
+exports.serialize_optional = serialize_optional;
 /**
  * Convenience functions for common types
  */
-exports.vmParam = {
-    hash: (value) => createVMParameter(value, 'Hash'),
-    address: (value) => createVMParameter(value, 'Address'),
-    publicKey: (value) => createVMParameter(value, 'PublicKey'),
-    blob: (value) => createVMParameter(value, 'Blob'),
-    u64: (value) => createVMParameter(value, 'u64'),
-    u32: (value) => createVMParameter(value, 'u32'),
-    u16: (value) => createVMParameter(value, 'u16'),
-    u8: (value) => createVMParameter(value, 'u8'),
-    string: (value) => createVMParameter(value, 'string'),
-    boolean: (value) => createVMParameter(value, 'boolean'),
+exports.VMParam = {
+    hash: (value) => createVMPrimitive(value, 'Hash'),
+    address: (value) => createVMPrimitive(value, 'Address'),
+    public_key: (value) => createVMPrimitive(value, 'PublicKey'),
+    blob: (value) => createVMPrimitive(value, 'Blob'),
+    u64: (value) => createVMPrimitive(value, 'u64'),
+    u32: (value) => createVMPrimitive(value, 'u32'),
+    u16: (value) => createVMPrimitive(value, 'u16'),
+    u8: (value) => createVMPrimitive(value, 'u8'),
+    string: (value) => createVMPrimitive(value, 'string'),
+    boolean: (value) => createVMPrimitive(value, 'boolean'),
 };
+/**
+ * Define an enum type from ABI schema
+ */
+function defineEnum(name, variants) {
+    const variantNames = variants.map(v => v.name);
+    return {
+        name,
+        // NEW: mark kind & expose a matcher
+        // (safe to add; SerializableType is duck-typed)
+        // @ts-ignore - widen at runtime
+        kind: 'enum',
+        // @ts-ignore
+        hasVariant: (vn) => variantNames.includes(vn),
+        to_VMParameter(value) {
+            const variant_index = variants.findIndex(v => v.name === value.type);
+            if (variant_index === -1) {
+                throw new Error(`Unknown variant '${value.type}' for enum '${name}'`);
+            }
+            const variant = variants[variant_index];
+            const expected_fields = new Set(variant.fields.map(f => f.name));
+            expected_fields.add('type');
+            for (const key of Object.keys(value)) {
+                if (!expected_fields.has(key)) {
+                    throw new Error(`Unknown field '${key}' for variant '${value.type}' of enum '${name}'. ` +
+                        `Expected fields: ${Array.from(expected_fields).filter(f => f !== 'type').join(', ')}`);
+                }
+            }
+            const params = [
+                exports.VMParam.u8(variant_index)
+            ];
+            for (const field_schema of variant.fields) {
+                const field_value = value[field_schema.name];
+                if (field_value === undefined) {
+                    throw new Error(`Missing field '${field_schema.name}' for variant '${value.type}' of enum '${name}'`);
+                }
+                params.push(createVMParameter(field_value, field_schema.type));
+            }
+            return { type: "object", value: params };
+        }
+    };
+}
+exports.defineEnum = defineEnum;
+/**
+ * Define a struct type from ABI schema
+ */
+function defineStruct(name, fields) {
+    return {
+        name,
+        // NEW: mark kind for structs
+        // @ts-ignore
+        kind: 'struct',
+        to_VMParameter(value) {
+            const expected_fields = new Set(fields.map(f => f.name));
+            for (const key of Object.keys(value)) {
+                if (!expected_fields.has(key)) {
+                    throw new Error(`Unknown field '${key}' for struct '${name}'. ` +
+                        `Expected fields: ${Array.from(expected_fields).join(', ')}`);
+                }
+            }
+            const params = [];
+            for (const field_schema of fields) {
+                const field_value = value[field_schema.name];
+                if (field_value === undefined) {
+                    throw new Error(`Missing field '${field_schema.name}' for struct '${name}'`);
+                }
+                params.push(createVMParameter(field_value, field_schema.type));
+            }
+            return { type: "object", value: params };
+        }
+    };
+}
+exports.defineStruct = defineStruct;
+/**
+ * Type registry - simple Map for custom types
+ */
+class TypeRegistry {
+    constructor() {
+        this.types = new Map();
+    }
+    register(definition) {
+        this.types.set(definition.name, definition);
+        return definition;
+    }
+    get(name) {
+        return this.types.get(name);
+    }
+    has(name) {
+        return this.types.has(name);
+    }
+    clear() {
+        this.types.clear();
+    }
+    all() {
+        return this.types.values();
+    }
+}
+exports.typeRegistry = new TypeRegistry();
+/**
+ * Enhanced parameter creation that handles both primitive and custom types
+ * @param value - The value to serialize
+ * @param type - The type string (primitive or custom type name)
+ * @param validate - Whether to validate primitive values (default: true)
+ */
+function createVMParameter(value, type, validate = true) {
+    // Pass-through already-serialized parameters
+    if (value && typeof value === 'object' && 'type' in value && 'value' in value) {
+        return value;
+    }
+    // Arrays
+    if (type.endsWith('[]')) {
+        const inner_type = type.slice(0, -2);
+        if (!Array.isArray(value)) {
+            throw new Error(`Expected array for type ${type}, got ${typeof value}`);
+        }
+        return serialize_array(value, inner_type);
+    }
+    // Optionals
+    if (type.startsWith('optional<') && type.endsWith('>')) {
+        const inner_type = type.slice(9, -1);
+        return serialize_optional(value, inner_type);
+    }
+    // Maps
+    const map_match = type.match(/^map<(.+),\s*(.+)>$/);
+    if (map_match) {
+        const [, keyType, valueType] = map_match;
+        if (typeof value !== 'object' || Array.isArray(value)) {
+            throw new Error(`Expected object for type ${type}, got ${typeof value}`);
+        }
+        return serialize_map(value, keyType.trim(), valueType.trim());
+    }
+    // Generic enum/struct notations: enum<Foo>, struct<Bar>
+    const enumGeneric = type.match(/^enum<\s*([^>]+)\s*>$/i);
+    if (enumGeneric) {
+        const realType = enumGeneric[1].trim();
+        const custom = exports.typeRegistry.get(realType);
+        if (!custom)
+            throw new Error(`Unregistered enum type: ${realType}`);
+        return custom.to_VMParameter(value);
+    }
+    const structGeneric = type.match(/^struct<\s*([^>]+)\s*>$/i);
+    if (structGeneric) {
+        const realType = structGeneric[1].trim();
+        const custom = exports.typeRegistry.get(realType);
+        if (!custom)
+            throw new Error(`Unregistered struct type: ${realType}`);
+        return custom.to_VMParameter(value);
+    }
+    // Preferred: named custom type
+    const custom_type = exports.typeRegistry.get(type);
+    if (custom_type) {
+        return custom_type.to_VMParameter(value);
+    }
+    // **Fix for ABI that says literally "enum"/"struct"**
+    if (type === 'enum' && value && typeof value === 'object' && 'type' in value) {
+        const variantName = value.type;
+        for (const t of exports.typeRegistry.all()) {
+            const anyT = t;
+            if (anyT?.kind === 'enum' && typeof anyT.hasVariant === 'function' && anyT.hasVariant(variantName)) {
+                return t.to_VMParameter(value);
+            }
+        }
+        throw new Error(`Cannot resolve enum type for variant '${variantName}'. Is it registered?`);
+    }
+    if (type === 'struct') {
+        // Best-effort: if your ABI truly says "struct" w/o a name, you’ll need a hint.
+        // You can add your own resolution heuristic here if you have one.
+        throw new Error(`Unknown struct subtype; ABI must specify struct<Foo> or a named type`);
+    }
+    // Primitive fallback
+    if (type in TYPE_VALIDATORS) {
+        return createVMPrimitive(value, type, validate);
+    }
+    console.error("[VMParam] unknown type", type, { value });
+    throw new Error(`Unknown type: ${type}`);
+}
+exports.createVMParameter = createVMParameter;
+// ============================================================================
+// Contract Invocation Helpers
+// ============================================================================
 /**
  * Creates a deposits object for contract calls
  * @param deposits - Object mapping token hashes to amounts
  */
 function createDeposits(deposits) {
     const result = {};
-    for (const [tokenHash, amount] of Object.entries(deposits)) {
+    for (const [token_hash, amount] of Object.entries(deposits)) {
         // Validate hash format
-        if (!/^[0-9a-fA-F]{64}$/.test(tokenHash)) {
-            throw new Error(`Invalid token hash format: ${tokenHash}`);
+        if (!/^[0-9a-fA-F]{64}$/.test(token_hash)) {
+            throw new Error(`Invalid token hash format: ${token_hash}`);
         }
-        result[tokenHash] = { amount };
+        result[token_hash] = { amount };
     }
     return result;
 }
 exports.createDeposits = createDeposits;
 function createContractInvocation(params) {
-    const { contract, chunkId, parameters = [], deposits, maxGas = 200000000 } = params;
+    const { contract, chunk_id, parameters = [], deposits, permission, maxGas = 50000000 } = params;
     const result = {
         invoke_contract: {
             contract,
             max_gas: maxGas,
-            chunk_id: chunkId,
+            entry_id: chunk_id,
+            permission,
             parameters
         }
     };
@@ -158,11 +381,11 @@ function createContractInvocation(params) {
 }
 exports.createContractInvocation = createContractInvocation;
 function createContractDeployment(params) {
-    const { bytecode, hasConstructor = false, maxGas = 200000000 } = params;
+    const { bytecode, hasConstructor = false, maxGas = 50000000 } = params;
     const result = {
         deploy_contract: {
             module: bytecode,
-            ...(hasConstructor && { invoke: { max_gas: maxGas } })
+            ...(hasConstructor && { invoke: { maxGas } })
         }
     };
     return result;

package/dist/cjs/daemon/rpc.js

@@ -52,6 +52,18 @@ class RPC extends http_1.HttpRPC {
     getTopBlock(params) {
         return this.request(types_1.RPCMethod.GetTopBlock, params);
     }
+    getBlockDifficultyByHash(params) {
+        return this.request(types_1.RPCMethod.GetBlockDifficultyByHash, params);
+    }
+    getBlockBaseFeeByHash(params) {
+        return this.request(types_1.RPCMethod.GetBlockBaseFeeByHash, params);
+    }
+    getBlockSummaryAtTopoheight(params) {
+        return this.request(types_1.RPCMethod.GetBlockSummaryAtTopoheight, params);
+    }
+    getBlockSummaryByHash(params) {
+        return this.request(types_1.RPCMethod.GetBlockSummaryByHash, params);
+    }
     getBalance(params) {
         return this.request(types_1.RPCMethod.GetBalance, params);
     }
@@ -106,6 +118,9 @@ class RPC extends http_1.HttpRPC {
     getTransactions(txHashes) {
         return this.request(types_1.RPCMethod.GetTransactions, { tx_hashes: txHashes });
     }
+    getTransactionsSummary(params) {
+        return this.request(types_1.RPCMethod.GetTransactionsSummary, params);
+    }
     isTxExecutedInBlock(params) {
         return this.request(types_1.RPCMethod.IsTxExecutedInBlock, params);
     }
@@ -163,6 +178,9 @@ class RPC extends http_1.HttpRPC {
     extractKeyFromAddress(params) {
         return this.request(types_1.RPCMethod.ExtractKeyFromAddress, params);
     }
+    keyToAddress(params) {
+        return this.request(types_1.RPCMethod.KeyToAddress, params);
+    }
     makeIntegratedAddress(params) {
         return this.request(types_1.RPCMethod.MakeIntegratedAddress, params);
     }
@@ -190,6 +208,9 @@ class RPC extends http_1.HttpRPC {
     getContractRegisteredExecutionsAtTopoheight(params) {
         return this.request(types_1.RPCMethod.GetContractRegisteredExecutionsAtTopoheight, params);
     }
+    getContractsOutputs(params) {
+        return this.request(types_1.RPCMethod.GetContractsOutputs);
+    }
     getContractModule(params) {
         return this.request(types_1.RPCMethod.GetContractModule, params);
     }

package/dist/cjs/daemon/types.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RPCEvent = exports.RPCMethod = exports.BlockType = exports.BalanceType = void 0;
+exports.RPCEvent = exports.RPCMethod = exports.BlockType = exports.BalanceType = exports.AddressType = void 0;
+var AddressType;
+(function (AddressType) {
+    AddressType["Normal"] = "normal";
+    AddressType["Data"] = "data";
+})(AddressType = exports.AddressType || (exports.AddressType = {}));
 var BalanceType;
 (function (BalanceType) {
     BalanceType["Input"] = "input";
@@ -32,6 +37,10 @@ var RPCMethod;
     RPCMethod["GetBlocksAtHeight"] = "get_blocks_at_height";
     RPCMethod["GetBlockByHash"] = "get_block_by_hash";
     RPCMethod["GetTopBlock"] = "get_top_block";
+    RPCMethod["GetBlockDifficultyByHash"] = "get_block_difficulty_by_hash";
+    RPCMethod["GetBlockBaseFeeByHash"] = "get_block_base_fee_by_hash";
+    RPCMethod["GetBlockSummaryAtTopoheight"] = "get_block_summary_at_topoheight";
+    RPCMethod["GetBlockSummaryByHash"] = "get_block_summary_by_hash";
     RPCMethod["GetBalance"] = "get_balance";
     RPCMethod["GetStableBalance"] = "get_stable_balance";
     RPCMethod["HasBalance"] = "has_balance";
@@ -50,9 +59,11 @@ var RPCMethod;
     RPCMethod["GetTransactionExecutor"] = "get_transaction_executor";
     RPCMethod["GetTransaction"] = "get_transaction";
     RPCMethod["GetTransactions"] = "get_transactions";
+    RPCMethod["GetTransactionsSummary"] = "get_transactions_summary";
     RPCMethod["IsTxExecutedInBlock"] = "is_tx_executed_in_block";
     RPCMethod["P2PStatus"] = "p2p_status";
     RPCMethod["GetPeers"] = "get_peers";
+    RPCMethod["GetP2PBlockPropagation"] = "get_p2p_block_propagation";
     RPCMethod["GetMempool"] = "get_mempool";
     RPCMethod["GetMempoolSummary"] = "get_mempool_summary";
     RPCMethod["GetMempoolCache"] = "get_mempool_cache";
@@ -69,6 +80,7 @@ var RPCMethod;
     RPCMethod["ValidateAddress"] = "validate_address";
     RPCMethod["SplitAddress"] = "split_address";
     RPCMethod["ExtractKeyFromAddress"] = "extract_key_from_address";
+    RPCMethod["KeyToAddress"] = "key_to_address";
     RPCMethod["MakeIntegratedAddress"] = "make_integrated_address";
     RPCMethod["DecryptExtraData"] = "decrypt_extra_data";
     RPCMethod["GetMultisigAtTopoheight"] = "get_multisig_at_topoheight";
@@ -78,6 +90,7 @@ var RPCMethod;
     RPCMethod["GetContractLogs"] = "get_contract_logs";
     RPCMethod["GetContractScheduledExecutionsAtTopoheight"] = "get_contract_scheduled_executions_at_topoheight";
     RPCMethod["GetContractRegisteredExecutionsAtTopoheight"] = "get_contract_registered_executions_at_topoheight";
+    RPCMethod["GetContractsOutputs"] = "get_contracts_outputs";
     RPCMethod["GetContractModule"] = "get_contract_module";
     RPCMethod["GetContractData"] = "get_contract_data";
     RPCMethod["GetContractDataAtTopoheight"] = "get_contract_data_at_topoheight";
@@ -86,7 +99,6 @@ var RPCMethod;
     RPCMethod["GetContractAssets"] = "get_contract_assets";
     RPCMethod["GetContracts"] = "get_contracts";
     RPCMethod["GetContractDataEntries"] = "get_contract_data_entries";
-    RPCMethod["GetP2PBlockPropagation"] = "get_p2p_block_propagation";
     RPCMethod["GetBlockTemplate"] = "get_block_template";
     RPCMethod["GetMinerWork"] = "get_miner_work";
     RPCMethod["SubmitBlock"] = "submit_block";

package/dist/cjs/daemon/websocket.js

@@ -71,6 +71,18 @@ class DaemonMethods {
     getTopBlock(params) {
         return this.dataCall(types_1.RPCMethod.GetTopBlock, params);
     }
+    getBlockDifficultyByHash(params) {
+        return this.dataCall(types_1.RPCMethod.GetBlockDifficultyByHash, params);
+    }
+    getBlockBaseFeeByHash(params) {
+        return this.dataCall(types_1.RPCMethod.GetBlockBaseFeeByHash, params);
+    }
+    getBlockSummaryAtTopoheight(params) {
+        return this.dataCall(types_1.RPCMethod.GetBlockSummaryAtTopoheight, params);
+    }
+    getBlockSummaryByHash(params) {
+        return this.dataCall(types_1.RPCMethod.GetBlockSummaryByHash, params);
+    }
     getBalance(params) {
         return this.dataCall(types_1.RPCMethod.GetBalance, params);
     }
@@ -125,6 +137,9 @@ class DaemonMethods {
     getTransactions(txHashes) {
         return this.dataCall(types_1.RPCMethod.GetTransactions, { tx_hashes: txHashes });
     }
+    getTransactionsSummary(params) {
+        return this.dataCall(types_1.RPCMethod.GetTransactionsSummary, params);
+    }
     isTxExecutedInBlock(params) {
         return this.dataCall(types_1.RPCMethod.IsTxExecutedInBlock, params);
     }
@@ -182,6 +197,9 @@ class DaemonMethods {
     extractKeyFromAddress(params) {
         return this.dataCall(types_1.RPCMethod.ExtractKeyFromAddress, params);
     }
+    keyToAddress(params) {
+        return this.dataCall(types_1.RPCMethod.KeyToAddress, params);
+    }
     makeIntegratedAddress(params) {
         return this.dataCall(types_1.RPCMethod.MakeIntegratedAddress, params);
     }
@@ -209,6 +227,9 @@ class DaemonMethods {
     getContractRegisteredExecutionsAtTopoheight(params) {
         return this.dataCall(types_1.RPCMethod.GetContractRegisteredExecutionsAtTopoheight, params);
     }
+    getContractsOutputs(params) {
+        return this.dataCall(types_1.RPCMethod.GetContractsOutputs);
+    }
     getContractModule(params) {
         return this.dataCall(types_1.RPCMethod.GetContractModule, params);
     }

package/dist/cjs/rpc/websocket.js

@@ -40,8 +40,6 @@ class WSRPC {
             }
             else {
                 let idRefObject = {};
-                await this.dataCall(`subscribe`, { notify: event }, idRefObject)
-                    .catch(err => listener(null, err));
                 const onMessage = (msgEvent) => {
                     const eventData = this.events.get(event);
                     if (eventData && typeof msgEvent.data === `string`) {
@@ -64,8 +62,16 @@ class WSRPC {
                         }
                     }
                 };
-                this.socket.addEventListener(`message`, onMessage);
-                this.events.set(event, { onMessage, listeners: [listener] });
+                try {
+                    this.socket.addEventListener(`message`, onMessage);
+                    this.events.set(event, { onMessage, listeners: [listener] });
+                    await this.dataCall(`subscribe`, { notify: event }, idRefObject);
+                }
+                catch (err) {
+                    this.socket.removeEventListener(`message`, onMessage);
+                    this.events.delete(event);
+                    throw err;
+                }
             }
         };
         // make sure connection is open or wait