@xelis/sdk 0.11.32 → 0.11.34

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/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

package/dist/esm/contract/contract.js

@@ -1,34 +1,4 @@
-import { createVMParameter, createContractInvocation } from './xvm_serializer.js';
-;
-// Convert ABI type to our validator type
-function normalizeType(abiType) {
-    const typeMap = {
-        'Hash': 'Hash',
-        'Address': 'Address',
-        'PublicKey': 'PublicKey',
-        'Blob': 'Blob',
-        'u256': 'u256',
-        'u128': 'u128',
-        'u64': 'u64',
-        'u32': 'u32',
-        'u16': 'u16',
-        'u8': 'u8',
-        'boolean': 'boolean',
-        'bool': 'boolean',
-        'string': 'string',
-        'String': 'string',
-        'Boolean': 'boolean',
-        'U64': 'u64',
-        'U32': 'u32',
-        'U16': 'u16',
-        'U8': 'u8'
-    };
-    const normalized = typeMap[abiType];
-    if (!normalized) {
-        throw new Error(`Unknown ABI type: ${abiType}`);
-    }
-    return normalized;
-}
+import { createContractInvocation, typeRegistry, defineEnum, defineStruct, createVMParameter } from './xvm_serializer.js';
 /**
  * Contract class that dynamically generates methods based on ABI
  */
@@ -37,107 +7,179 @@ export class Contract {
         this.address = address;
         this.abi = abi;
         this.methods = new Map();
-        // Parse ABI and set up methods map
+        this.register_internal_types();
         for (const entry of abi.data) {
             if (entry.type === 'entry') {
                 this.methods.set(entry.name, entry);
-                // Dynamically add method to the instance
-                this.createDynamicMethod(entry);
+                this.create_dynamic_method(entry);
+            }
+        }
+    }
+    /**
+     * Register all custom types from ABI
+     */
+    register_internal_types() {
+        if (!this.abi.internal_types)
+            return;
+        for (const type_def of this.abi.internal_types) {
+            if (type_def.kind === 'enum' && type_def.variants) {
+                typeRegistry.register(defineEnum(type_def.name, type_def.variants));
+            }
+            else if (type_def.kind === 'struct' && type_def.fields) {
+                typeRegistry.register(defineStruct(type_def.name, type_def.fields));
+            }
+        }
+    }
+    /**
+     * 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, ...field_values) {
+        const type_def = this.abi.internal_types?.find(t => t.name === type_name && t.kind === 'struct');
+        if (!type_def || !type_def.fields) {
+            throw new Error(`Struct type '${type_name}' not found in contract ABI`);
+        }
+        if (field_values.length !== type_def.fields.length) {
+            throw new Error(`Struct '${type_name}' expects ${type_def.fields.length} fields ` +
+                `(${type_def.fields.map(f => f.name).join(', ')}), ` +
+                `but got ${field_values.length}`);
+        }
+        const result = {};
+        for (let i = 0; i < type_def.fields.length; i++) {
+            const field = type_def.fields[i];
+            const value = field_values[i];
+            try {
+                createVMParameter(value, field.type);
+            }
+            catch (error) {
+                throw new Error(`Invalid value for field '${field.name}' (position ${i}) of struct '${type_name}': ${error}`);
+            }
+            result[field.name] = value;
+        }
+        return result;
+    }
+    /**
+     * 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, variant_name, ...field_values) {
+        const type_def = this.abi.internal_types?.find(t => t.name === type_name && t.kind === 'enum');
+        if (!type_def || !type_def.variants) {
+            throw new Error(`Enum type '${type_name}' not found in contract ABI`);
+        }
+        const variant = type_def.variants.find(v => v.name === variant_name);
+        if (!variant) {
+            const available = type_def.variants.map(v => v.name).join(', ');
+            throw new Error(`Unknown variant '${variant_name}' for enum '${type_name}'. ` +
+                `Available variants: ${available}`);
+        }
+        if (field_values.length !== variant.fields.length) {
+            throw new Error(`Variant '${variant_name}' of enum '${type_name}' expects ${variant.fields.length} fields ` +
+                `(${variant.fields.map(f => f.name).join(', ')}), ` +
+                `but got ${field_values.length}`);
+        }
+        const result = { type: variant_name };
+        for (let i = 0; i < variant.fields.length; i++) {
+            const field = variant.fields[i];
+            const value = field_values[i];
+            try {
+                createVMParameter(value, field.type);
+            }
+            catch (error) {
+                throw new Error(`Invalid value for field '${field.name}' (position ${i}) of variant '${variant_name}' in enum '${type_name}': ${error}`);
             }
+            result[field.name] = value;
         }
+        return result;
     }
     /**
      * Creates a dynamic method on the contract instance
      */
-    createDynamicMethod(entry) {
-        const methodName = entry.name;
-        // Create a method that properly binds 'this'
+    create_dynamic_method(entry) {
+        const method_name = entry.name;
         const method = (params) => {
-            return this.invoke(methodName, params);
+            return this.invoke(method_name, params);
         };
-        // Add the method to the instance
-        this[methodName] = method;
+        this[method_name] = 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, params = {}) {
-        const entry = this.methods.get(methodName);
+    invoke(method_name, params = { permission: "all" }) {
+        const entry = this.methods.get(method_name);
         if (!entry) {
-            throw new Error(`Method '${methodName}' not found in contract ABI`);
+            throw new Error(`Method '${method_name}' not found in contract ABI`);
         }
-        // Extract special parameters
-        const { maxGas, deposits, ...methodParams } = params;
-        // Build parameter list according to ABI
+        const { maxGas, deposits, permission, ...method_params } = params;
         const parameters = [];
-        for (const abiParam of entry.params) {
-            const value = methodParams[abiParam.name];
+        for (const abi_param of entry.params) {
+            const value = method_params[abi_param.name];
             if (value === undefined) {
-                throw new Error(`Missing required parameter '${abiParam.name}' for method '${methodName}'`);
+                throw new Error(`Missing required parameter '${abi_param.name}' for method '${method_name}'`);
             }
             try {
-                const normalizedType = normalizeType(abiParam.type);
-                const vmParam = createVMParameter(value, normalizedType);
-                parameters.push(vmParam);
+                const VMParam = createVMParameter(value, abi_param.type);
+                parameters.push(VMParam);
             }
             catch (error) {
-                throw new Error(`Invalid parameter '${abiParam.name}' for method '${methodName}': ${error}`);
+                throw new Error(`Invalid parameter '${abi_param.name}' for method '${method_name}': ${error}`);
             }
         }
-        // Create the contract invocation
-        const invocationParams = {
+        const invocation_params = {
             contract: this.address,
-            chunkId: entry.chunk_id,
+            chunk_id: entry.chunk_id,
             parameters,
-            maxGas: maxGas || 200000000
+            permission,
+            maxGas: maxGas || 50000000
         };
         if (deposits && Object.keys(deposits).length > 0) {
-            invocationParams.deposits = deposits;
+            invocation_params.deposits = deposits;
         }
-        return createContractInvocation(invocationParams);
+        return createContractInvocation(invocation_params);
     }
     /**
      * Get list of available methods
      */
-    getMethods() {
+    get_methods() {
         return Array.from(this.methods.keys());
     }
     /**
      * Get method signature information
      */
-    getMethodSignature(methodName) {
-        return this.methods.get(methodName);
+    get_method_signature(method_name) {
+        return this.methods.get(method_name);
     }
     /**
      * Validate parameters for a method without creating the transaction
      */
-    validateParams(methodName, params) {
-        const entry = this.methods.get(methodName);
+    validate_params(method_name, params) {
+        const entry = this.methods.get(method_name);
         if (!entry) {
-            throw new Error(`Method '${methodName}' not found in contract ABI`);
+            throw new Error(`Method '${method_name}' not found in contract ABI`);
         }
-        const { deposits, maxGas, ...methodParams } = params;
-        // Check all required parameters are present
-        for (const abiParam of entry.params) {
-            if (!(abiParam.name in methodParams)) {
-                throw new Error(`Missing required parameter '${abiParam.name}'`);
+        const { deposits, maxGas, ...method_params } = params;
+        for (const abi_param of entry.params) {
+            if (!(abi_param.name in method_params)) {
+                throw new Error(`Missing required parameter '${abi_param.name}'`);
             }
-            // Validate type
             try {
-                const normalizedType = normalizeType(abiParam.type);
-                createVMParameter(methodParams[abiParam.name], normalizedType, true);
+                createVMParameter(method_params[abi_param.name], abi_param.type, true);
             }
             catch (error) {
-                throw new Error(`Invalid parameter '${abiParam.name}': ${error}`);
+                throw new Error(`Invalid parameter '${abi_param.name}': ${error}`);
             }
         }
-        // Check for extra parameters
-        const expectedParams = new Set(entry.params.map(p => p.name));
-        for (const key in methodParams) {
-            if (!expectedParams.has(key)) {
-                console.warn(`Warning: Unexpected parameter '${key}' for method '${methodName}'`);
+        const expected_params = new Set(entry.params.map(p => p.name));
+        for (const key in method_params) {
+            if (!expected_params.has(key)) {
+                console.warn(`Warning: Unexpected parameter '${key}' for method '${method_name}'`);
             }
         }
         return true;
@@ -147,7 +189,7 @@ export class Contract {
  * Helper function to create a typed contract instance
  * This provides better TypeScript support when the ABI is known at compile time
  */
-export function createContract(address, abi) {
+export function create_contract(address, abi) {
     return new Contract(address, abi);
 }
 /**
@@ -161,12 +203,12 @@ export class ContractFactory {
      * Create a new contract instance at the specified address
      */
     at(address) {
-        return createContract(address, this.abi);
+        return create_contract(address, this.abi);
     }
     /**
      * Get the ABI
      */
-    getABI() {
+    get_abi() {
         return this.abi;
     }
 }