@locuschain/lib 0.1.31 → 0.1.33

package/dist/clients/createLocusPublicClient.d.mts

@@ -0,0 +1,100 @@
+import type { TransportConfig } from '../transports/types.mjs';
+export type CreateLocusPublicClientArgs = {
+    /** JSON-RPC 엔드포인트 URL. */
+    rpcUrl: string;
+    /**
+     * 선택적 HTTP 트랜스포트 설정. 로드밸런서 힌트 (예: Locus `locuslb` 헤더)
+     * 같은 용도로 `headers` 를 넘길 수 있다. `http()` 의 모든 옵션을 그대로 받는다.
+     */
+    transport?: TransportConfig;
+};
+/**
+ * Locus 읽기 전용 클라이언트의 one-call 생성자.
+ *
+ * bare {@link createPublicClient} 를 HTTP 트랜스포트와 함께 감싸고, 두 표준
+ * read 액션 셋 (`publicActions` + `debugPublicActions`) 을 단일 `.extend()`
+ * 호출로 합쳐 부착한다. 반환된 클라이언트는 두 셋 모두 정적 타입이 잡힌
+ * 상태로 노출된다.
+ *
+ * 생성 이후엔 모든 read RPC (`locus_getNodeStatus`, `locus_getAccountDetail`,
+ * `calculateSpentByExpress`, `debug_viewContract`, ...) 가 타입이 잡힌
+ * 메서드로 호출 가능:
+ *
+ * ```ts
+ * const client = createLocusPublicClient({ rpcUrl });
+ * const status = await client.getNodeStatus();
+ * const balance = await client.getAccountDetail({ account });
+ * ```
+ *
+ * write TX 용 클라이언트는 {@link createLocusWalletClient} 참고.
+ */
+export declare function createLocusPublicClient(args: CreateLocusPublicClientArgs): import("./types.mjs").Client<undefined> & {
+    readonly allHeights: () => Promise<import("../index.mjs").RpcAccountHeight[]>;
+    readonly balanceGrantList: () => Promise<string[]>;
+    readonly balanceList: () => Promise<string[]>;
+    readonly createAccount: () => Promise<import("../index.mjs").RpcCreateAccountResult>;
+    readonly createNode: (param: import("../index.mjs").ParamsCreateNode) => Promise<import("../index.mjs").RpcCreateNodeResult>;
+    readonly dumpAllAccounts: () => Promise<import("../index.mjs").ResultDumpAccounts>;
+    readonly echo: (str: string) => Promise<string>;
+    readonly gameChainCmd: (param: import("../index.mjs").ParamsGameChainCmd) => Promise<import("../index.mjs").RpcGameChainCmdResult>;
+    readonly getAccountsBalances: (param: import("../index.mjs").ParamsAccounts) => Promise<import("../index.mjs").RpcGetAccountsBalancesResult>;
+    readonly getAccountsHeights: (param: import("../index.mjs").ParamsAccounts) => Promise<import("../index.mjs").RpcGetAccountsHeightsResult>;
+    readonly getContractLog: (param: import("../index.mjs").ParamsContractLog) => Promise<import("../index.mjs").RpcGetContractLogResult>;
+    readonly getGuestsInfo: () => Promise<import("../index.mjs").RpcGetGuestsInfoResult>;
+    readonly getHomeShard: (param: import("../index.mjs").ParamsGetHomeShard) => Promise<import("../index.mjs").RpcGetHomeShardResult>;
+    readonly getImportAccount: (params: import("../index.mjs").ParamsGetImportAccount) => Promise<import("../index.mjs").RpcGetImportAccountResult>;
+    readonly getImportAccountLog: (params: import("../index.mjs").ParamsGetImportAccount) => Promise<import("../index.mjs").RpcImportAccountResult>;
+    readonly getKeys: (params: import("../index.mjs").ParamsAccount) => Promise<import("../index.mjs").RpcGetKeysResult>;
+    readonly getNodeBlocks: () => Promise<import("../index.mjs").RpcGetNodeBlocksResult>;
+    readonly getPeerPool: () => Promise<string[]>;
+    readonly getPeersInfo: () => Promise<import("../index.mjs").GetPeersInfo>;
+    readonly importAccount: (params: import("../index.mjs").ParamsImportAccount) => Promise<import("../index.mjs").RpcImportAccountResult>;
+    readonly initReliableNodes: (param: import("../index.mjs").ParamsInitReliableNodes) => Promise<import("../index.mjs").RpcBoolResult>;
+    readonly noArgsRets: () => Promise<any>;
+    readonly nodeCmd: (cmd: string) => Promise<import("../index.mjs").RpcNodeCmdResult>;
+    readonly removeHoldTxs: (param: import("../index.mjs").ParamsRemoveHoldTxs) => Promise<import("../index.mjs").RetTypeBase>;
+    readonly requestVme: (params: import("../index.mjs").ParamsRequestVme) => Promise<import("../index.mjs").RpcRequestVmeResult>;
+    readonly sendRawTransaction: (params: import("../index.mjs").ParamsSendRawTransaction) => Promise<import("../index.mjs").RpcSendRawTransactionResult>;
+    readonly setImportAccountTx: (params: import("../index.mjs").ParamsSetImportAccountTx) => Promise<import("../index.mjs").RpcSetImportAccountTxResult>;
+    readonly setReliableNode: (param: import("../index.mjs").ParamsSetReliableNode) => Promise<import("../index.mjs").RpcBoolResult>;
+    readonly viewContract: (param: import("../index.mjs").ParamsCallContract) => Promise<import("../index.mjs").RpcViewContractResult>;
+    readonly accountHeightsToDownload: (param: import("../index.mjs").ParamsAccountHeights) => Promise<import("../index.mjs").HeightsResult>;
+    readonly accountHeightsToUpload: (param: import("../index.mjs").ParamsAccountHeights) => Promise<import("../index.mjs").UploadHeightsResult>;
+    readonly calculateSpentByExpress: (param: import("../index.mjs").ParamsCalculateSpentByExpress) => Promise<import("../index.mjs").RpcCalculateSpentByExpressResult>;
+    readonly clientMessage: (param: import("../index.mjs").ParamStr) => Promise<any>;
+    readonly downloadAccountTxs: (param: import("../index.mjs").ParamsDownloadAccountTxs) => Promise<import("../index.mjs").OutputDownloadAccountTxs>;
+    readonly findDuplicateSubscriber: (params: import("../index.mjs").ParamsFindDuplicateSubscriber) => Promise<import("../index.mjs").RpcFindDuplicateSubscriberResult>;
+    readonly generateLatestStoredDataProof: (params: import("../index.mjs").ParamsGenerateLatestStoredDataProof) => Promise<import("../index.mjs").RpcGenerateLatestStoredDataProofResult>;
+    readonly getAccountAssetList: (params: import("../index.mjs").ParamsGetAssetList) => Promise<import("../index.mjs").RpcGetAccountAssetListResult>;
+    readonly getAccountAssetObject: (params: import("../index.mjs").ParamsGetAssetObjects) => Promise<import("../index.mjs").RpcGetAccountAssetObjectResult>;
+    readonly getAccountDetail: (param: import("../index.mjs").ParamsAccount) => Promise<import("../index.mjs").RpcGetAccountDetailResult>;
+    readonly getAccountHistory: (param: import("../index.mjs").ParamsAccountHistory) => Promise<import("../index.mjs").RpcGetAccountHistoryResult>;
+    readonly getAccountTokenList: (params: import("../index.mjs").ParamsAccount) => Promise<import("../index.mjs").RpcGetAccountTokenListResult>;
+    readonly getConciseNodeStatus: () => Promise<import("../index.mjs").RpcGetConciseNodeStatusResult>;
+    readonly getGenesisAccount: () => Promise<import("../index.mjs").RpcGetGenesisAccountResult>;
+    readonly getIdentityProof: (param: import("../index.mjs").ParamsGetIdentityProof) => Promise<import("../index.mjs").RpcGetIdentityProofResult>;
+    readonly getInactiveTxList: (param: import("../index.mjs").ParamsAccount) => Promise<import("../index.mjs").RpcGetInactiveTxListResult>;
+    readonly getMontInfoList: (param: import("../index.mjs").ParamsAccount) => Promise<import("../index.mjs").RpcGetMontInfoListResult>;
+    readonly getNodeStatus: () => Promise<import("../index.mjs").RpcGetNodeStatusResult>;
+    readonly getOwnerBalance: () => Promise<import("../index.mjs").RpcAccountsBalancesResult[]>;
+    readonly getRoundState: (param: import("../index.mjs").ParamsRound) => Promise<import("../index.mjs").RoundStateDetail>;
+    readonly getRoundStatesList: (param: import("../index.mjs").ParamsRS) => Promise<import("../index.mjs").RoundStateAbstract[]>;
+    readonly getShardOfAccount: (params: import("../index.mjs").ParamsAccount) => Promise<import("../index.mjs").RpcGetShardOfAccountResult>;
+    readonly getSyncState: () => Promise<import("../index.mjs").RpcGetSyncStateResult>;
+    readonly getTx: (param: import("../index.mjs").ParamsAccountAndIndex) => Promise<import("../index.mjs").RpcGetTxResult>;
+    readonly getWorldRoundState: (param: import("../index.mjs").ParamsRound) => Promise<import("../index.mjs").RpcGetWorldRoundStateResult>;
+    readonly getWorldRoundStatesList: (param: import("../index.mjs").ParamsRoundList) => Promise<import("../index.mjs").RpcGetWorldRoundStatesListResult>;
+    readonly hasSystemToken: (params: import("../index.mjs").ParamsAccount) => Promise<import("../index.mjs").RpcHasSystemTokenResult>;
+    readonly makeTxProof: (params: import("../index.mjs").ParamsTxList) => Promise<import("../index.mjs").RpcReadTxListWitnessResult>;
+    readonly queryAddress: (params: import("../index.mjs").ParamsQueryAddress) => Promise<import("../index.mjs").RpcQueryAddressResult>;
+    readonly readTxListWitness: (params: import("../index.mjs").ParamsReadTxList) => Promise<import("../index.mjs").RpcReadTxListWitnessResult>;
+    readonly setHost: (param: import("../index.mjs").ParamsSetHost) => Promise<boolean>;
+    readonly subscribeAddress: (params: import("../index.mjs").ParamsSubscribeAddress) => Promise<import("../index.mjs").RpcSubscribeAddressResult>;
+    readonly uploadAccountTxs: (param: import("../index.mjs").ParamsUploadAccountTxs) => Promise<number[]>;
+    readonly verifyAndSignChallenge: (param: import("../index.mjs").ParamsVerifyAndSignChallenge) => Promise<import("../index.mjs").RpcVerifyAndSignChallengeResult>;
+    readonly verifyIdentityProof: (param: import("../index.mjs").ParamsVerifyIdentityProof) => Promise<import("../index.mjs").RpcVerifyIdentityProofResult>;
+    readonly verifyLatestStoredDataProof: (params: import("../index.mjs").ParamsLatestStoredDataProof) => Promise<boolean>;
+    readonly verifyTxListWitness: (params: import("../index.mjs").ParamsTxListWitness) => Promise<boolean>;
+};
+/** 추론된 반환 타입 — 이 클라이언트를 담는 필드/변수의 타입 선언에 사용. */
+export type LocusPublicClient = ReturnType<typeof createLocusPublicClient>;

package/dist/clients/createLocusWalletClient.d.mts

@@ -0,0 +1,56 @@
+import type { DualKeyAccount } from '../accounts/types.mjs';
+import type { TransportConfig } from '../transports/types.mjs';
+export type CreateLocusWalletClientArgs = {
+    /** JSON-RPC 엔드포인트 URL. */
+    rpcUrl: string;
+    /** 트랜잭션 서명에 쓰는 account. `keysToAccount` / `toAccount` 로 만든다. */
+    account: DualKeyAccount;
+    /**
+     * 선택적 HTTP 트랜스포트 설정. 로드밸런서 힌트 (예: Locus `locuslb` 헤더)
+     * 같은 용도로 `headers` 를 넘길 수 있다. `http()` 의 모든 옵션을 그대로 받는다.
+     */
+    transport?: TransportConfig;
+};
+/**
+ * Locus write 클라이언트의 one-call 생성자.
+ *
+ * bare {@link createWalletClient} 를 HTTP 트랜스포트와 함께 감싸고, 두 표준
+ * write 액션 셋 (`walletActions` + `debugWalletActions`) 을 단일 `.extend()`
+ * 호출로 합쳐 부착한다. 반환된 클라이언트는 두 셋 모두 정적 타입이 잡힌
+ * 상태로 노출된다.
+ *
+ * 생성 이후엔 모든 write RPC (`transferCoin`, `openAccount`, `changeKey`,
+ * `closeAccount`, `callContract`, `debug_createContract`, ...) 가 타입이
+ * 잡힌 메서드로 호출 가능. 각 호출은 내부적으로 prepare → sign → submit
+ * 파이프라인을 한 번에 돌리며, master/normal 키 라우팅은 `txKeyPolicy` 와
+ * 바인드된 `account` 의 `KeySource` 슬롯이 결정한다.
+ *
+ * 읽기 전용 RPC 는 {@link createLocusPublicClient} 참고.
+ */
+export declare function createLocusWalletClient(args: CreateLocusWalletClientArgs): import("./types.mjs").Client<DualKeyAccount> & {
+    readonly callContract: (param: import("../index.mjs").ParamsCallContract) => Promise<import("../index.mjs").RpcCreateTxResult>;
+    readonly createContract: (param: import("../index.mjs").ParamsCreateContract) => Promise<import("../index.mjs").RpcCreateTxResult>;
+    readonly createSynthAccount: (param: import("../index.mjs").ParamsCreateSynthAccount) => Promise<import("../index.mjs").RpcCreateTxResult>;
+    readonly postDataToSynthAccount: (param: import("../index.mjs").ParamsPostDataToSynthAccount) => Promise<import("../index.mjs").RpcCreateTxResult>;
+    readonly acceptScript: (params: import("../index.mjs").ParamsAcceptScript) => Promise<import("../index.mjs").RpcCreateTxResult>;
+    readonly becomeGuest: (param: import("../index.mjs").ParamsBecomeGuest) => Promise<import("../index.mjs").RpcCreateTxResult>;
+    readonly becomeHost: (param: import("../index.mjs").ParamsBecomeHost) => Promise<import("../index.mjs").RpcCreateTxResult>;
+    readonly changeKey: (params: import("../index.mjs").ParamsChangeKey) => Promise<import("../index.mjs").RpcCreateTxResult>;
+    readonly changeVkey: (params: import("../index.mjs").ParamsChangeVKey) => Promise<import("../index.mjs").RpcCreateTxResult>;
+    readonly closeAccount: (param: import("../index.mjs").ParamsCloseAccount) => Promise<import("../index.mjs").RpcCreateTxResult>;
+    readonly createAssetObject: (param: import("../index.mjs").ParamsCreateAssetObject) => Promise<import("../index.mjs").RpcCreateTxResult>;
+    readonly createToken: (param: import("../index.mjs").ParamsCreateToken) => Promise<import("../index.mjs").RpcCreateTxResult>;
+    readonly createVme: (param: import("../index.mjs").ParamsCreateVme) => Promise<import("../index.mjs").RpcCreateTxResult>;
+    readonly lockStake: (params: import("../index.mjs").ParamsLockStake) => Promise<import("../index.mjs").RpcCreateTxResult>;
+    readonly openAccount: (param: import("../index.mjs").ParamsOpenAccount) => Promise<import("../index.mjs").RpcCreateTxResult>;
+    readonly postData: (params: import("../index.mjs").InputParamsDataTransfer) => Promise<import("../index.mjs").RpcCreateTxResult>;
+    readonly provideScript: (params: import("../index.mjs").ParamsProvideScript) => Promise<import("../index.mjs").RpcCreateTxResult>;
+    readonly requestDataTrade: (params: import("../index.mjs").ParamsRequestDataTrade) => Promise<import("../index.mjs").RpcDataTradeResult>;
+    readonly transferAssetObject: (params: import("../index.mjs").ParamsTransferAssetObject) => Promise<import("../index.mjs").RpcCreateTxResult>;
+    readonly transferCoin: (param: import("../index.mjs").ParamsTransferCoin) => Promise<import("../index.mjs").RpcCreateTxResult>;
+    readonly transferCoinExpress: (param: import("../index.mjs").ParamsTransferCoinExpress) => Promise<import("../index.mjs").RpcCreateTxResult>;
+    readonly transferToken: (params: import("../index.mjs").ParamsTransferTokens) => Promise<import("../index.mjs").RpcCreateTxResult>;
+    readonly unlockStake: (params: import("../index.mjs").ParamsUnlockStake) => Promise<import("../index.mjs").RpcCreateTxResult>;
+};
+/** 추론된 반환 타입 — 이 클라이언트를 담는 필드/변수의 타입 선언에 사용. */
+export type LocusWalletClient = ReturnType<typeof createLocusWalletClient>;

package/dist/clients/createPublicClient.d.mts

@@ -0,0 +1,6 @@
+import type { Transport } from '../transports/types.mjs';
+import type { PublicClient } from './types.mjs';
+export type CreatePublicClientArgs = {
+    transport: Transport;
+};
+export declare function createPublicClient(args: CreatePublicClientArgs): PublicClient;

package/dist/clients/createWalletClient.d.mts

@@ -0,0 +1,8 @@
+import type { DualKeyAccount } from '../accounts/types.mjs';
+import type { Transport } from '../transports/types.mjs';
+import type { WalletClient } from './types.mjs';
+export type CreateWalletClientArgs = {
+    transport: Transport;
+    account: DualKeyAccount;
+};
+export declare function createWalletClient(args: CreateWalletClientArgs): WalletClient;

package/dist/clients/index.amd.js

@@ -0,0 +1,97 @@
+define(['exports', '../chunks/lclib-BfTIyj-E', '../chunks/debugWalletActions-BDz-h2tl', '../chunks/tslib.es6-D29rxPkW', '../transports/index.amd', '../chunks/rpc-C4n7t9y0', '../chunks/base-B_kRRfsf', '../chunks/account-BSrvZ7S8', '../chunks/transport-BBAz1kmP'], (function (exports, lclib, debugWalletActions, tslib_es6, transports, rpc, base, account, transport) { 'use strict';
+
+    function createClient(args) {
+        var _a;
+        let counter = 0;
+        const idGen = () => {
+            if (counter === Number.MAX_SAFE_INTEGER)
+                counter = 0;
+            return ++counter;
+        };
+        const transport = args.transport({ id: idGen });
+        const account = ((_a = args.account) !== null && _a !== void 0 ? _a : undefined);
+        const request = (rpcArgs, opts) => transport.request(rpcArgs, opts);
+        const base = {
+            transport,
+            account,
+            request,
+        };
+        return attachExtend(base);
+    }
+    function attachExtend(base) {
+        const target = base;
+        target.extend = (fn) => {
+            const ext = fn(base);
+            const merged = Object.assign(Object.assign({}, base), ext);
+            return attachExtend(merged);
+        };
+        return target;
+    }
+
+    function createPublicClient(args) {
+        return createClient({ transport: args.transport });
+    }
+
+    function createWalletClient(args) {
+        return createClient({
+            transport: args.transport,
+            account: args.account,
+        });
+    }
+
+    /**
+     * Locus 읽기 전용 클라이언트의 one-call 생성자.
+     *
+     * bare {@link createPublicClient} 를 HTTP 트랜스포트와 함께 감싸고, 두 표준
+     * read 액션 셋 (`publicActions` + `debugPublicActions`) 을 단일 `.extend()`
+     * 호출로 합쳐 부착한다. 반환된 클라이언트는 두 셋 모두 정적 타입이 잡힌
+     * 상태로 노출된다.
+     *
+     * 생성 이후엔 모든 read RPC (`locus_getNodeStatus`, `locus_getAccountDetail`,
+     * `calculateSpentByExpress`, `debug_viewContract`, ...) 가 타입이 잡힌
+     * 메서드로 호출 가능:
+     *
+     * ```ts
+     * const client = createLocusPublicClient({ rpcUrl });
+     * const status = await client.getNodeStatus();
+     * const balance = await client.getAccountDetail({ account });
+     * ```
+     *
+     * write TX 용 클라이언트는 {@link createLocusWalletClient} 참고.
+     */
+    function createLocusPublicClient(args) {
+        return createPublicClient({
+            transport: transports.http(args.rpcUrl, args.transport),
+        }).extend((c) => (Object.assign(Object.assign({}, debugWalletActions.publicActions(c)), debugWalletActions.debugPublicActions(c))));
+    }
+
+    /**
+     * Locus write 클라이언트의 one-call 생성자.
+     *
+     * bare {@link createWalletClient} 를 HTTP 트랜스포트와 함께 감싸고, 두 표준
+     * write 액션 셋 (`walletActions` + `debugWalletActions`) 을 단일 `.extend()`
+     * 호출로 합쳐 부착한다. 반환된 클라이언트는 두 셋 모두 정적 타입이 잡힌
+     * 상태로 노출된다.
+     *
+     * 생성 이후엔 모든 write RPC (`transferCoin`, `openAccount`, `changeKey`,
+     * `closeAccount`, `callContract`, `debug_createContract`, ...) 가 타입이
+     * 잡힌 메서드로 호출 가능. 각 호출은 내부적으로 prepare → sign → submit
+     * 파이프라인을 한 번에 돌리며, master/normal 키 라우팅은 `txKeyPolicy` 와
+     * 바인드된 `account` 의 `KeySource` 슬롯이 결정한다.
+     *
+     * 읽기 전용 RPC 는 {@link createLocusPublicClient} 참고.
+     */
+    function createLocusWalletClient(args) {
+        return createWalletClient({
+            transport: transports.http(args.rpcUrl, args.transport),
+            account: args.account,
+        }).extend((c) => (Object.assign(Object.assign({}, debugWalletActions.walletActions(c)), debugWalletActions.debugWalletActions(c))));
+    }
+
+    exports.createClient = createClient;
+    exports.createLocusPublicClient = createLocusPublicClient;
+    exports.createLocusWalletClient = createLocusWalletClient;
+    exports.createPublicClient = createPublicClient;
+    exports.createWalletClient = createWalletClient;
+
+}));

package/dist/clients/index.cjs.cjs

@@ -0,0 +1,104 @@
+'use strict';
+
+require('../chunks/lclib-DuoOR0-Q.cjs');
+var debugWalletActions = require('../chunks/debugWalletActions-6qjkZVq9.cjs');
+require('../chunks/tslib.es6-Cfi3-HmA.cjs');
+var transports = require('../transports/index.cjs.cjs');
+require('../chunks/rpc-DwWIkUva.cjs');
+require('../chunks/base-Cy5SSYLF.cjs');
+require('../chunks/account-BAsiKnSL.cjs');
+require('../chunks/transport-VThNtzck.cjs');
+
+function createClient(args) {
+    var _a;
+    let counter = 0;
+    const idGen = () => {
+        if (counter === Number.MAX_SAFE_INTEGER)
+            counter = 0;
+        return ++counter;
+    };
+    const transport = args.transport({ id: idGen });
+    const account = ((_a = args.account) !== null && _a !== void 0 ? _a : undefined);
+    const request = (rpcArgs, opts) => transport.request(rpcArgs, opts);
+    const base = {
+        transport,
+        account,
+        request,
+    };
+    return attachExtend(base);
+}
+function attachExtend(base) {
+    const target = base;
+    target.extend = (fn) => {
+        const ext = fn(base);
+        const merged = Object.assign(Object.assign({}, base), ext);
+        return attachExtend(merged);
+    };
+    return target;
+}
+
+function createPublicClient(args) {
+    return createClient({ transport: args.transport });
+}
+
+function createWalletClient(args) {
+    return createClient({
+        transport: args.transport,
+        account: args.account,
+    });
+}
+
+/**
+ * Locus 읽기 전용 클라이언트의 one-call 생성자.
+ *
+ * bare {@link createPublicClient} 를 HTTP 트랜스포트와 함께 감싸고, 두 표준
+ * read 액션 셋 (`publicActions` + `debugPublicActions`) 을 단일 `.extend()`
+ * 호출로 합쳐 부착한다. 반환된 클라이언트는 두 셋 모두 정적 타입이 잡힌
+ * 상태로 노출된다.
+ *
+ * 생성 이후엔 모든 read RPC (`locus_getNodeStatus`, `locus_getAccountDetail`,
+ * `calculateSpentByExpress`, `debug_viewContract`, ...) 가 타입이 잡힌
+ * 메서드로 호출 가능:
+ *
+ * ```ts
+ * const client = createLocusPublicClient({ rpcUrl });
+ * const status = await client.getNodeStatus();
+ * const balance = await client.getAccountDetail({ account });
+ * ```
+ *
+ * write TX 용 클라이언트는 {@link createLocusWalletClient} 참고.
+ */
+function createLocusPublicClient(args) {
+    return createPublicClient({
+        transport: transports.http(args.rpcUrl, args.transport),
+    }).extend((c) => (Object.assign(Object.assign({}, debugWalletActions.publicActions(c)), debugWalletActions.debugPublicActions(c))));
+}
+
+/**
+ * Locus write 클라이언트의 one-call 생성자.
+ *
+ * bare {@link createWalletClient} 를 HTTP 트랜스포트와 함께 감싸고, 두 표준
+ * write 액션 셋 (`walletActions` + `debugWalletActions`) 을 단일 `.extend()`
+ * 호출로 합쳐 부착한다. 반환된 클라이언트는 두 셋 모두 정적 타입이 잡힌
+ * 상태로 노출된다.
+ *
+ * 생성 이후엔 모든 write RPC (`transferCoin`, `openAccount`, `changeKey`,
+ * `closeAccount`, `callContract`, `debug_createContract`, ...) 가 타입이
+ * 잡힌 메서드로 호출 가능. 각 호출은 내부적으로 prepare → sign → submit
+ * 파이프라인을 한 번에 돌리며, master/normal 키 라우팅은 `txKeyPolicy` 와
+ * 바인드된 `account` 의 `KeySource` 슬롯이 결정한다.
+ *
+ * 읽기 전용 RPC 는 {@link createLocusPublicClient} 참고.
+ */
+function createLocusWalletClient(args) {
+    return createWalletClient({
+        transport: transports.http(args.rpcUrl, args.transport),
+        account: args.account,
+    }).extend((c) => (Object.assign(Object.assign({}, debugWalletActions.walletActions(c)), debugWalletActions.debugWalletActions(c))));
+}
+
+exports.createClient = createClient;
+exports.createLocusPublicClient = createLocusPublicClient;
+exports.createLocusWalletClient = createLocusWalletClient;
+exports.createPublicClient = createPublicClient;
+exports.createWalletClient = createWalletClient;

package/dist/clients/index.d.cts

@@ -0,0 +1,6 @@
+export * from './types.mjs';
+export * from './createClient.mjs';
+export * from './createPublicClient.mjs';
+export * from './createWalletClient.mjs';
+export * from './createLocusPublicClient.mjs';
+export * from './createLocusWalletClient.mjs';

package/dist/clients/index.d.mts

@@ -0,0 +1,6 @@
+export * from './types.mjs';
+export * from './createClient.mjs';
+export * from './createPublicClient.mjs';
+export * from './createWalletClient.mjs';
+export * from './createLocusPublicClient.mjs';
+export * from './createLocusWalletClient.mjs';

package/dist/clients/index.esm.js

@@ -0,0 +1,98 @@
+import '../chunks/lclib-C2eG5HzD.js';
+import { an as publicActions, U as debugPublicActions, aD as walletActions, V as debugWalletActions } from '../chunks/debugWalletActions-D5-Ds7Hl.js';
+import '../chunks/tslib.es6-WQS2tr1v.js';
+import { http } from '../transports/index.esm.js';
+import '../chunks/rpc-BlPk44QH.js';
+import '../chunks/base-BQXfRsuw.js';
+import '../chunks/account-FZT9LH_s.js';
+import '../chunks/transport-ktAPuqsc.js';
+
+function createClient(args) {
+    var _a;
+    let counter = 0;
+    const idGen = () => {
+        if (counter === Number.MAX_SAFE_INTEGER)
+            counter = 0;
+        return ++counter;
+    };
+    const transport = args.transport({ id: idGen });
+    const account = ((_a = args.account) !== null && _a !== void 0 ? _a : undefined);
+    const request = (rpcArgs, opts) => transport.request(rpcArgs, opts);
+    const base = {
+        transport,
+        account,
+        request,
+    };
+    return attachExtend(base);
+}
+function attachExtend(base) {
+    const target = base;
+    target.extend = (fn) => {
+        const ext = fn(base);
+        const merged = Object.assign(Object.assign({}, base), ext);
+        return attachExtend(merged);
+    };
+    return target;
+}
+
+function createPublicClient(args) {
+    return createClient({ transport: args.transport });
+}
+
+function createWalletClient(args) {
+    return createClient({
+        transport: args.transport,
+        account: args.account,
+    });
+}
+
+/**
+ * Locus 읽기 전용 클라이언트의 one-call 생성자.
+ *
+ * bare {@link createPublicClient} 를 HTTP 트랜스포트와 함께 감싸고, 두 표준
+ * read 액션 셋 (`publicActions` + `debugPublicActions`) 을 단일 `.extend()`
+ * 호출로 합쳐 부착한다. 반환된 클라이언트는 두 셋 모두 정적 타입이 잡힌
+ * 상태로 노출된다.
+ *
+ * 생성 이후엔 모든 read RPC (`locus_getNodeStatus`, `locus_getAccountDetail`,
+ * `calculateSpentByExpress`, `debug_viewContract`, ...) 가 타입이 잡힌
+ * 메서드로 호출 가능:
+ *
+ * ```ts
+ * const client = createLocusPublicClient({ rpcUrl });
+ * const status = await client.getNodeStatus();
+ * const balance = await client.getAccountDetail({ account });
+ * ```
+ *
+ * write TX 용 클라이언트는 {@link createLocusWalletClient} 참고.
+ */
+function createLocusPublicClient(args) {
+    return createPublicClient({
+        transport: http(args.rpcUrl, args.transport),
+    }).extend((c) => (Object.assign(Object.assign({}, publicActions(c)), debugPublicActions(c))));
+}
+
+/**
+ * Locus write 클라이언트의 one-call 생성자.
+ *
+ * bare {@link createWalletClient} 를 HTTP 트랜스포트와 함께 감싸고, 두 표준
+ * write 액션 셋 (`walletActions` + `debugWalletActions`) 을 단일 `.extend()`
+ * 호출로 합쳐 부착한다. 반환된 클라이언트는 두 셋 모두 정적 타입이 잡힌
+ * 상태로 노출된다.
+ *
+ * 생성 이후엔 모든 write RPC (`transferCoin`, `openAccount`, `changeKey`,
+ * `closeAccount`, `callContract`, `debug_createContract`, ...) 가 타입이
+ * 잡힌 메서드로 호출 가능. 각 호출은 내부적으로 prepare → sign → submit
+ * 파이프라인을 한 번에 돌리며, master/normal 키 라우팅은 `txKeyPolicy` 와
+ * 바인드된 `account` 의 `KeySource` 슬롯이 결정한다.
+ *
+ * 읽기 전용 RPC 는 {@link createLocusPublicClient} 참고.
+ */
+function createLocusWalletClient(args) {
+    return createWalletClient({
+        transport: http(args.rpcUrl, args.transport),
+        account: args.account,
+    }).extend((c) => (Object.assign(Object.assign({}, walletActions(c)), debugWalletActions(c))));
+}
+
+export { createClient, createLocusPublicClient, createLocusWalletClient, createPublicClient, createWalletClient };

package/dist/clients/types.d.mts

@@ -0,0 +1,19 @@
+import type { DualKeyAccount } from '../accounts/types.mjs';
+import type { TransportInstance } from '../transports/types.mjs';
+export type ClientRequestArgs = {
+    method: string;
+    params: readonly unknown[];
+};
+export type ClientRequestOptions = {
+    signal?: AbortSignal;
+    headers?: HeadersInit;
+};
+export type ClientRequestFn = <T = any>(args: ClientRequestArgs, opts?: ClientRequestOptions) => Promise<T>;
+export type Client<TAccount extends DualKeyAccount | undefined = DualKeyAccount | undefined> = {
+    transport: TransportInstance;
+    account: TAccount;
+    request: ClientRequestFn;
+    extend: <const Ext extends object>(fn: (client: Client<TAccount>) => Ext) => Client<TAccount> & Ext;
+};
+export type PublicClient = Client<undefined>;
+export type WalletClient = Client<DualKeyAccount>;