@xelis/sdk 0.11.32 → 0.11.34

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/dist/types/daemon/types.d.ts

@@ -300,16 +300,27 @@ export interface Reference {
     hash: string;
     topoheight: number;
 }
+export interface SignatureId {
+    id: number;
+    signature: string;
+}
+export interface MultiSig {
+    signatures: {
+        [id: number]: SignatureId;
+    };
+}
 export interface Transaction {
     hash: string;
     version: number;
     source: string;
     data: TransactionData;
     fee: number;
+    fee_limit: number;
     nonce: number;
     source_commitments: SourceCommitment[];
     range_proof: number[];
     reference: Reference;
+    multisig?: MultiSig;
     signature: string;
     size: number;
 }
@@ -418,25 +429,23 @@ export interface MaxSupplyFixed {
 export interface MaxSupplyMintable {
     mintable: number;
 }
-export interface AssetCreator {
+export type MaxSupplyMode = "none" | MaxSupplyFixed | MaxSupplyMintable;
+export interface AssetOwnerCreator {
     contract: string;
     id: number;
 }
-export interface AssetOwner {
+export interface AssetOwnerOwner {
     origin: string;
     origin_id: number;
     owner: string;
 }
+export type AssetOwner = "none" | AssetOwnerCreator | AssetOwnerOwner;
 export interface AssetData {
     decimals: number;
     name: string;
     ticker: string;
-    max_supply: "none" | MaxSupplyFixed | MaxSupplyMintable;
-    owner: "none" | {
-        creator: AssetCreator;
-    } | {
-        owner: AssetOwner;
-    };
+    max_supply: MaxSupplyMode;
+    owner: AssetOwner;
     topoheight: number;
 }
 export interface AssetWithData extends AssetData {

package/dist/types/wallet/rpc.d.ts

@@ -25,7 +25,7 @@ export declare class RPC extends HttpRPC {
     buildTransaction(params: types.BuildTransactionParams): Promise<types.TransactionResponse>;
     buildTransactionOffline(params: types.BuildTransactionOfflineParams): Promise<types.TransactionResponse>;
     buildUnsignedTransaction(params: types.BuildTransactionParams): Promise<types.UnsignedTransactionResponse>;
-    signUnsignedTransaction(params: types.SignUnsignedTransactionParams): Promise<types.SignatureId>;
+    signUnsignedTransaction(params: types.SignUnsignedTransactionParams): Promise<daemonTypes.SignatureId>;
     finalizeUnsignedTransaction(params: types.FinalizeUnsignedTransactionParams): Promise<types.TransactionResponse>;
     clearTxCache(): Promise<boolean>;
     listTransactions(params?: types.ListTransactionParams): Promise<types.TransactionEntry[]>;

package/dist/types/wallet/types.d.ts

@@ -2,10 +2,20 @@ import * as daemonTypes from '../daemon/types';
 export interface GetAddressParams {
     integrated_data?: string;
 }
-export interface FeeBuilder {
-    multiplier?: number;
-    value?: number;
+export interface ExtraFeeModeTip {
+    tip: number;
 }
+export interface ExtraFeeModeMultiplier {
+    multiplier: number;
+}
+export type ExtraFeeMode = "none" | ExtraFeeModeTip | ExtraFeeModeMultiplier;
+export interface FeeBuilderFixed {
+    fixed: number;
+}
+export interface FeeBuilderExtra {
+    extra: ExtraFeeMode;
+}
+export type FeeBuilder = FeeBuilderFixed | FeeBuilderExtra;
 export interface MultiSigBuilder {
     participants: string[];
     threshold: number;
@@ -44,45 +54,51 @@ export interface SignerId {
     id: number;
     private_key: number[];
 }
-export interface BuildTransactionParams {
+export interface BaseFeeModeFixed {
+    fixed: number;
+}
+export interface BaseFeeModeCap {
+    cap: number;
+}
+type BaseFeeMode = "none" | BaseFeeModeFixed | BaseFeeModeCap;
+export interface BuildUnsignedTransaction {
     transfers?: TransferBuilder[];
     burn?: daemonTypes.Burn;
     multi_sig?: MultiSigBuilder;
     invoke_contract?: InvokeContractBuilder;
     deploy_contract?: DeployContractBuilder;
     fee?: FeeBuilder;
+    base_fee?: BaseFeeMode;
+    fee_limit?: number;
     nonce?: number;
     tx_version?: number;
-    broadcast: boolean;
     tx_as_hex: boolean;
+}
+export interface BuildTransactionParams extends BuildUnsignedTransaction {
+    broadcast: boolean;
     signers?: SignerId[];
 }
 export interface BuildTransactionOfflineParams extends BuildTransactionParams {
-    nonce: number;
+    balances: {
+        [hash: string]: any;
+    };
     reference: daemonTypes.Reference;
+    nonce: number;
 }
 export interface TransactionResponse extends daemonTypes.Transaction {
     txt_as_hex?: string;
 }
-export interface SignatureId {
-    id: number;
-    signature: string;
-}
-export interface MultiSig {
-    signatures: {
-        [id: number]: SignatureId;
-    };
-}
 export interface UnsignedTransaction {
     version: number;
     source: string;
     data: daemonTypes.TransactionData;
     fee: number;
+    fee_limit: number;
     nonce: number;
     source_commitments: daemonTypes.SourceCommitment[];
     reference: daemonTypes.Reference;
     range_proof: number[];
-    multisig?: MultiSig;
+    multisig?: daemonTypes.MultiSig;
 }
 export interface UnsignedTransactionResponse extends UnsignedTransaction {
     hash: string;
@@ -201,7 +217,7 @@ export interface SignUnsignedTransactionParams {
 }
 export interface FinalizeUnsignedTransactionParams {
     unsigned: string;
-    signatures: SignatureId[];
+    signatures: daemonTypes.SignatureId[];
     broadcast: boolean;
     tx_as_hex: boolean;
 }
@@ -366,3 +382,4 @@ export declare enum RPCEvent {
     TrackAsset = "track_asset",
     UntrackAsset = "untrack_asset"
 }
+export {};

package/dist/types/wallet/websocket.d.ts

@@ -77,7 +77,7 @@ export declare class WalletMethods {
     buildTransaction(params: types.BuildTransactionParams): Promise<types.TransactionResponse>;
     buildTransactionOffline(params: types.BuildTransactionOfflineParams): Promise<types.TransactionResponse>;
     buildUnsignedTransaction(params: types.BuildTransactionParams): Promise<types.UnsignedTransactionResponse>;
-    signUnsignedTransaction(params: types.SignUnsignedTransactionParams): Promise<types.SignatureId>;
+    signUnsignedTransaction(params: types.SignUnsignedTransactionParams): Promise<daemonTypes.SignatureId>;
     finalizeUnsignedTransaction(params: types.FinalizeUnsignedTransactionParams): Promise<types.TransactionResponse>;
     clearTxCache(): Promise<boolean>;
     listTransactions(params?: types.ListTransactionParams): Promise<types.TransactionEntry[]>;

package/package.json

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