@xelis/sdk 0.11.32 → 0.11.33

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 {};

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

@@ -9,14 +9,30 @@ export interface ABIEntry {
     name: string;
     outputs?: string | string[];
     params: ABIParam[];
-    type: 'entry' | 'view';
+    type: 'entry';
     description?: string;
 }
+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 type ABI = {
     data: ABIEntry[];
     version: string;
+    internal_types?: InternalType[];
 };
-type ParamType<T extends string> = T extends 'Hash' ? string : T extends 'Address' ? string : T extends 'PublicKey' ? string : T extends 'Blob' ? string : T extends 'String' | 'string' ? string : T extends 'Boolean' | 'boolean' | 'bool' ? boolean : T extends 'U256' | 'u256' ? bigint | number : T extends 'U128' | 'u128' ? bigint | number : T extends 'U64' | 'u64' ? bigint | number : T extends 'U32' | 'u32' ? number : T extends 'U16' | 'u16' ? number : T extends 'U8' | 'u8' ? number : any;
+type ParamType<T extends string> = T extends 'Hash' ? string : T extends 'Address' ? string : T extends 'PublicKey' ? string : T extends 'Blob' ? string : T extends 'String' | 'string' ? string : T extends 'Boolean' | 'boolean' | 'bool' ? boolean : T extends 'U256' | 'u256' ? bigint | number : T extends 'U128' | 'u128' ? bigint | number : T extends 'U64' | 'u64' ? bigint | number : T extends 'U32' | 'u32' ? number : T extends 'U16' | 'u16' ? number : T extends 'U8' | 'u8' ? number : T extends `${infer Inner}[]` ? Array<ParamType<Inner>> : T extends `optional<${infer Inner}>` ? ParamType<Inner> | null | undefined : T extends `map<${infer K}, ${infer V}>` ? ParamType<K> extends string | number | symbol ? Record<ParamType<K>, ParamType<V>> : Record<string, ParamType<V>> : T extends `(${string})` ? any[] : any;
 type ExtractParams<T extends ABIEntry> = {
     [K in T['params'][number] as K['name']]: K extends {
         optional: true;
@@ -37,39 +53,58 @@ export declare class TypedContract<T extends ABI> {
     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;
     /**
      * Internal method to invoke contract functions
      */
-    invokeUnsafe(methodName: string, params?: any): Record<string, any>;
+    invokeUnsafe(method_name: string, params?: any): Record<string, any>;
     /**
      * Type-safe invoke method
      */
-    invoke<K extends T['data'][number]['name']>(methodName: K, params: K extends T['data'][number]['name'] ? T['data'][number] extends infer E ? E extends ABIEntry ? E['name'] extends K ? ExtractParams<E> : never : never : never : never): Record<string, any>;
+    invoke<K extends T['data'][number]['name']>(method_name: K, params: K extends T['data'][number]['name'] ? T['data'][number] extends infer E ? E extends ABIEntry ? E['name'] extends K ? ExtractParams<E> : never : never : never : never): 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;
     /**
      * Generate TypeScript interface for the contract
      */
-    generateInterface(): string;
-    private getTypeScriptType;
+    generate_interface(): string;
+    private get_typescript_type;
 }
 /**
  * Create a typed contract instance with full TypeScript support
  */
-export declare function createTypedContract<T extends ABI>(address: string, abi: T): TypedContract<T> & MethodsFromABI<T>;
+export declare function create_typed_contract<T extends ABI>(address: string, abi: T): TypedContract<T> & MethodsFromABI<T>;
 /**
  * Contract factory with strong typing
  */
 export declare class TypedContractFactory<T extends ABI> {
     private readonly abi;
-    private readonly contractName;
-    constructor(abi: T, contractName?: string);
+    private readonly contract_name;
+    constructor(abi: T, contract_name?: string);
     /**
      * Create a new contract instance at the specified address
      */
@@ -77,18 +112,18 @@ export declare class TypedContractFactory<T extends ABI> {
     /**
      * Get the ABI
      */
-    getABI(): T;
+    get_abi(): T;
     /**
      * Generate TypeScript definitions for this contract
      */
-    generateTypeDefinitions(): string;
+    generate_type_definitions(): string;
 }
 /**
  * Utility to validate ABI structure
  */
-export declare function validateABI(abi: any): abi is ABI;
+export declare function validate_abi(abi: any): abi is ABI;
 /**
  * Helper to create a contract from JSON ABI
  */
-export declare function createContractFromJSON(address: string, abiPath: string): Promise<TypedContract<ABI> & MethodsFromABI<ABI>>;
+export declare function create_contract_from_json(address: string, abi_path: string): Promise<TypedContract<ABI> & MethodsFromABI<ABI>>;
 export {};

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

@@ -23,14 +23,26 @@ export type ValidationType = keyof typeof TYPE_VALIDATORS;
  * @param type - The type string (e.g., 'u64', 'Hash', 'string')
  * @param validate - Whether to validate and convert the value (default: true)
  */
-export declare function createVMParameter(value: any, type: ValidationType, validate?: boolean): VMParameter;
+export declare function createVMPrimitive(value: any, type: ValidationType, validate?: boolean): VMParameter;
+/**
+ * Serialize an array of values
+ */
+export declare function serialize_array(items: any[], item_type: string): VMParameter;
+/**
+ * Serialize a map
+ */
+export declare function serialize_map(map: Record<string, any>, keyType: string, valueType: string): VMParameter;
+/**
+ * Serialize an optional value
+ */
+export declare function serialize_optional(value: any, inner_type: string): VMParameter;
 /**
  * Convenience functions for common types
  */
-export declare const vmParam: {
+export declare const VMParam: {
     hash: (value: string) => VMParameter;
     address: (value: string) => VMParameter;
-    publicKey: (value: string) => VMParameter;
+    public_key: (value: string) => VMParameter;
     blob: (value: string) => VMParameter;
     u64: (value: number | bigint) => VMParameter;
     u32: (value: number) => VMParameter;
@@ -39,6 +51,57 @@ export declare const vmParam: {
     string: (value: string) => VMParameter;
     boolean: (value: boolean) => VMParameter;
 };
+/**
+ * A type that knows how to serialize itself to VMParameter
+ */
+export interface SerializableType {
+    readonly name: string;
+    to_VMParameter(value: any): VMParameter;
+}
+/**
+ * Enum variant schema
+ */
+export interface EnumVariantSchema {
+    name: string;
+    fields: Array<{
+        name: string;
+        type: string;
+    }>;
+}
+/**
+ * Struct field schema
+ */
+export interface StructFieldSchema {
+    name: string;
+    type: string;
+}
+/**
+ * Define an enum type from ABI schema
+ */
+export declare function defineEnum(name: string, variants: EnumVariantSchema[]): SerializableType;
+/**
+ * Define a struct type from ABI schema
+ */
+export declare function defineStruct(name: string, fields: StructFieldSchema[]): SerializableType;
+/**
+ * Type registry - simple Map for custom types
+ */
+declare class TypeRegistry {
+    private types;
+    register(definition: SerializableType): SerializableType;
+    get(name: string): SerializableType | undefined;
+    has(name: string): boolean;
+    clear(): void;
+    all(): Iterable<SerializableType>;
+}
+export declare const typeRegistry: 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 declare function createVMParameter(value: any, type: string, validate?: boolean): VMParameter;
 /**
  * Creates a deposits object for contract calls
  * @param deposits - Object mapping token hashes to amounts
@@ -51,8 +114,9 @@ export declare function createDeposits(deposits: Record<string, number | bigint>
  */
 export interface ContractInvocationParams {
     contract: string;
-    chunkId: number;
+    chunk_id: number;
     parameters?: VMParameter[];
+    permission: string;
     deposits?: Record<string, number | bigint>;
     maxGas?: number;
 }

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.11.32",
+  "version": "0.11.33",
   "name": "@xelis/sdk",
   "description": "Xelis software development kit for JS",
   "exports": {