@xelis/sdk 0.11.15 → 0.11.17

package/dist/esm/xswd/relayer/index.js

@@ -1,46 +1,44 @@
 import { App } from './app.js';
-var Relayer = /** @class */ (function () {
-    function Relayer(props) {
-        var _this = this;
-        this.onOpen = function (e) {
-            _this.message_timeout = window.setTimeout(function () {
-                _this.app.setError("timeout occured (did not receive any message)");
+class Relayer {
+    constructor(props) {
+        this.onOpen = (e) => {
+            this.message_timeout = window.setTimeout(() => {
+                this.app.setError("timeout occured (did not receive any message)");
             }, 3000);
         };
-        this.onMessage = function (e) {
-            window.clearTimeout(_this.message_timeout);
+        this.onMessage = (e) => {
+            window.clearTimeout(this.message_timeout);
             try {
                 console.log(e);
-                var data = JSON.parse(e.data);
+                const data = JSON.parse(e.data);
                 if (data.channel_id) {
-                    _this.app.setQRCode(data.channel_id);
+                    this.app.setQRCode(data.channel_id);
                 }
                 else {
-                    _this.app.setError("channel id not found");
+                    this.app.setError("channel id not found");
                 }
             }
             catch (e) {
-                _this.app.setError("invalid data format");
+                this.app.setError("invalid data format");
             }
         };
-        this.onError = function (e) {
-            _this.app.setError("connection failed");
+        this.onError = (e) => {
+            this.app.setError("connection failed");
         };
-        this.onClose = function (e) {
-            _this.app.setError("connection closed");
+        this.onClose = (e) => {
+            this.app.setError("connection closed");
         };
         this.props = props;
         this.app = new App(this);
         this.ws = new WebSocket(this.props.url);
-        this.ws.addEventListener("open", this.onOpen);
-        this.ws.addEventListener("message", this.onMessage);
-        this.ws.addEventListener("error", this.onError);
-        this.ws.addEventListener("close", this.onClose);
+        this.ws.addEventListener(`open`, this.onOpen);
+        this.ws.addEventListener(`message`, this.onMessage);
+        this.ws.addEventListener(`error`, this.onError);
+        this.ws.addEventListener(`close`, this.onClose);
     }
-    Relayer.prototype.close = function () {
+    close() {
         this.ws.close();
         this.app.element.remove();
-    };
-    return Relayer;
-}());
+    }
+}
 export default Relayer;

package/dist/esm/xswd/websocket.js

@@ -1,35 +1,16 @@
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 import { WSRPC } from '../rpc/websocket.js';
 import { DaemonMethods } from '../daemon/websocket.js';
 import { WalletMethods } from '../wallet/websocket.js';
-var WS = /** @class */ (function (_super) {
-    __extends(WS, _super);
-    function WS(endpoint) {
-        var _this = _super.call(this, endpoint) || this;
-        _this.callTimeout = 0; // xswd needs user input for confirmation - timeout should not be used
-        _this.daemon = new DaemonMethods(_this, "node.");
-        _this.wallet = new WalletMethods(_this, "wallet.");
-        return _this;
+export class WS extends WSRPC {
+    constructor(endpoint) {
+        super(endpoint);
+        this.callTimeout = 0; // xswd needs user input for confirmation - timeout should not be used
+        this.daemon = new DaemonMethods(this, "node.");
+        this.wallet = new WalletMethods(this, "wallet.");
     }
-    WS.prototype.authorize = function (app) {
-        var data = JSON.stringify(app);
+    authorize(app) {
+        const data = JSON.stringify(app);
         return this.rawCall(0, data);
-    };
-    return WS;
-}(WSRPC));
-export { WS };
+    }
+}
 export default WS;

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

@@ -0,0 +1,80 @@
+export interface ABIParam {
+    name: string;
+    type: string;
+}
+export interface ABIEntry {
+    chunk_id: number;
+    name: string;
+    outputs?: string;
+    params: ABIParam[];
+    type: 'entry' | 'view';
+}
+export interface ABI {
+    data: ABIEntry[];
+    version: string;
+}
+export interface ContractCallParams {
+    [key: string]: any;
+    maxGas?: number;
+    deposits?: Record<string, number | bigint>;
+}
+export interface IContract {
+    readonly address: string;
+    readonly abi: ABI;
+    invoke(methodName: string, params?: ContractCallParams): Record<string, any>;
+}
+type GenerateContractMethods<T extends ABI> = {
+    [K in T['data'][number]['name']]: (params?: ContractCallParams) => Record<string, any>;
+};
+/**
+ * Contract class that dynamically generates methods based on ABI
+ */
+export declare class Contract<T extends ABI = ABI> implements IContract {
+    readonly address: string;
+    readonly abi: T;
+    private readonly methods;
+    constructor(address: string, abi: T);
+    /**
+     * Creates a dynamic method on the contract instance
+     */
+    private createDynamicMethod;
+    /**
+     * Invoke a contract method by name
+     * @param methodName - Name of the method from the ABI
+     * @param params - Parameters for the method call
+     */
+    invoke(methodName: string, params?: ContractCallParams): Record<string, any>;
+    /**
+     * Get list of available methods
+     */
+    getMethods(): string[];
+    /**
+     * Get method signature information
+     */
+    getMethodSignature(methodName: string): ABIEntry | undefined;
+    /**
+     * Validate parameters for a method without creating the transaction
+     */
+    validateParams(methodName: 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>;
+/**
+ * Factory for creating multiple contracts with the same ABI
+ */
+export declare class ContractFactory<T extends ABI = ABI> {
+    private readonly abi;
+    constructor(abi: T);
+    /**
+     * Create a new contract instance at the specified address
+     */
+    at(address: string): Contract<T> & GenerateContractMethods<T>;
+    /**
+     * Get the ABI
+     */
+    getABI(): T;
+}
+export {};

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

@@ -0,0 +1,94 @@
+export interface ABIParam {
+    name: string;
+    type: string;
+    optional?: boolean;
+    default?: any;
+}
+export interface ABIEntry {
+    chunk_id: number;
+    name: string;
+    outputs?: string | string[];
+    params: ABIParam[];
+    type: 'entry' | 'view';
+    description?: string;
+}
+export type ABI = {
+    data: ABIEntry[];
+    version: string;
+};
+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 ExtractParams<T extends ABIEntry> = {
+    [K in T['params'][number] as K['name']]: K extends {
+        optional: true;
+    } ? ParamType<K['type']> | undefined : ParamType<K['type']>;
+} & {
+    maxGas?: number;
+    deposits?: Record<string, number | bigint>;
+};
+type MethodFromEntry<T extends ABIEntry> = (params: ExtractParams<T>) => Record<string, any>;
+type MethodsFromABI<T extends ABI> = {
+    [K in T['data'][number] as K['name']]: MethodFromEntry<K>;
+};
+/**
+ * Strongly typed contract class
+ */
+export declare class TypedContract<T extends ABI> {
+    readonly address: string;
+    readonly abi: T;
+    private readonly methods;
+    constructor(address: string, abi: T);
+    /**
+     * Internal method to invoke contract functions
+     */
+    invokeUnsafe(methodName: 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>;
+    /**
+     * Get list of available methods
+     */
+    getMethods(): string[];
+    /**
+     * Get method signature information
+     */
+    getMethodSignature(methodName: string): ABIEntry | undefined;
+    /**
+     * Generate TypeScript interface for the contract
+     */
+    generateInterface(): string;
+    private getTypeScriptType;
+}
+/**
+ * Create a typed contract instance with full TypeScript support
+ */
+export declare function createTypedContract<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);
+    /**
+     * Create a new contract instance at the specified address
+     */
+    at(address: string): TypedContract<T> & MethodsFromABI<T>;
+    /**
+     * Get the ABI
+     */
+    getABI(): T;
+    /**
+     * Generate TypeScript definitions for this contract
+     */
+    generateTypeDefinitions(): string;
+}
+/**
+ * Utility to validate ABI structure
+ */
+export declare function validateABI(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 {};

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

@@ -0,0 +1,69 @@
+export interface VMParameter {
+    type: string;
+    value: any;
+}
+declare const TYPE_VALIDATORS: {
+    readonly u256: (v: any) => number;
+    readonly u128: (v: any) => number;
+    readonly u64: (v: any) => number;
+    readonly u32: (v: any) => number;
+    readonly u16: (v: any) => number;
+    readonly u8: (v: any) => number;
+    readonly boolean: (v: any) => boolean;
+    readonly string: (v: any) => string;
+    readonly Hash: (v: any) => string;
+    readonly Address: (v: any) => string;
+    readonly PublicKey: (v: any) => string;
+    readonly Blob: (v: any) => string;
+};
+export type ValidationType = keyof typeof TYPE_VALIDATORS;
+/**
+ * Creates a VM-compatible parameter object
+ * @param value - The value to wrap
+ * @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;
+/**
+ * Convenience functions for common types
+ */
+export declare const vmParam: {
+    hash: (value: string) => VMParameter;
+    address: (value: string) => VMParameter;
+    publicKey: (value: string) => VMParameter;
+    blob: (value: string) => VMParameter;
+    u64: (value: number | bigint) => VMParameter;
+    u32: (value: number) => VMParameter;
+    u16: (value: number) => VMParameter;
+    u8: (value: number) => VMParameter;
+    string: (value: string) => VMParameter;
+    boolean: (value: boolean) => VMParameter;
+};
+/**
+ * Creates a deposits object for contract calls
+ * @param deposits - Object mapping token hashes to amounts
+ */
+export declare function createDeposits(deposits: Record<string, number | bigint>): Record<string, {
+    amount: number | bigint;
+}>;
+/**
+ * Creates a contract invocation object
+ */
+export interface ContractInvocationParams {
+    contract: string;
+    chunkId: number;
+    parameters?: VMParameter[];
+    deposits?: Record<string, number | bigint>;
+    maxGas?: number;
+}
+export declare function createContractInvocation(params: ContractInvocationParams): Record<string, any>;
+/**
+ * Creates a contract deployment object
+ */
+export interface ContractDeploymentParams {
+    bytecode: string;
+    hasConstructor?: boolean;
+    maxGas?: number;
+}
+export declare function createContractDeployment(params: ContractDeploymentParams): Record<string, any>;
+export {};

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

@@ -58,9 +58,12 @@ export declare class RPC extends HttpRPC {
     getMultisig(params: types.GetMultisigParams): Promise<types.GetMultisigResult>;
     hasMultisig(params: types.HasMultisigParams): Promise<boolean>;
     hasMultisigAtTopoheight(params: types.HasMultisigAtTopoheightParams): Promise<boolean>;
-    getContractOutputs(params: types.GetContractOutputsParams): Promise<types.ContractOutput[]>;
+    getContractLogs(params: types.GetContractLogsParams): Promise<types.ContractLog[]>;
+    getContractScheduledExecutionsAtTopoheight(params: types.GetContractScheduledExecutionsAtTopoheightParams): Promise<types.ScheduledExecution[]>;
+    getContractRegisteredExecutionsAtTopoheight(params: types.GetContractScheduledExecutionsAtTopoheightParams): Promise<[number, string][]>;
+    getContractOutputs(params: types.GetContractOutputsParams): Promise<types.ContractOutputs>;
     getContractModule(params: types.GetContractModuleParams): Promise<types.GetContractModuleResult>;
-    getContractData(params: types.GetContractModuleParams): Promise<unknown>;
+    getContractData(params: types.GetContractDataParams): Promise<unknown>;
     getContractDataAtTopoheight(params: types.GetContractDataAtTopoheightParams): Promise<unknown>;
     getContractBalance(params: types.GetContractBalanceParams): Promise<types.GetContractBalanceResult>;
     getContractBalanceAtTopoheight(params: types.GetContractBalanceAtTopoheightParams): Promise<types.GetContractBalanceAtTopoheightResult>;

package/dist/types/daemon/types.d.ts

@@ -174,7 +174,7 @@ export interface Burn {
     amount: number;
 }
 export interface MultiSigPayload {
-    participants: string[];
+    participants: number[];
     threshold: number;
 }
 export interface ContractDeposit {
@@ -456,12 +456,13 @@ export interface HasMultisigParams {
     topoheight?: number;
 }
 export interface GetContractOutputsParams {
-    transaction: string;
+    address: string;
+    topoheight: number;
 }
 export interface GetContractModuleParams {
     contract: string;
 }
-export interface GetContractDataPrams {
+export interface GetContractDataParams {
     contract: string;
     key: any;
 }
@@ -509,20 +510,6 @@ export interface GetContractBalanceResult {
     amount: number;
     previous_topoheight: number | null;
 }
-export interface ContractOutputRefundGas {
-    amount: number;
-}
-export interface ContractOutputTransfer {
-    amount: number;
-    asset: string;
-    destination: string;
-}
-export interface ContractOutputExitCode {
-    exit_code: number;
-}
-export interface ContractOutputRefundDeposits {
-}
-export type ContractOutput = ContractOutputRefundGas | ContractOutputTransfer | ContractOutputExitCode | ContractOutputRefundDeposits;
 export interface TransactionResponse extends Transaction {
     in_mempool: boolean;
     blocks?: string[];
@@ -559,7 +546,7 @@ export interface InvokeContract {
     block_hash: string;
     tx_hash: string;
     topoheight: number;
-    contract_outputs: ContractOutput[];
+    contract_outputs: ContractLog[];
 }
 export interface NewContract {
     contract: string;
@@ -587,6 +574,95 @@ export interface ContractTransfer {
 export interface ContractEvent {
     data: any;
 }
+export interface GetContractLogsParams {
+    caller: string;
+}
+export interface GetContractScheduledExecutionsAtTopoheightParams {
+    topoheight: number;
+    max?: number;
+    min?: number;
+}
+export interface ScheduledExecution {
+    hash: string;
+    contract: string;
+    chunk_id: number;
+    params: any[];
+    max_gas: number;
+}
+export interface ContractLogRefundGas {
+    type: "refund_gas";
+    value: {
+        amount: number;
+    };
+}
+export interface ContractLogTransfer {
+    type: "transfer";
+    value: {
+        contract: string;
+        amount: number;
+        asset: string;
+        destination: string;
+    };
+}
+export interface ContractLogTransferContract {
+    type: "transfer_contract";
+    value: {
+        contract: string;
+        amount: number;
+        asset: string;
+        destination: string;
+    };
+}
+export interface ContractLogMint {
+    type: "mint";
+    value: {
+        contract: string;
+        asset: string;
+        amount: number;
+    };
+}
+export interface ContractLogBurn {
+    type: "burn";
+    value: {
+        contract: string;
+        asset: string;
+        amount: number;
+    };
+}
+export interface ContractLogNewAsset {
+    type: "new_asset";
+    value: {
+        contract: string;
+        asset: string;
+    };
+}
+export interface ContractLogExitCode {
+    type: "exit_code";
+    value?: number;
+}
+export interface ContractLogRefundDeposits {
+    type: "refund_deposits";
+}
+export interface ContractLogGasInjection {
+    type: "gas_injection";
+    value: {
+        contract: string;
+        amount: number;
+    };
+}
+export interface ContractLogScheduledExecution {
+    type: "scheduled_execution";
+    value: {
+        contract: string;
+        hash: string;
+        kind: "topo_height" | "block_end";
+    };
+}
+export type ContractLog = ContractLogRefundGas | ContractLogTransfer | ContractLogTransferContract | ContractLogMint | ContractLogBurn | ContractLogNewAsset | ContractLogExitCode | ContractLogRefundDeposits | ContractLogGasInjection | ContractLogScheduledExecution;
+export interface ContractOutputs {
+    caller: string;
+    outputs: ContractLog[];
+}
 export declare enum RPCMethod {
     GetVersion = "get_version",
     GetHeight = "get_height",
@@ -645,6 +721,9 @@ export declare enum RPCMethod {
     GetMultisig = "get_multisig",
     HasMultisig = "has_multisig",
     HasMultisigAtTopoheight = "has_multisig_at_topoheight",
+    GetContractLogs = "get_contract_logs",
+    GetContractScheduledExecutionsAtTopoheight = "get_contract_scheduled_executions_at_topoheight",
+    GetContractRegisteredExecutionsAtTopoheight = "get_contract_registered_executions_at_topoheight",
     GetContractOutputs = "get_contract_outputs",
     GetContractModule = "get_contract_module",
     GetContractData = "get_contract_data",

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

@@ -86,9 +86,12 @@ export declare class DaemonMethods {
     getMultisig(params: types.GetMultisigParams): Promise<types.GetMultisigResult>;
     hasMultisig(params: types.HasMultisigParams): Promise<boolean>;
     hasMultisigAtTopoheight(params: types.HasMultisigAtTopoheightParams): Promise<boolean>;
-    getContractOutputs(params: types.GetContractOutputsParams): Promise<types.ContractOutput[]>;
+    getContractLogs(params: types.GetContractLogsParams): Promise<types.ContractLog[]>;
+    getContractScheduledExecutionsAtTopoheight(params: types.GetContractScheduledExecutionsAtTopoheightParams): Promise<types.ScheduledExecution[]>;
+    getContractRegisteredExecutionsAtTopoheight(params: types.GetContractScheduledExecutionsAtTopoheightParams): Promise<[number, string][]>;
+    getContractOutputs(params: types.GetContractOutputsParams): Promise<types.ContractOutputs>;
     getContractModule(params: types.GetContractModuleParams): Promise<types.GetContractModuleResult>;
-    getContractData(params: types.GetContractModuleParams): Promise<unknown>;
+    getContractData(params: types.GetContractDataParams): Promise<unknown>;
     getContractDataAtTopoheight(params: types.GetContractDataAtTopoheightParams): Promise<unknown>;
     getContractBalance(params: types.GetContractBalanceParams): Promise<types.GetContractBalanceResult>;
     getContractBalanceAtTopoheight(params: types.GetContractBalanceAtTopoheightParams): Promise<types.GetContractBalanceAtTopoheightResult>;

package/package.json

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