@1money/protocol-ts-sdk 1.0.14

package/es/api/index.js

@@ -0,0 +1,593 @@
+import axios$1 from'axios';import'viem';import'@ethereumjs/rlp';function _typeof(ele) {
+    if (typeof ele !== 'object')
+        return (typeof ele).toLowerCase();
+    const typeStr = Object.prototype.toString.call(ele);
+    return typeStr.slice(8, typeStr.length - 1).toLowerCase();
+}class ResponsePromise {
+    _success;
+    _failure;
+    _error;
+    _login;
+    _timeout;
+    _rest;
+    _resolve;
+    _reject;
+    promiseWrapper;
+    _restScope;
+    constructor() {
+        this.promiseWrapper = new Promise((resolve, reject) => {
+            this._resolve = resolve;
+            this._reject = reject;
+        });
+        this._restScope = ['success', 'failure', 'error', 'login', 'timeout'];
+        for (let i = 0; i < this._restScope.length; i++) {
+            const method = this._restScope[i];
+            if (!method)
+                continue;
+            this.promiseWrapper[method] = _callback => {
+                // @ts-ignore
+                if (typeof _callback === 'function')
+                    this[`_${method}`] = _callback;
+                const wrapper = this.promiseWrapper;
+                delete wrapper[method];
+                const methods = this._restScope.slice();
+                methods.splice(methods.indexOf(method), 1);
+                if (methods.every(_m => !!_m && !wrapper[_m]))
+                    delete wrapper.rest;
+                return wrapper;
+            };
+        }
+        this.promiseWrapper.rest = (onRest, scope) => {
+            // @ts-ignore
+            if (typeof onRest === 'function')
+                this._rest = onRest;
+            const wrapper = this.promiseWrapper;
+            delete wrapper.rest;
+            this._restScope = scope || this._restScope;
+            // @ts-ignore
+            if (this._restScope.length === 0) {
+                console.warn('[1Money client]: The ".rest(cb, scope)" scope is empty and will never be triggered!');
+            }
+            else {
+                let deletedCounter = 0;
+                this._restScope.forEach(method => {
+                    if (!method)
+                        return;
+                    if (wrapper[method]) {
+                        delete wrapper[method];
+                    }
+                    else {
+                        deletedCounter++;
+                    }
+                });
+                if (deletedCounter === this._restScope.length) {
+                    console.warn(`[1Money client]: The "${this._restScope.join(', ')}" had been called and the "rest" will never be triggered!`);
+                }
+            }
+            return wrapper;
+        };
+    }
+}
+class Request {
+    _config;
+    axios;
+    constructor(config) {
+        this._config = config || {};
+        this.axios = axios$1;
+        this.parseError = this.parseError.bind(this);
+        this.setting = this.setting.bind(this);
+        this.request = this.request.bind(this);
+    }
+    parseError(err) {
+        if (typeof err === 'string')
+            err = new Error(err);
+        // Ensure we have a valid error object
+        if (!err || (_typeof(err) !== 'object' && _typeof(err) !== 'error')) {
+            err = new Error('Unknown error occurred');
+        }
+        const name = err?.name ?? 'Error';
+        const message = err?.message ?? err?.toString?.() ?? 'Unknown error';
+        const stack = err?.stack ?? '';
+        const status = err?.response?.status ?? 500;
+        const data = err?.response?.data ?? undefined;
+        // Validate status code
+        if (typeof status !== 'number' || status < 100 || status > 599) {
+            return {
+                name: 'InvalidStatusError',
+                message: 'Invalid HTTP status code',
+                stack,
+                status: 500,
+                data
+            };
+        }
+        return {
+            name,
+            message,
+            stack,
+            status,
+            data
+        };
+    }
+    setting(config) {
+        if (!config)
+            return console.warn('[1Money client]: setting method required correct parameters!');
+        this._config = { ...this._config, ...config };
+    }
+    request(options) {
+        // Set default security headers
+        options.withCredentials = typeof options.withCredentials === 'boolean' ? options.withCredentials : true;
+        options.headers = options.headers || {};
+        options.headers['Accept'] = options.headers['Accept'] || '*/*';
+        options.headers['X-Requested-With'] = options.headers['X-Requested-With'] || 'XMLHttpRequest';
+        options.headers['X-Content-Type-Options'] = options.headers['X-Content-Type-Options'] || 'nosniff';
+        const { onSuccess: initOnSuccess, onFailure: initOnFailure, onLogin: initOnLogin, onError: initOnError, onTimeout: initOnTimeout, isSuccess: initIsSuccess, isLogin: initIsLogin, timeout: initTimeout, } = this._config;
+        const { onSuccess, onFailure, onLogin, onError, onTimeout, isSuccess, isLogin, timeout, } = options;
+        const rules = {
+            success: isSuccess ?? initIsSuccess,
+            login: isLogin ?? initIsLogin,
+        };
+        const ResPromise = new ResponsePromise();
+        Promise.resolve().then(() => {
+            const callbacks = {
+                success: ResPromise._success ??
+                    (~ResPromise._restScope.indexOf('success') ? ResPromise._rest : undefined) ??
+                    onSuccess ??
+                    initOnSuccess ??
+                    ((r, h) => r),
+                failure: ResPromise._failure ??
+                    (~ResPromise._restScope.indexOf('failure') ? ResPromise._rest : undefined) ??
+                    onFailure ??
+                    initOnFailure ??
+                    ((v, h) => v),
+                error: ResPromise._error ??
+                    (~ResPromise._restScope.indexOf('error') ? ResPromise._rest : undefined) ??
+                    onError ??
+                    initOnError ??
+                    ((v, h) => v),
+                login: ResPromise._login ??
+                    (~ResPromise._restScope.indexOf('login') ? ResPromise._rest : undefined) ??
+                    onLogin ??
+                    initOnLogin ??
+                    ((v, h) => v),
+                timeout: ResPromise._timeout ??
+                    (~ResPromise._restScope.indexOf('timeout') ? ResPromise._rest : undefined) ??
+                    onTimeout ??
+                    initOnTimeout ??
+                    ((v, h) => v),
+            };
+            const existedHandler = {
+                success: !!(ResPromise._success ||
+                    (ResPromise._rest && ~ResPromise._restScope.indexOf('success')) ||
+                    onSuccess ||
+                    initOnSuccess),
+                failure: !!(ResPromise._failure ||
+                    (ResPromise._rest && ~ResPromise._restScope.indexOf('failure')) ||
+                    onFailure ||
+                    initOnFailure),
+                login: !!(ResPromise._login ||
+                    (ResPromise._rest && ~ResPromise._restScope.indexOf('login')) ||
+                    onLogin ||
+                    initOnLogin),
+                error: !!(ResPromise._error ||
+                    (ResPromise._rest && ~ResPromise._restScope.indexOf('error')) ||
+                    onError ||
+                    initOnError),
+                timeout: !!(ResPromise._timeout ||
+                    (ResPromise._rest && ~ResPromise._restScope.indexOf('timeout')) ||
+                    onTimeout ||
+                    initOnTimeout),
+            };
+            const existedChainHandler = {
+                success: !!(ResPromise._success ||
+                    (ResPromise._rest && ~ResPromise._restScope.indexOf('success'))),
+                failure: !!(ResPromise._failure ||
+                    (ResPromise._rest && ~ResPromise._restScope.indexOf('failure'))),
+                login: !!(ResPromise._login ||
+                    (ResPromise._rest && ~ResPromise._restScope.indexOf('login'))),
+                error: !!(ResPromise._error ||
+                    (ResPromise._rest && ~ResPromise._restScope.indexOf('error'))),
+                timeout: !!(ResPromise._timeout ||
+                    (ResPromise._rest && ~ResPromise._restScope.indexOf('timeout'))),
+            };
+            const errorHandler = async (e, headers) => {
+                try {
+                    let err = this.parseError(e);
+                    const result = await Promise.resolve(callbacks.error(err, headers));
+                    if (existedChainHandler.error)
+                        err = result;
+                    existedHandler.error ? ResPromise._resolve(err) : ResPromise._reject(err);
+                }
+                catch (_e) {
+                    ResPromise._reject(this.parseError(_e));
+                }
+            };
+            let timer = null;
+            let isTimeout = false;
+            const _timeout = timeout ?? initTimeout;
+            // Cleanup function for timeout
+            const cleanup = () => {
+                if (timer !== null) {
+                    clearTimeout(timer);
+                    timer = null;
+                }
+            };
+            if (_timeout) {
+                timer = setTimeout(async () => {
+                    try {
+                        isTimeout = true;
+                        cleanup();
+                        let err = this.parseError('timeout');
+                        // @ts-ignore
+                        const res = await Promise.resolve(callbacks.timeout(err, options.headers ?? {}));
+                        if (existedChainHandler.timeout)
+                            err = res;
+                        existedHandler.timeout ? ResPromise._resolve(err) : ResPromise._reject(err);
+                    }
+                    catch (e) {
+                        errorHandler(e, options.headers ?? {});
+                    }
+                }, _timeout);
+            }
+            this.axios(options).then(async (response) => {
+                if (isTimeout)
+                    return;
+                cleanup();
+                const { status, data, headers } = response;
+                try {
+                    const doSuccess = rules.success?.(data, status, headers);
+                    const doLogin = rules.login?.(data, status, headers);
+                    let res = data;
+                    if (doLogin) {
+                        const result = await Promise.resolve(callbacks.login(data, headers));
+                        if (existedChainHandler.login)
+                            res = result;
+                    }
+                    else if (doSuccess) {
+                        const result = await Promise.resolve(callbacks.success(data, headers));
+                        if (existedChainHandler.success)
+                            res = result;
+                    }
+                    else {
+                        const result = await Promise.resolve(callbacks.failure(data, headers));
+                        if (existedChainHandler.failure)
+                            res = result;
+                    }
+                    ResPromise._resolve(res);
+                }
+                catch (e) {
+                    errorHandler(e, headers);
+                }
+            }).catch(async (err) => {
+                if (isTimeout)
+                    return;
+                cleanup();
+                console.error(`[1Money client]: Error(${err.status ?? 500}, ${err.code ?? 'UNKNOWN'}), Message: ${err.message}, Config: ${err.config?.method}, ${err.config?.baseURL ?? ''}${err.config?.url ?? ''}, ${JSON.stringify(err.config?.headers ?? {})}, Request: ${JSON.stringify(err.config?.data ?? {})};`);
+                const status = err.response?.status ?? 500;
+                const data = err.response?.data ?? {};
+                const headers = err.response?.headers ?? {};
+                try {
+                    let res = data;
+                    const doLogin = rules.login?.(data, status, headers);
+                    if (doLogin) {
+                        res = await Promise.resolve(callbacks.login(res, headers));
+                        ResPromise._resolve(res);
+                    }
+                    else {
+                        errorHandler(err, headers);
+                    }
+                }
+                catch (e) {
+                    errorHandler(e, headers);
+                }
+            });
+        });
+        return ResPromise.promiseWrapper;
+    }
+}const { request, setting, axios } = new Request({
+    isSuccess: (res, status) => status === 200 && res.code == 0,
+    isLogin: (res, status) => status === 401 || res.code == 401,
+    timeout: 10000
+});
+function get(url, options) {
+    return request({
+        ...options,
+        method: 'get',
+        url
+    });
+}
+function post(url, data, options) {
+    return request({
+        ...options,
+        method: 'post',
+        url,
+        data,
+        headers: {
+            'Content-Type': 'application/json',
+            ...options?.headers,
+        }
+    });
+}
+function setInitConfig(config) {
+    const { baseURL, ...rest } = config;
+    axios.defaults.baseURL = baseURL || (typeof window !== 'undefined' ? location.origin : void 0);
+    setting(rest);
+}// Base URLs for the API
+const TESTNET_API_URL = 'https://api.testnet.1money.network';
+const MAINNET_API_URL = 'https://api.1money.network';
+const LOCAL_API_URL = 'http://localhost:18555';
+// API version
+const API_VERSION = 'v1';const API_PREFIX$5 = `/${API_VERSION}/accounts`;
+/**
+ * Accounts API methods
+ */
+const accountsApi = {
+    /**
+     * Get account nonce
+     * @param address Address of the account to lookup nonce for
+     * @returns Promise with account info response
+     */
+    getNonce: (address) => {
+        return get(`${API_PREFIX$5}/nonce?address=${address}`, { withCredentials: false });
+    },
+    /**
+     * Get associated token account
+     * @param address Address of the account to lookup associated token account for
+     * @param token Token address to lookup associated token account for
+     * @returns Promise with associated token account response
+     */
+    getTokenAccount: (address, token) => {
+        return get(`${API_PREFIX$5}/token_account?address=${address}&token=${token}`, { withCredentials: false });
+    }
+};const API_PREFIX$4 = `/${API_VERSION}/checkpoints`;
+/**
+ * Checkpoint API methods
+ */
+const checkpointsApi = {
+    /**
+     * Get the current checkpoint number
+     * @returns Promise with checkpoint number response
+     */
+    getNumber: () => {
+        return get(`${API_PREFIX$4}/number`, { withCredentials: false });
+    },
+    /**
+     * Get checkpoint by hash
+     * @param hash Hash of the checkpoint to lookup
+     * @param full Whether to include full transaction details
+     * @returns Promise with checkpoint response
+     */
+    getByHash: (hash, full = false) => {
+        return get(`${API_PREFIX$4}/by_hash?hash=${hash}&full=${full}`, { withCredentials: false });
+    },
+    /**
+     * Get checkpoint by number
+     * @param number Number of the checkpoint to lookup
+     * @param full Whether to include full transaction details
+     * @returns Promise with checkpoint response
+     */
+    getByNumber: (number, full = false) => {
+        return get(`${API_PREFIX$4}/by_number?number=${number}&full=${full}`, { withCredentials: false });
+    }
+};const API_PREFIX$3 = `/${API_VERSION}/tokens`;
+/**
+ * Tokens API methods
+ */
+const tokensApi = {
+    /**
+     * Get token metadata
+     * @param token Token address to lookup metadata for
+     * @returns Promise with token metadata response
+     */
+    getTokenMetadata: (token) => {
+        return get(`${API_PREFIX$3}/token_metadata?token=${token}`, { withCredentials: false });
+    },
+    /**
+     * Manage token blacklist
+     * @param payload Token blacklist request payload
+     * @returns Promise with transaction hash response
+     */
+    manageBlacklist: (payload) => {
+        return post(`${API_PREFIX$3}/manage_blacklist`, payload, { withCredentials: false });
+    },
+    /**
+     * Manage token whitelist
+     * @param payload Token whitelist request payload
+     * @returns Promise with transaction hash response
+     */
+    manageWhitelist: (payload) => {
+        return post(`${API_PREFIX$3}/manage_whitelist`, payload, { withCredentials: false });
+    },
+    /**
+     * Burn tokens
+     * @param payload Token burn request payload
+     * @returns Promise with transaction hash response
+     */
+    burnToken: (payload) => {
+        return post(`${API_PREFIX$3}/burn`, payload, { withCredentials: false });
+    },
+    /**
+     * Grant or revoke token authority
+     * @param payload Token authority request payload
+     * @returns Promise with transaction hash response
+     */
+    grantAuthority: (payload) => {
+        return post(`${API_PREFIX$3}/grant_authority`, payload, { withCredentials: false });
+    },
+    /**
+     * Issue new token
+     * @param payload Token issue request payload
+     * @returns Promise with transaction hash and token address response
+     */
+    issueToken: (payload) => {
+        return post(`${API_PREFIX$3}/issue`, payload, { withCredentials: false });
+    },
+    /**
+     * Mint tokens
+     * @param payload Token mint request payload
+     * @returns Promise with transaction hash response
+     */
+    mintToken: (payload) => {
+        return post(`${API_PREFIX$3}/mint`, payload, { withCredentials: false });
+    },
+    /**
+     * Pause or unpause token
+     * @param payload Token pause request payload
+     * @returns Promise with transaction hash response
+     */
+    pauseToken: (payload) => {
+        return post(`${API_PREFIX$3}/pause`, payload, { withCredentials: false });
+    },
+    /**
+     * Update token metadata
+     * @param payload Token metadata request payload
+     * @returns Promise with transaction hash response
+     */
+    updateMetadata: (payload) => {
+        return post(`${API_PREFIX$3}/update_metadata`, payload, { withCredentials: false });
+    }
+};const API_PREFIX$2 = `/${API_VERSION}/transactions`;
+/**
+ * Transactions API methods
+ */
+const transactionsApi = {
+    /**
+     * Get transaction by hash
+     * @param hash Hash of the transaction to lookup
+     * @returns Promise with transaction response
+     */
+    getByHash: (hash) => {
+        return get(`${API_PREFIX$2}/by_hash?hash=${hash}`, { withCredentials: false });
+    },
+    /**
+     * Get transaction receipt by hash
+     * @param hash Hash of the transaction to lookup receipt for
+     * @returns Promise with transaction receipt response
+     */
+    getReceiptByHash: (hash) => {
+        return get(`${API_PREFIX$2}/receipt/by_hash?hash=${hash}`, { withCredentials: false });
+    },
+    /**
+     * Estimate transaction fee
+     * @param from Address of the transaction author
+     * @param value Value of the transaction
+     * @param token Optional token address
+     * @returns Promise with fee estimate response
+     */
+    estimateFee: (from, value, token) => {
+        let url = `${API_PREFIX$2}/estimate_fee?from=${from}&value=${value}`;
+        if (token) {
+            url += `&token=${token}`;
+        }
+        return get(url, { withCredentials: false });
+    },
+    /**
+     * Submit payment transaction
+     * @param payload Payment transaction payload
+     * @returns Promise with transaction hash response
+     */
+    payment: (payload) => {
+        return post(`${API_PREFIX$2}/payment`, payload, { withCredentials: false });
+    }
+};const API_PREFIX$1 = `/${API_VERSION}/chains`;
+/**
+ * Checkpoint API methods
+ */
+const chainApi = {
+    /**
+     * Get the current chain id
+     * @returns Promise with chain id response
+     */
+    getChainId: () => {
+        return get(`${API_PREFIX$1}/chain_id`, { withCredentials: false });
+    },
+};const API_PREFIX = `/${API_VERSION}/states`;
+/**
+ * State API methods
+ */
+const stateApi = {
+    /**
+     * Get latest epoch checkpoint
+     * @returns Promise with latest epoch checkpoint response
+     */
+    getLatestEpochCheckpoint: () => {
+        return get(`${API_PREFIX}/latest_epoch_checkpoint`, { withCredentials: false });
+    }
+};// Authority types
+var AuthorityType;
+(function (AuthorityType) {
+    AuthorityType["MasterMint"] = "MasterMint";
+    AuthorityType["MintBurnTokens"] = "MintBurnTokens";
+    AuthorityType["Pause"] = "Pause";
+    AuthorityType["ManageList"] = "ManageList";
+    AuthorityType["UpdateMetadata"] = "UpdateMetadata";
+})(AuthorityType || (AuthorityType = {}));
+var AuthorityAction;
+(function (AuthorityAction) {
+    AuthorityAction["Grant"] = "Grant";
+    AuthorityAction["Revoke"] = "Revoke";
+})(AuthorityAction || (AuthorityAction = {}));
+var ManageListAction;
+(function (ManageListAction) {
+    ManageListAction["Add"] = "Add";
+    ManageListAction["Remove"] = "Remove";
+})(ManageListAction || (ManageListAction = {}));
+var PauseAction;
+(function (PauseAction) {
+    PauseAction["Pause"] = "Pause";
+    PauseAction["Unpause"] = "Unpause";
+})(PauseAction || (PauseAction = {}));/**
+ * API client for 1money network
+ * @param options Configuration options
+ * @param options.network Network to use (testnet, mainnet, local)
+ * @param options.timeout Request timeout in milliseconds
+ * @param options.chainId Custom chain ID (overrides the default for the selected network)
+ */
+function api(options) {
+    const network = options?.network || 'mainnet';
+    let baseURL = MAINNET_API_URL;
+    // Set the base URL based on the network
+    switch (network) {
+        case 'mainnet':
+            baseURL = MAINNET_API_URL;
+            break;
+        case 'testnet':
+            baseURL = TESTNET_API_URL;
+            break;
+        case 'local':
+            baseURL = LOCAL_API_URL;
+            break;
+    }
+    // Initialize API configuration
+    setInitConfig({
+        baseURL,
+        // Treat status code 200 as success
+        isSuccess: (_res, status) => status === 200,
+        timeout: options?.timeout || 10000
+    });
+    return {
+        /**
+         * Accounts API methods
+         */
+        accounts: accountsApi,
+        /**
+         * Checkpoint API methods
+         */
+        checkpoints: checkpointsApi,
+        /**
+         * Tokens API methods
+         */
+        tokens: tokensApi,
+        /**
+         * Transactions API methods
+         */
+        transactions: transactionsApi,
+        /**
+         * Chain API methods
+         */
+        chain: chainApi,
+        /**
+         * State API methods
+         */
+        state: stateApi,
+    };
+}export{AuthorityAction,AuthorityType,ManageListAction,PauseAction,api,api as default};

package/es/api/state/index.d.ts

@@ -0,0 +1,12 @@
+import type { EpochCheckpointResponse } from './types';
+/**
+ * State API methods
+ */
+export declare const stateApi: {
+    /**
+     * Get latest epoch checkpoint
+     * @returns Promise with latest epoch checkpoint response
+     */
+    getLatestEpochCheckpoint: () => import("../../client/index.js").PromiseWrapper<"custom", EpochCheckpointResponse, EpochCheckpointResponse, EpochCheckpointResponse, import("../../client/index.js").ParsedError<string>, import("../../client/index.js").ParsedError<string> | EpochCheckpointResponse, import("../../client/index.js").ParsedError<"timeout">, ""> & Promise<EpochCheckpointResponse>;
+};
+export default stateApi;

package/es/api/state/types.d.ts

@@ -0,0 +1,7 @@
+import type { B256Schema } from '../types';
+export interface EpochCheckpointResponse {
+    epoch: number;
+    checkpoint: number;
+    checkpoint_hash: B256Schema;
+    checkpoint_parent_hash: B256Schema;
+}

package/es/api/tokens/index.d.ts

@@ -0,0 +1,62 @@
+import type { Hash, HashWithToken } from '../../api/types';
+import type { MintInfo, TokenManageListPayload, TokenBurnPayload, TokenAuthorityPayload, TokenIssuePayload, TokenMintPayload, TokenPausePayload, TokenMetadataPayload } from './types';
+/**
+ * Tokens API methods
+ */
+export declare const tokensApi: {
+    /**
+     * Get token metadata
+     * @param token Token address to lookup metadata for
+     * @returns Promise with token metadata response
+     */
+    getTokenMetadata: (token: string) => import("../../client/index.js").PromiseWrapper<"custom", MintInfo, MintInfo, MintInfo, import("../../client/index.js").ParsedError<string>, import("../../client/index.js").ParsedError<string> | MintInfo, import("../../client/index.js").ParsedError<"timeout">, ""> & Promise<MintInfo>;
+    /**
+     * Manage token blacklist
+     * @param payload Token blacklist request payload
+     * @returns Promise with transaction hash response
+     */
+    manageBlacklist: (payload: TokenManageListPayload) => import("../../client/index.js").PromiseWrapper<"custom", Hash, Hash, Hash, import("../../client/index.js").ParsedError<string>, import("../../client/index.js").ParsedError<string> | Hash, import("../../client/index.js").ParsedError<"timeout">, ""> & Promise<Hash>;
+    /**
+     * Manage token whitelist
+     * @param payload Token whitelist request payload
+     * @returns Promise with transaction hash response
+     */
+    manageWhitelist: (payload: TokenManageListPayload) => import("../../client/index.js").PromiseWrapper<"custom", Hash, Hash, Hash, import("../../client/index.js").ParsedError<string>, import("../../client/index.js").ParsedError<string> | Hash, import("../../client/index.js").ParsedError<"timeout">, ""> & Promise<Hash>;
+    /**
+     * Burn tokens
+     * @param payload Token burn request payload
+     * @returns Promise with transaction hash response
+     */
+    burnToken: (payload: TokenBurnPayload) => import("../../client/index.js").PromiseWrapper<"custom", Hash, Hash, Hash, import("../../client/index.js").ParsedError<string>, import("../../client/index.js").ParsedError<string> | Hash, import("../../client/index.js").ParsedError<"timeout">, ""> & Promise<Hash>;
+    /**
+     * Grant or revoke token authority
+     * @param payload Token authority request payload
+     * @returns Promise with transaction hash response
+     */
+    grantAuthority: (payload: TokenAuthorityPayload) => import("../../client/index.js").PromiseWrapper<"custom", Hash, Hash, Hash, import("../../client/index.js").ParsedError<string>, import("../../client/index.js").ParsedError<string> | Hash, import("../../client/index.js").ParsedError<"timeout">, ""> & Promise<Hash>;
+    /**
+     * Issue new token
+     * @param payload Token issue request payload
+     * @returns Promise with transaction hash and token address response
+     */
+    issueToken: (payload: TokenIssuePayload) => import("../../client/index.js").PromiseWrapper<"custom", HashWithToken, HashWithToken, HashWithToken, import("../../client/index.js").ParsedError<string>, import("../../client/index.js").ParsedError<string> | HashWithToken, import("../../client/index.js").ParsedError<"timeout">, ""> & Promise<HashWithToken>;
+    /**
+     * Mint tokens
+     * @param payload Token mint request payload
+     * @returns Promise with transaction hash response
+     */
+    mintToken: (payload: TokenMintPayload) => import("../../client/index.js").PromiseWrapper<"custom", Hash, Hash, Hash, import("../../client/index.js").ParsedError<string>, import("../../client/index.js").ParsedError<string> | Hash, import("../../client/index.js").ParsedError<"timeout">, ""> & Promise<Hash>;
+    /**
+     * Pause or unpause token
+     * @param payload Token pause request payload
+     * @returns Promise with transaction hash response
+     */
+    pauseToken: (payload: TokenPausePayload) => import("../../client/index.js").PromiseWrapper<"custom", Hash, Hash, Hash, import("../../client/index.js").ParsedError<string>, import("../../client/index.js").ParsedError<string> | Hash, import("../../client/index.js").ParsedError<"timeout">, ""> & Promise<Hash>;
+    /**
+     * Update token metadata
+     * @param payload Token metadata request payload
+     * @returns Promise with transaction hash response
+     */
+    updateMetadata: (payload: TokenMetadataPayload) => import("../../client/index.js").PromiseWrapper<"custom", Hash, Hash, Hash, import("../../client/index.js").ParsedError<string>, import("../../client/index.js").ParsedError<string> | Hash, import("../../client/index.js").ParsedError<"timeout">, ""> & Promise<Hash>;
+};
+export default tokensApi;