@locuschain/lib 0.0.7 → 0.0.9

package/dist/errors/index.amd.js

@@ -0,0 +1,22 @@
+define(['exports'], (function (exports) { 'use strict';
+
+    exports.RpcErrorCode = void 0;
+    (function (RpcErrorCode) {
+        RpcErrorCode["ERROR"] = "LOCUSLIB_ERROR";
+        RpcErrorCode["RUNTIME_ERROR"] = "LOCUSLIB_RUNTIME_ERROR";
+        RpcErrorCode["NET_ERROR"] = "LOCUSLIB_NET_ERROR";
+        RpcErrorCode["TIMEOUT"] = "LOCUSLIB_TIMEOUT";
+        RpcErrorCode["ABORTED"] = "LOCUSLIB_ABORTED";
+        RpcErrorCode["REQUIRE_ACCOUNT"] = "LOCUSLIB_REQUIRE_ACCOUNT";
+    })(exports.RpcErrorCode || (exports.RpcErrorCode = {}));
+    class RpcError extends Error {
+        constructor(code, message) {
+            super(message);
+            this.code = code;
+            this.message = message;
+        }
+    }
+
+    exports.RpcError = RpcError;
+
+}));

package/dist/errors/index.cjs.js

@@ -0,0 +1,20 @@
+'use strict';
+
+exports.RpcErrorCode = void 0;
+(function (RpcErrorCode) {
+    RpcErrorCode["ERROR"] = "LOCUSLIB_ERROR";
+    RpcErrorCode["RUNTIME_ERROR"] = "LOCUSLIB_RUNTIME_ERROR";
+    RpcErrorCode["NET_ERROR"] = "LOCUSLIB_NET_ERROR";
+    RpcErrorCode["TIMEOUT"] = "LOCUSLIB_TIMEOUT";
+    RpcErrorCode["ABORTED"] = "LOCUSLIB_ABORTED";
+    RpcErrorCode["REQUIRE_ACCOUNT"] = "LOCUSLIB_REQUIRE_ACCOUNT";
+})(exports.RpcErrorCode || (exports.RpcErrorCode = {}));
+class RpcError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.message = message;
+    }
+}
+
+exports.RpcError = RpcError;

package/dist/errors/index.d.mts

@@ -0,0 +1 @@
+export * from './rpc-error.mts';

package/dist/errors/index.esm.js

@@ -0,0 +1,18 @@
+var RpcErrorCode;
+(function (RpcErrorCode) {
+    RpcErrorCode["ERROR"] = "LOCUSLIB_ERROR";
+    RpcErrorCode["RUNTIME_ERROR"] = "LOCUSLIB_RUNTIME_ERROR";
+    RpcErrorCode["NET_ERROR"] = "LOCUSLIB_NET_ERROR";
+    RpcErrorCode["TIMEOUT"] = "LOCUSLIB_TIMEOUT";
+    RpcErrorCode["ABORTED"] = "LOCUSLIB_ABORTED";
+    RpcErrorCode["REQUIRE_ACCOUNT"] = "LOCUSLIB_REQUIRE_ACCOUNT";
+})(RpcErrorCode || (RpcErrorCode = {}));
+class RpcError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.message = message;
+    }
+}
+
+export { RpcError, RpcErrorCode };

package/dist/errors/rpc-error.d.mts

@@ -0,0 +1,13 @@
+export declare enum RpcErrorCode {
+    ERROR = "LOCUSLIB_ERROR",
+    RUNTIME_ERROR = "LOCUSLIB_RUNTIME_ERROR",
+    NET_ERROR = "LOCUSLIB_NET_ERROR",
+    TIMEOUT = "LOCUSLIB_TIMEOUT",
+    ABORTED = "LOCUSLIB_ABORTED",
+    REQUIRE_ACCOUNT = "LOCUSLIB_REQUIRE_ACCOUNT"
+}
+export declare class RpcError extends Error {
+    code: string;
+    message: string;
+    constructor(code: string, message: string);
+}

package/dist/support/index.amd.js

@@ -1,4 +1,4 @@
-define(['exports', '../index-BkQ38g4T', '../rpc-error-CIW1Ier-', 'lodash', '../address-class-Dp7aNQb2'], (function (exports, utils$2, rpcError, _, addressClass) { 'use strict';
+define(['exports', '../index-BkQ38g4T', '../errors/index.amd', 'lodash', '../address-class-Dp7aNQb2'], (function (exports, utils$2, errors, _, addressClass) { 'use strict';
 
   function _interopNamespaceDefault(e) {
     var n = Object.create(null);

package/dist/support/index.cjs.js

@@ -1,7 +1,7 @@
 'use strict';
 
 var utils$2 = require('../index-BJsuMvb_.js');
-require('../rpc-error-DxFStPj8.js');
+require('../errors/index.cjs.js');
 var _ = require('lodash');
 require('../address-class-Cjy48Uqk.js');
 

package/dist/support/index.esm.js

@@ -1,5 +1,5 @@
 import { c as convertHexToData, a as convertDataToHex, b as convertHexToAddress, d as convertAddressToHex, _ as __awaiter } from '../index-CB-t6xed.js';
-import '../rpc-error-8sxpHnEq.js';
+import '../errors/index.esm.js';
 import * as _ from 'lodash';
 import '../address-class-CHAZYhdZ.js';
 

package/dist/web3/index.amd.js

@@ -1,4 +1,4 @@
-define(['exports', '../index-BkQ38g4T', '../tx-type-BeeK7Ci3', '../rpc-error-CIW1Ier-', '../address-class-Dp7aNQb2', 'lodash'], (function (exports, utils, txType, rpcError, addressClass, _) { 'use strict';
+define(['exports', '../index-BkQ38g4T', '../tx-type-BeeK7Ci3', '../errors/index.amd', '../address-class-Dp7aNQb2', 'lodash'], (function (exports, utils, txType, errors, addressClass, _) { 'use strict';
 
     class Account {
         constructor({ address, nsk }) {
@@ -84,7 +84,6 @@ define(['exports', '../index-BkQ38g4T', '../tx-type-BeeK7Ci3', '../rpc-error-CIW
         constructor() {
             super(...arguments);
             this.id = 0;
-            this.canceledLastCallIndex = -1;
         }
         setAccountProvider(accountProvider) {
             this.accountProvider = accountProvider;
@@ -97,43 +96,64 @@ define(['exports', '../index-BkQ38g4T', '../tx-type-BeeK7Ci3', '../rpc-error-CIW
             this.rpcOptions = Object.assign(Object.assign({}, this.rpcOptions), { abortController: new AbortController() });
             return true;
         }
+        getSignal(rpcOption) {
+            var _a, _b;
+            const controller = (_a = rpcOption === null || rpcOption === void 0 ? void 0 : rpcOption.abortController) !== null && _a !== void 0 ? _a : (_b = this.rpcOptions) === null || _b === void 0 ? void 0 : _b.abortController;
+            const signals = [AbortSignal.timeout(30000)];
+            if (controller) {
+                signals.push(controller.signal);
+            }
+            return AbortSignal.any(signals);
+        }
         request(cmd, params, rpcOption) {
             return utils.__awaiter(this, void 0, void 0, function* () {
-                const callRpcOptions = Object.assign(Object.assign({}, this.rpcOptions), rpcOption);
-                const signal = AbortSignal.any(callRpcOptions.abortController ? [callRpcOptions.abortController.signal, AbortSignal.timeout(30000)] : [AbortSignal.timeout(30000)]);
-                if (signal.aborted) {
-                    throw new rpcError.RpcError(rpcError.RpcErrorCode.ABORTED, `rpc aborted by user`);
+                if (this.getSignal().aborted) {
+                    throw new errors.RpcError(errors.RpcErrorCode.ABORTED, `rpc aborted by user`);
+                }
+                if (this.id === Number.MAX_SAFE_INTEGER) {
+                    this.id = 0;
                 }
-                const id = ++this.id;
                 const data = {
-                    id,
+                    id: ++this.id,
                     jsonrpc: '2.0',
                     method: cmd,
                     params
                 };
                 try {
-                    const rpc1Result = yield this.callRpc(data, { signal, headersInit: callRpcOptions.headersInit });
-                    if (!utils.TX_CREATION_RPC_LIST.includes(cmd))
+                    const options = Object.assign(Object.assign({}, this.rpcOptions), rpcOption);
+                    const callRpc1Signal = this.getSignal();
+                    const rpc1Result = yield this.callRpc(data, { signal: callRpc1Signal, headersInit: options.headersInit });
+                    if (callRpc1Signal.aborted) {
+                        throw new errors.RpcError(errors.RpcErrorCode.ABORTED, `rpc aborted by user`);
+                    }
+                    if (!utils.TX_CREATION_RPC_LIST.includes(cmd)) {
                         return rpc1Result;
+                    }
                     if (!this.accountProvider)
-                        throw new rpcError.RpcError(rpcError.RpcErrorCode.REQUIRE_ACCOUNT, 'No accounts found. Please add an account before tx creation.');
+                        throw new errors.RpcError(errors.RpcErrorCode.REQUIRE_ACCOUNT, 'No accounts found. Please add an account before tx creation.');
                     // rpc1Result가 T(제네릭)이므로 'in' 연산자 사용을 위해 any로 캐스팅하여 체크합니다.
                     const txResult = rpc1Result;
                     if (!txResult || typeof txResult !== 'object' || !('hash' in txResult) || !('tx' in txResult)) {
                         // console.warn('rpcResul1>>', txResult)
-                        throw new rpcError.RpcError(rpcError.RpcErrorCode.REQUIRE_ACCOUNT, 'Invalid transaction creation result.');
+                        throw new errors.RpcError(errors.RpcErrorCode.REQUIRE_ACCOUNT, 'Invalid transaction creation result.');
                     }
                     // console.debug('rpcResul1>>', txResult)
-                    const additionalParams = yield this.accountProvider.signTx(txResult, params, rpcOption === null || rpcOption === void 0 ? void 0 : rpcOption.address);
-                    const newData = Object.assign(Object.assign({}, data), { params: params.map((p, idx) => (idx === 0 ? Object.assign(Object.assign({}, p), additionalParams) : p)) });
-                    const rpcResult2 = yield this.callRpc(newData, callRpcOptions);
+                    const additionalParams = yield this.accountProvider.signTx(txResult, params, options.address);
+                    const newData = Object.assign(Object.assign({}, data), { id: ++this.id, params: params.map((p, idx) => (idx === 0 ? Object.assign(Object.assign({}, p), additionalParams) : p)) });
+                    const callRpc2Signal = this.getSignal();
+                    const rpcResul2 = yield this.callRpc(newData, { signal: callRpc2Signal, headersInit: options.headersInit });
+                    if (callRpc2Signal.aborted) {
+                        throw new errors.RpcError(errors.RpcErrorCode.ABORTED, `rpc aborted by user`);
+                    }
+                    return rpcResul2;
                     // console.debug('rpcResul2', rpcResult2)
-                    return rpcResult2;
                 }
                 catch (err) {
+                    if (err.code === errors.RpcErrorCode.ABORTED)
+                        throw err;
+                    throw new errors.RpcError(errors.RpcErrorCode.RUNTIME_ERROR, err.message);
                     // console.trace(err)
                     // console.log(err.stack);
-                    throw new rpcError.RpcError(rpcError.RpcErrorCode.RUNTIME_ERROR, err.message);
                 }
             });
         }
@@ -143,7 +163,6 @@ define(['exports', '../index-BkQ38g4T', '../tx-type-BeeK7Ci3', '../rpc-error-CIW
         constructor(rpcUrl, rpcOptions) {
             super();
             this.id = 0;
-            this.canceledLastCallIndex = -1;
             this.rpcUrl = rpcUrl;
             this.rpcOptions = Object.assign({ abortController: new AbortController() }, rpcOptions);
         }
@@ -152,7 +171,7 @@ define(['exports', '../index-BkQ38g4T', '../tx-type-BeeK7Ci3', '../rpc-error-CIW
                 // console.debug('params', data)
                 var _a;
                 if ((_a = options === null || options === void 0 ? void 0 : options.signal) === null || _a === void 0 ? void 0 : _a.aborted) {
-                    throw new rpcError.RpcError(rpcError.RpcErrorCode.ABORTED, `rpc aborted by user`);
+                    throw new errors.RpcError(errors.RpcErrorCode.ABORTED, `rpc aborted by user`);
                 }
                 try {
                     const res = yield fetch(this.rpcUrl, {
@@ -162,16 +181,16 @@ define(['exports', '../index-BkQ38g4T', '../tx-type-BeeK7Ci3', '../rpc-error-CIW
                         signal: options === null || options === void 0 ? void 0 : options.signal
                     });
                     if (!res.ok)
-                        throw new rpcError.RpcError(rpcError.RpcErrorCode.NET_ERROR, `node response http status : ${res.status}`);
+                        throw new errors.RpcError(errors.RpcErrorCode.NET_ERROR, `node response http status : ${res.status}`);
                     const response = yield res.json();
                     if (response.error) {
                         const { code, message } = response.error;
-                        throw new rpcError.RpcError(message === 'timeout error' ? rpcError.RpcErrorCode.TIMEOUT : code, message);
+                        throw new errors.RpcError(message === 'timeout error' ? errors.RpcErrorCode.TIMEOUT : code, message);
                     }
                     return response.result;
                 }
                 catch (err) {
-                    throw new rpcError.RpcError(err.name === 'TimeoutError' ? rpcError.RpcErrorCode.TIMEOUT : rpcError.RpcErrorCode.RUNTIME_ERROR, err.message);
+                    throw new errors.RpcError(err.name === 'TimeoutError' ? errors.RpcErrorCode.TIMEOUT : errors.RpcErrorCode.RUNTIME_ERROR, err.message);
                 }
             });
         }

package/dist/web3/index.cjs.js

@@ -2,7 +2,7 @@
 
 var utils = require('../index-BJsuMvb_.js');
 var txType = require('../tx-type-jR5Owltc.js');
-var rpcError = require('../rpc-error-DxFStPj8.js');
+var errors = require('../errors/index.cjs.js');
 require('../address-class-Cjy48Uqk.js');
 require('lodash');
 
@@ -90,7 +90,6 @@ class RpcProvider extends utils.Rpc {
     constructor() {
         super(...arguments);
         this.id = 0;
-        this.canceledLastCallIndex = -1;
     }
     setAccountProvider(accountProvider) {
         this.accountProvider = accountProvider;
@@ -103,43 +102,64 @@ class RpcProvider extends utils.Rpc {
         this.rpcOptions = Object.assign(Object.assign({}, this.rpcOptions), { abortController: new AbortController() });
         return true;
     }
+    getSignal(rpcOption) {
+        var _a, _b;
+        const controller = (_a = rpcOption === null || rpcOption === void 0 ? void 0 : rpcOption.abortController) !== null && _a !== void 0 ? _a : (_b = this.rpcOptions) === null || _b === void 0 ? void 0 : _b.abortController;
+        const signals = [AbortSignal.timeout(30000)];
+        if (controller) {
+            signals.push(controller.signal);
+        }
+        return AbortSignal.any(signals);
+    }
     request(cmd, params, rpcOption) {
         return utils.__awaiter(this, void 0, void 0, function* () {
-            const callRpcOptions = Object.assign(Object.assign({}, this.rpcOptions), rpcOption);
-            const signal = AbortSignal.any(callRpcOptions.abortController ? [callRpcOptions.abortController.signal, AbortSignal.timeout(30000)] : [AbortSignal.timeout(30000)]);
-            if (signal.aborted) {
-                throw new rpcError.RpcError(rpcError.RpcErrorCode.ABORTED, `rpc aborted by user`);
+            if (this.getSignal().aborted) {
+                throw new errors.RpcError(errors.RpcErrorCode.ABORTED, `rpc aborted by user`);
+            }
+            if (this.id === Number.MAX_SAFE_INTEGER) {
+                this.id = 0;
             }
-            const id = ++this.id;
             const data = {
-                id,
+                id: ++this.id,
                 jsonrpc: '2.0',
                 method: cmd,
                 params
             };
             try {
-                const rpc1Result = yield this.callRpc(data, { signal, headersInit: callRpcOptions.headersInit });
-                if (!utils.TX_CREATION_RPC_LIST.includes(cmd))
+                const options = Object.assign(Object.assign({}, this.rpcOptions), rpcOption);
+                const callRpc1Signal = this.getSignal();
+                const rpc1Result = yield this.callRpc(data, { signal: callRpc1Signal, headersInit: options.headersInit });
+                if (callRpc1Signal.aborted) {
+                    throw new errors.RpcError(errors.RpcErrorCode.ABORTED, `rpc aborted by user`);
+                }
+                if (!utils.TX_CREATION_RPC_LIST.includes(cmd)) {
                     return rpc1Result;
+                }
                 if (!this.accountProvider)
-                    throw new rpcError.RpcError(rpcError.RpcErrorCode.REQUIRE_ACCOUNT, 'No accounts found. Please add an account before tx creation.');
+                    throw new errors.RpcError(errors.RpcErrorCode.REQUIRE_ACCOUNT, 'No accounts found. Please add an account before tx creation.');
                 // rpc1Result가 T(제네릭)이므로 'in' 연산자 사용을 위해 any로 캐스팅하여 체크합니다.
                 const txResult = rpc1Result;
                 if (!txResult || typeof txResult !== 'object' || !('hash' in txResult) || !('tx' in txResult)) {
                     // console.warn('rpcResul1>>', txResult)
-                    throw new rpcError.RpcError(rpcError.RpcErrorCode.REQUIRE_ACCOUNT, 'Invalid transaction creation result.');
+                    throw new errors.RpcError(errors.RpcErrorCode.REQUIRE_ACCOUNT, 'Invalid transaction creation result.');
                 }
                 // console.debug('rpcResul1>>', txResult)
-                const additionalParams = yield this.accountProvider.signTx(txResult, params, rpcOption === null || rpcOption === void 0 ? void 0 : rpcOption.address);
-                const newData = Object.assign(Object.assign({}, data), { params: params.map((p, idx) => (idx === 0 ? Object.assign(Object.assign({}, p), additionalParams) : p)) });
-                const rpcResult2 = yield this.callRpc(newData, callRpcOptions);
+                const additionalParams = yield this.accountProvider.signTx(txResult, params, options.address);
+                const newData = Object.assign(Object.assign({}, data), { id: ++this.id, params: params.map((p, idx) => (idx === 0 ? Object.assign(Object.assign({}, p), additionalParams) : p)) });
+                const callRpc2Signal = this.getSignal();
+                const rpcResul2 = yield this.callRpc(newData, { signal: callRpc2Signal, headersInit: options.headersInit });
+                if (callRpc2Signal.aborted) {
+                    throw new errors.RpcError(errors.RpcErrorCode.ABORTED, `rpc aborted by user`);
+                }
+                return rpcResul2;
                 // console.debug('rpcResul2', rpcResult2)
-                return rpcResult2;
             }
             catch (err) {
+                if (err.code === errors.RpcErrorCode.ABORTED)
+                    throw err;
+                throw new errors.RpcError(errors.RpcErrorCode.RUNTIME_ERROR, err.message);
                 // console.trace(err)
                 // console.log(err.stack);
-                throw new rpcError.RpcError(rpcError.RpcErrorCode.RUNTIME_ERROR, err.message);
             }
         });
     }
@@ -149,7 +169,6 @@ class HttpRpcProvider extends RpcProvider {
     constructor(rpcUrl, rpcOptions) {
         super();
         this.id = 0;
-        this.canceledLastCallIndex = -1;
         this.rpcUrl = rpcUrl;
         this.rpcOptions = Object.assign({ abortController: new AbortController() }, rpcOptions);
     }
@@ -158,7 +177,7 @@ class HttpRpcProvider extends RpcProvider {
             // console.debug('params', data)
             var _a;
             if ((_a = options === null || options === void 0 ? void 0 : options.signal) === null || _a === void 0 ? void 0 : _a.aborted) {
-                throw new rpcError.RpcError(rpcError.RpcErrorCode.ABORTED, `rpc aborted by user`);
+                throw new errors.RpcError(errors.RpcErrorCode.ABORTED, `rpc aborted by user`);
             }
             try {
                 const res = yield fetch(this.rpcUrl, {
@@ -168,16 +187,16 @@ class HttpRpcProvider extends RpcProvider {
                     signal: options === null || options === void 0 ? void 0 : options.signal
                 });
                 if (!res.ok)
-                    throw new rpcError.RpcError(rpcError.RpcErrorCode.NET_ERROR, `node response http status : ${res.status}`);
+                    throw new errors.RpcError(errors.RpcErrorCode.NET_ERROR, `node response http status : ${res.status}`);
                 const response = yield res.json();
                 if (response.error) {
                     const { code, message } = response.error;
-                    throw new rpcError.RpcError(message === 'timeout error' ? rpcError.RpcErrorCode.TIMEOUT : code, message);
+                    throw new errors.RpcError(message === 'timeout error' ? errors.RpcErrorCode.TIMEOUT : code, message);
                 }
                 return response.result;
             }
             catch (err) {
-                throw new rpcError.RpcError(err.name === 'TimeoutError' ? rpcError.RpcErrorCode.TIMEOUT : rpcError.RpcErrorCode.RUNTIME_ERROR, err.message);
+                throw new errors.RpcError(err.name === 'TimeoutError' ? errors.RpcErrorCode.TIMEOUT : errors.RpcErrorCode.RUNTIME_ERROR, err.message);
             }
         });
     }

package/dist/web3/index.d.cts

@@ -1,7 +1,7 @@
-import { AccountProvider } from "./providers/account-provider.mts";
-import { HttpRpcProvider } from "./providers/http-rpc-provider.mts";
-import { RpcProvider } from "./providers/rpc-provider.mts";
-import { RpcOptions } from "./types/index.mts";
+import { AccountProvider } from './providers/account-provider.mts';
+import { HttpRpcProvider } from './providers/http-rpc-provider.mts';
+import { RpcProvider } from './providers/rpc-provider.mts';
+import { RpcOptions } from './types/index.mts';
 export declare class Web3 {
     private accountProvider?;
     private rpcProvider?;

package/dist/web3/index.d.mts

@@ -1,7 +1,7 @@
-import { AccountProvider } from "./providers/account-provider.mts";
-import { HttpRpcProvider } from "./providers/http-rpc-provider.mts";
-import { RpcProvider } from "./providers/rpc-provider.mts";
-import { RpcOptions } from "./types/index.mts";
+import { AccountProvider } from './providers/account-provider.mts';
+import { HttpRpcProvider } from './providers/http-rpc-provider.mts';
+import { RpcProvider } from './providers/rpc-provider.mts';
+import { RpcOptions } from './types/index.mts';
 export declare class Web3 {
     private accountProvider?;
     private rpcProvider?;

package/dist/web3/index.esm.js

@@ -1,6 +1,6 @@
 import { s as sign, _ as __awaiter, v as verifyTxParams, R as Rpc, T as TX_CREATION_RPC_LIST } from '../index-CB-t6xed.js';
 import { T as TxType } from '../tx-type-nyLU5xv5.js';
-import { R as RpcError, a as RpcErrorCode } from '../rpc-error-8sxpHnEq.js';
+import { RpcError, RpcErrorCode } from '../errors/index.esm.js';
 import '../address-class-CHAZYhdZ.js';
 import 'lodash';
 
@@ -88,7 +88,6 @@ class RpcProvider extends Rpc {
     constructor() {
         super(...arguments);
         this.id = 0;
-        this.canceledLastCallIndex = -1;
     }
     setAccountProvider(accountProvider) {
         this.accountProvider = accountProvider;
@@ -101,24 +100,39 @@ class RpcProvider extends Rpc {
         this.rpcOptions = Object.assign(Object.assign({}, this.rpcOptions), { abortController: new AbortController() });
         return true;
     }
+    getSignal(rpcOption) {
+        var _a, _b;
+        const controller = (_a = rpcOption === null || rpcOption === void 0 ? void 0 : rpcOption.abortController) !== null && _a !== void 0 ? _a : (_b = this.rpcOptions) === null || _b === void 0 ? void 0 : _b.abortController;
+        const signals = [AbortSignal.timeout(30000)];
+        if (controller) {
+            signals.push(controller.signal);
+        }
+        return AbortSignal.any(signals);
+    }
     request(cmd, params, rpcOption) {
         return __awaiter(this, void 0, void 0, function* () {
-            const callRpcOptions = Object.assign(Object.assign({}, this.rpcOptions), rpcOption);
-            const signal = AbortSignal.any(callRpcOptions.abortController ? [callRpcOptions.abortController.signal, AbortSignal.timeout(30000)] : [AbortSignal.timeout(30000)]);
-            if (signal.aborted) {
+            if (this.getSignal().aborted) {
                 throw new RpcError(RpcErrorCode.ABORTED, `rpc aborted by user`);
             }
-            const id = ++this.id;
+            if (this.id === Number.MAX_SAFE_INTEGER) {
+                this.id = 0;
+            }
             const data = {
-                id,
+                id: ++this.id,
                 jsonrpc: '2.0',
                 method: cmd,
                 params
             };
             try {
-                const rpc1Result = yield this.callRpc(data, { signal, headersInit: callRpcOptions.headersInit });
-                if (!TX_CREATION_RPC_LIST.includes(cmd))
+                const options = Object.assign(Object.assign({}, this.rpcOptions), rpcOption);
+                const callRpc1Signal = this.getSignal();
+                const rpc1Result = yield this.callRpc(data, { signal: callRpc1Signal, headersInit: options.headersInit });
+                if (callRpc1Signal.aborted) {
+                    throw new RpcError(RpcErrorCode.ABORTED, `rpc aborted by user`);
+                }
+                if (!TX_CREATION_RPC_LIST.includes(cmd)) {
                     return rpc1Result;
+                }
                 if (!this.accountProvider)
                     throw new RpcError(RpcErrorCode.REQUIRE_ACCOUNT, 'No accounts found. Please add an account before tx creation.');
                 // rpc1Result가 T(제네릭)이므로 'in' 연산자 사용을 위해 any로 캐스팅하여 체크합니다.
@@ -128,16 +142,22 @@ class RpcProvider extends Rpc {
                     throw new RpcError(RpcErrorCode.REQUIRE_ACCOUNT, 'Invalid transaction creation result.');
                 }
                 // console.debug('rpcResul1>>', txResult)
-                const additionalParams = yield this.accountProvider.signTx(txResult, params, rpcOption === null || rpcOption === void 0 ? void 0 : rpcOption.address);
-                const newData = Object.assign(Object.assign({}, data), { params: params.map((p, idx) => (idx === 0 ? Object.assign(Object.assign({}, p), additionalParams) : p)) });
-                const rpcResult2 = yield this.callRpc(newData, callRpcOptions);
+                const additionalParams = yield this.accountProvider.signTx(txResult, params, options.address);
+                const newData = Object.assign(Object.assign({}, data), { id: ++this.id, params: params.map((p, idx) => (idx === 0 ? Object.assign(Object.assign({}, p), additionalParams) : p)) });
+                const callRpc2Signal = this.getSignal();
+                const rpcResul2 = yield this.callRpc(newData, { signal: callRpc2Signal, headersInit: options.headersInit });
+                if (callRpc2Signal.aborted) {
+                    throw new RpcError(RpcErrorCode.ABORTED, `rpc aborted by user`);
+                }
+                return rpcResul2;
                 // console.debug('rpcResul2', rpcResult2)
-                return rpcResult2;
             }
             catch (err) {
+                if (err.code === RpcErrorCode.ABORTED)
+                    throw err;
+                throw new RpcError(RpcErrorCode.RUNTIME_ERROR, err.message);
                 // console.trace(err)
                 // console.log(err.stack);
-                throw new RpcError(RpcErrorCode.RUNTIME_ERROR, err.message);
             }
         });
     }
@@ -147,7 +167,6 @@ class HttpRpcProvider extends RpcProvider {
     constructor(rpcUrl, rpcOptions) {
         super();
         this.id = 0;
-        this.canceledLastCallIndex = -1;
         this.rpcUrl = rpcUrl;
         this.rpcOptions = Object.assign({ abortController: new AbortController() }, rpcOptions);
     }

package/dist/web3/providers/http-rpc-provider.d.mts

@@ -1,10 +1,9 @@
-import { CallRpcOptions, RpcOptions } from "../types/index.mts";
-import { RpcProvider } from "./rpc-provider.mts";
+import { CallRpcOptions, RpcOptions } from '../types/index.mts';
+import { RpcProvider } from './rpc-provider.mts';
 export declare class HttpRpcProvider extends RpcProvider {
     id: number;
     rpcUrl: string;
     rpcOptions?: RpcOptions;
-    canceledLastCallIndex: number;
     constructor(rpcUrl: string, rpcOptions?: RpcOptions);
     callRpc<T>(data: any, options?: CallRpcOptions): Promise<T>;
 }

package/dist/web3/providers/rpc-provider.d.mts

@@ -1,15 +1,15 @@
-import { RpcApiSpec } from "../../autogen/rpc-api-spec.mts";
-import { Rpc } from "../../autogen/rpc.mts";
-import { CallRpcOptions, RpcOptions, Web3APIMethod, Web3APIParams } from "../types/index.mts";
-import { AccountProvider } from "./account-provider.mts";
+import { RpcApiSpec } from '../../autogen/rpc-api-spec.mts';
+import { Rpc } from '../../autogen/rpc.mts';
+import { CallRpcOptions, RpcOptions, Web3APIMethod, Web3APIParams } from '../types/index.mts';
+import { AccountProvider } from './account-provider.mts';
 export declare abstract class RpcProvider extends Rpc {
     id: number;
     rpcOptions?: RpcOptions | undefined;
-    canceledLastCallIndex: number;
     accountProvider?: AccountProvider;
     abstract callRpc<T>(data: any, options?: CallRpcOptions): Promise<T>;
     abstract get rpcUrl(): string;
     setAccountProvider(accountProvider: AccountProvider): void;
     abort(): boolean;
+    private getSignal;
     request<T, M extends Web3APIMethod<RpcApiSpec> = any>(cmd: M, params: Web3APIParams<RpcApiSpec, M>, rpcOption?: RpcOptions): Promise<T>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@locuschain/lib",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "author": "bloomtechnology",
   "license": "MIT",
   "description": "",
@@ -52,6 +52,14 @@
       },
       "import": "./dist/support/index.esm.js",
       "require": "./dist/support/index.cjs.js"
+    },
+    "./errors": {
+      "types": {
+        "require": "./dist/errors/index.d.cts",
+        "import": "./dist/errors/index.d.mts"
+      },
+      "import": "./dist/errors/index.esm.js",
+      "require": "./dist/errors/index.cjs.js"
     }
   },
   "files": [

package/dist/rpc-error-8sxpHnEq.js

@@ -1,18 +0,0 @@
-var RpcErrorCode;
-(function (RpcErrorCode) {
-    RpcErrorCode[RpcErrorCode["ERROR"] = -32000] = "ERROR";
-    RpcErrorCode[RpcErrorCode["RUNTIME_ERROR"] = -31999] = "RUNTIME_ERROR";
-    RpcErrorCode[RpcErrorCode["NET_ERROR"] = -31998] = "NET_ERROR";
-    RpcErrorCode[RpcErrorCode["TIMEOUT"] = -31997] = "TIMEOUT";
-    RpcErrorCode[RpcErrorCode["ABORTED"] = -31996] = "ABORTED";
-    RpcErrorCode[RpcErrorCode["REQUIRE_ACCOUNT"] = -31995] = "REQUIRE_ACCOUNT";
-})(RpcErrorCode || (RpcErrorCode = {}));
-class RpcError extends Error {
-    constructor(code, message) {
-        super(message);
-        this.code = code;
-        this.message = message;
-    }
-}
-
-export { RpcError as R, RpcErrorCode as a };

package/dist/rpc-error-CIW1Ier-.js

@@ -1,22 +0,0 @@
-define(['exports'], (function (exports) { 'use strict';
-
-    exports.RpcErrorCode = void 0;
-    (function (RpcErrorCode) {
-        RpcErrorCode[RpcErrorCode["ERROR"] = -32000] = "ERROR";
-        RpcErrorCode[RpcErrorCode["RUNTIME_ERROR"] = -31999] = "RUNTIME_ERROR";
-        RpcErrorCode[RpcErrorCode["NET_ERROR"] = -31998] = "NET_ERROR";
-        RpcErrorCode[RpcErrorCode["TIMEOUT"] = -31997] = "TIMEOUT";
-        RpcErrorCode[RpcErrorCode["ABORTED"] = -31996] = "ABORTED";
-        RpcErrorCode[RpcErrorCode["REQUIRE_ACCOUNT"] = -31995] = "REQUIRE_ACCOUNT";
-    })(exports.RpcErrorCode || (exports.RpcErrorCode = {}));
-    class RpcError extends Error {
-        constructor(code, message) {
-            super(message);
-            this.code = code;
-            this.message = message;
-        }
-    }
-
-    exports.RpcError = RpcError;
-
-}));

package/dist/rpc-error-DxFStPj8.js

@@ -1,20 +0,0 @@
-'use strict';
-
-exports.RpcErrorCode = void 0;
-(function (RpcErrorCode) {
-    RpcErrorCode[RpcErrorCode["ERROR"] = -32000] = "ERROR";
-    RpcErrorCode[RpcErrorCode["RUNTIME_ERROR"] = -31999] = "RUNTIME_ERROR";
-    RpcErrorCode[RpcErrorCode["NET_ERROR"] = -31998] = "NET_ERROR";
-    RpcErrorCode[RpcErrorCode["TIMEOUT"] = -31997] = "TIMEOUT";
-    RpcErrorCode[RpcErrorCode["ABORTED"] = -31996] = "ABORTED";
-    RpcErrorCode[RpcErrorCode["REQUIRE_ACCOUNT"] = -31995] = "REQUIRE_ACCOUNT";
-})(exports.RpcErrorCode || (exports.RpcErrorCode = {}));
-class RpcError extends Error {
-    constructor(code, message) {
-        super(message);
-        this.code = code;
-        this.message = message;
-    }
-}
-
-exports.RpcError = RpcError;

package/dist/web3/rpc-error.d.mts

@@ -1,13 +0,0 @@
-export declare enum RpcErrorCode {
-    ERROR = -32000,
-    RUNTIME_ERROR = -31999,
-    NET_ERROR = -31998,
-    TIMEOUT = -31997,
-    ABORTED = -31996,
-    REQUIRE_ACCOUNT = -31995
-}
-export declare class RpcError extends Error {
-    code: number;
-    message: string;
-    constructor(code: number, message: string);
-}