@xelis/sdk 0.11.31 → 0.11.33

package/dist/esm/contract/xvm_serializer.js

@@ -1,5 +1,5 @@
 // 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) => {
@@ -73,12 +73,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)
  */
-export function createVMParameter(value, type, validate = true) {
-    let processedValue = value;
+export 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}`);
@@ -87,62 +87,279 @@ export 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
         }
     };
 }
+/**
+ * Serialize an array of values
+ */
+export function serialize_array(items, item_type) {
+    const serialized_items = items.map(item => createVMParameter(item, item_type));
+    return {
+        type: "array",
+        value: serialized_items
+    };
+}
+/**
+ * Serialize a map
+ */
+export 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
+    };
+}
+/**
+ * Serialize an optional value
+ */
+export function serialize_optional(value, inner_type) {
+    if (value === null || value === undefined) {
+        return {
+            type: "option",
+            value: null
+        };
+    }
+    return {
+        type: "option",
+        value: createVMParameter(value, inner_type)
+    };
+}
 /**
  * Convenience functions for common types
  */
-export const 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'),
+export const 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
+ */
+export 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 = [
+                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 };
+        }
+    };
+}
+/**
+ * Define a struct type from ABI schema
+ */
+export 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 };
+        }
+    };
+}
+/**
+ * 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();
+    }
+}
+export const 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)
+ */
+export 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 = 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 = typeRegistry.get(realType);
+        if (!custom)
+            throw new Error(`Unregistered struct type: ${realType}`);
+        return custom.to_VMParameter(value);
+    }
+    // Preferred: named custom type
+    const custom_type = 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 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}`);
+}
+// ============================================================================
+// Contract Invocation Helpers
+// ============================================================================
 /**
  * Creates a deposits object for contract calls
  * @param deposits - Object mapping token hashes to amounts
  */
 export 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;
 }
 export 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
         }
     };
@@ -152,11 +369,11 @@ export function createContractInvocation(params) {
     return result;
 }
 export 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/esm/daemon/rpc.js

@@ -49,6 +49,18 @@ export class RPC extends HttpRPC {
     getTopBlock(params) {
         return this.request(RPCMethod.GetTopBlock, params);
     }
+    getBlockDifficultyByHash(params) {
+        return this.request(RPCMethod.GetBlockDifficultyByHash, params);
+    }
+    getBlockBaseFeeByHash(params) {
+        return this.request(RPCMethod.GetBlockBaseFeeByHash, params);
+    }
+    getBlockSummaryAtTopoheight(params) {
+        return this.request(RPCMethod.GetBlockSummaryAtTopoheight, params);
+    }
+    getBlockSummaryByHash(params) {
+        return this.request(RPCMethod.GetBlockSummaryByHash, params);
+    }
     getBalance(params) {
         return this.request(RPCMethod.GetBalance, params);
     }
@@ -103,6 +115,9 @@ export class RPC extends HttpRPC {
     getTransactions(txHashes) {
         return this.request(RPCMethod.GetTransactions, { tx_hashes: txHashes });
     }
+    getTransactionsSummary(params) {
+        return this.request(RPCMethod.GetTransactionsSummary, params);
+    }
     isTxExecutedInBlock(params) {
         return this.request(RPCMethod.IsTxExecutedInBlock, params);
     }
@@ -160,6 +175,9 @@ export class RPC extends HttpRPC {
     extractKeyFromAddress(params) {
         return this.request(RPCMethod.ExtractKeyFromAddress, params);
     }
+    keyToAddress(params) {
+        return this.request(RPCMethod.KeyToAddress, params);
+    }
     makeIntegratedAddress(params) {
         return this.request(RPCMethod.MakeIntegratedAddress, params);
     }
@@ -187,6 +205,9 @@ export class RPC extends HttpRPC {
     getContractRegisteredExecutionsAtTopoheight(params) {
         return this.request(RPCMethod.GetContractRegisteredExecutionsAtTopoheight, params);
     }
+    getContractsOutputs(params) {
+        return this.request(RPCMethod.GetContractsOutputs);
+    }
     getContractModule(params) {
         return this.request(RPCMethod.GetContractModule, params);
     }

package/dist/esm/daemon/types.js

@@ -1,3 +1,8 @@
+export var AddressType;
+(function (AddressType) {
+    AddressType["Normal"] = "normal";
+    AddressType["Data"] = "data";
+})(AddressType || (AddressType = {}));
 export var BalanceType;
 (function (BalanceType) {
     BalanceType["Input"] = "input";
@@ -29,6 +34,10 @@ export 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";
@@ -47,9 +56,11 @@ export 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";
@@ -66,6 +77,7 @@ export 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";
@@ -75,6 +87,7 @@ export 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";
@@ -83,7 +96,6 @@ export 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/esm/daemon/websocket.js

@@ -68,6 +68,18 @@ export class DaemonMethods {
     getTopBlock(params) {
         return this.dataCall(RPCMethod.GetTopBlock, params);
     }
+    getBlockDifficultyByHash(params) {
+        return this.dataCall(RPCMethod.GetBlockDifficultyByHash, params);
+    }
+    getBlockBaseFeeByHash(params) {
+        return this.dataCall(RPCMethod.GetBlockBaseFeeByHash, params);
+    }
+    getBlockSummaryAtTopoheight(params) {
+        return this.dataCall(RPCMethod.GetBlockSummaryAtTopoheight, params);
+    }
+    getBlockSummaryByHash(params) {
+        return this.dataCall(RPCMethod.GetBlockSummaryByHash, params);
+    }
     getBalance(params) {
         return this.dataCall(RPCMethod.GetBalance, params);
     }
@@ -122,6 +134,9 @@ export class DaemonMethods {
     getTransactions(txHashes) {
         return this.dataCall(RPCMethod.GetTransactions, { tx_hashes: txHashes });
     }
+    getTransactionsSummary(params) {
+        return this.dataCall(RPCMethod.GetTransactionsSummary, params);
+    }
     isTxExecutedInBlock(params) {
         return this.dataCall(RPCMethod.IsTxExecutedInBlock, params);
     }
@@ -179,6 +194,9 @@ export class DaemonMethods {
     extractKeyFromAddress(params) {
         return this.dataCall(RPCMethod.ExtractKeyFromAddress, params);
     }
+    keyToAddress(params) {
+        return this.dataCall(RPCMethod.KeyToAddress, params);
+    }
     makeIntegratedAddress(params) {
         return this.dataCall(RPCMethod.MakeIntegratedAddress, params);
     }
@@ -206,6 +224,9 @@ export class DaemonMethods {
     getContractRegisteredExecutionsAtTopoheight(params) {
         return this.dataCall(RPCMethod.GetContractRegisteredExecutionsAtTopoheight, params);
     }
+    getContractsOutputs(params) {
+        return this.dataCall(RPCMethod.GetContractsOutputs);
+    }
     getContractModule(params) {
         return this.dataCall(RPCMethod.GetContractModule, params);
     }

package/dist/esm/rpc/websocket.js

@@ -34,8 +34,6 @@ export 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`) {
@@ -58,8 +56,16 @@ export 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

package/dist/types/contract/contract.d.ts

@@ -7,21 +7,38 @@ export interface ABIEntry {
     name: string;
     outputs?: string;
     params: ABIParam[];
-    type: 'entry' | 'view';
+    type: 'entry';
+}
+export interface InternalType {
+    name: string;
+    kind: 'struct' | 'enum';
+    fields?: Array<{
+        name: string;
+        type: string;
+    }>;
+    variants?: Array<{
+        name: string;
+        fields: Array<{
+            name: string;
+            type: string;
+        }>;
+    }>;
 }
 export interface ABI {
     data: ABIEntry[];
     version: string;
+    internal_types?: InternalType[];
 }
 export interface ContractCallParams {
     [key: string]: any;
     maxGas?: number;
+    permission: string;
     deposits?: Record<string, number | bigint>;
 }
 export interface IContract {
     readonly address: string;
     readonly abi: ABI;
-    invoke(methodName: string, params?: ContractCallParams): Record<string, any>;
+    invoke(method_name: string, params?: ContractCallParams): Record<string, any>;
 }
 type GenerateContractMethods<T extends ABI> = {
     [K in T['data'][number]['name']]: (params?: ContractCallParams) => Record<string, any>;
@@ -34,34 +51,53 @@ export declare class Contract<T extends ABI = ABI> implements IContract {
     readonly abi: T;
     private readonly methods;
     constructor(address: string, abi: T);
+    /**
+     * Register all custom types from ABI
+     */
+    private register_internal_types;
+    /**
+     * Helper to create struct values with positional arguments
+     * Validates field types immediately
+     * @param type_name - Name of the struct type
+     * @param field_values - Field values in the order defined in ABI
+     */
+    struct(type_name: string, ...field_values: any[]): any;
+    /**
+     * Helper to create enum values with positional arguments
+     * Validates field types immediately
+     * @param type_name - Name of the enum type
+     * @param variant_name - Name of the variant
+     * @param field_values - Field values in the order defined in ABI
+     */
+    enum(type_name: string, variant_name: string, ...field_values: any[]): any;
     /**
      * Creates a dynamic method on the contract instance
      */
-    private createDynamicMethod;
+    private create_dynamic_method;
     /**
      * Invoke a contract method by name
-     * @param methodName - Name of the method from the ABI
+     * @param method_name - Name of the method from the ABI
      * @param params - Parameters for the method call
      */
-    invoke(methodName: string, params?: ContractCallParams): Record<string, any>;
+    invoke(method_name: string, params?: ContractCallParams): Record<string, any>;
     /**
      * Get list of available methods
      */
-    getMethods(): string[];
+    get_methods(): string[];
     /**
      * Get method signature information
      */
-    getMethodSignature(methodName: string): ABIEntry | undefined;
+    get_method_signature(method_name: string): ABIEntry | undefined;
     /**
      * Validate parameters for a method without creating the transaction
      */
-    validateParams(methodName: string, params: ContractCallParams): boolean;
+    validate_params(method_name: string, params: ContractCallParams): boolean;
 }
 /**
  * Helper function to create a typed contract instance
  * This provides better TypeScript support when the ABI is known at compile time
  */
-export declare function createContract<T extends ABI>(address: string, abi: T): Contract<T> & GenerateContractMethods<T>;
+export declare function create_contract<T extends ABI>(address: string, abi: T): Contract<T> & GenerateContractMethods<T>;
 /**
  * Factory for creating multiple contracts with the same ABI
  */
@@ -75,6 +111,6 @@ export declare class ContractFactory<T extends ABI = ABI> {
     /**
      * Get the ABI
      */
-    getABI(): T;
+    get_abi(): T;
 }
 export {};