@locuschain/lib 0.2.2 → 0.2.3

package/dist/autogen/wasm.d.cts

@@ -0,0 +1,72 @@
+import { GrantConsumeResult } from './types/wasm/grant-consume-result.cjs';
+import { LibraryVersions } from './types/wasm/library-versions.cjs';
+import { ParamCalculateTxLinkHash } from './types/wasm/param-calculate-tx-link-hash.cjs';
+import { ParamCodeCoreScript } from './types/wasm/param-code-core-script.cjs';
+import { ParamConvertCurrency } from './types/wasm/param-convert-currency.cjs';
+import { ParamCreateAccountAndKeystore } from './types/wasm/param-create-account-and-keystore.cjs';
+import { ParamCreateMasterKeystore } from './types/wasm/param-create-master-keystore.cjs';
+import { ParamCreateNormalKey } from './types/wasm/param-create-normal-key.cjs';
+import { ParamCreateNormalKeystore } from './types/wasm/param-create-normal-keystore.cjs';
+import { ParamDeriveKeysFromMnemonicAndPath } from './types/wasm/param-derive-keys-from-mnemonic-and-path.cjs';
+import { ParamDeriveKeysFromMnemonic } from './types/wasm/param-derive-keys-from-mnemonic.cjs';
+import { ParamEncodeTxCurrency } from './types/wasm/param-encode-tx-currency.cjs';
+import { ParamEncodeTxNumber } from './types/wasm/param-encode-tx-number.cjs';
+import { ParamGenerateMnemonicBySeed } from './types/wasm/param-generate-mnemonic-by-seed.cjs';
+import { ParamGenerateMnemonic } from './types/wasm/param-generate-mnemonic.cjs';
+import { ParamGetHomeShard } from './types/wasm/param-get-home-shard.cjs';
+import { ParamHash } from './types/wasm/param-hash.cjs';
+import { ParamLoadKeystore } from './types/wasm/param-load-keystore.cjs';
+import { ParamMakeCurrency } from './types/wasm/param-make-currency.cjs';
+import { ParamSignByMasterKey } from './types/wasm/param-sign-by-master-key.cjs';
+import { ParamSignKeyBind } from './types/wasm/param-sign-key-bind.cjs';
+import { ParamSign } from './types/wasm/param-sign.cjs';
+import { ParamTestCoreScript } from './types/wasm/param-test-core-script.cjs';
+import { ParamTxs } from './types/wasm/param-txs.cjs';
+import { ParamVerifyMerkleProof } from './types/wasm/param-verify-merkle-proof.cjs';
+import { ParamVerify } from './types/wasm/param-verify.cjs';
+export declare const calculateTxLinkHash: (params: ParamCalculateTxLinkHash) => string;
+export declare const compileCoreScript: (params: ParamCodeCoreScript) => string;
+export declare const convertAddressToData: (addrEncoded: string) => string;
+export declare const convertAddressToHex: (addrEncoded: string) => string;
+export declare const convertBase32ToData: (encoded: string) => string;
+export declare const convertBase32ToHex: (encoded: string) => string;
+export declare const convertCurrency: (params: ParamConvertCurrency) => string;
+export declare const convertDataTo: (value: string, retType: number) => string;
+export declare const convertDataToAddress: (str: string) => string;
+export declare const convertDataToBase32: (str: string) => string;
+export declare const convertDataToHex: (str: string) => string;
+export declare const convertDataToString: (str: string) => string;
+export declare const convertHexToAddress: (hexString: string) => string;
+export declare const convertHexToBase32: (hexString: string) => string;
+export declare const convertHexToData: (encoded: string) => string;
+export declare const convertStringToData: (raw: string) => string;
+export declare const convertToData: (value: string, valueType: number) => string;
+export declare const createAccountAndKeystore: (params: ParamCreateAccountAndKeystore) => string;
+export declare const createMasterKeystore: (params: ParamCreateMasterKeystore) => string;
+export declare const createNormalKey: (params: ParamCreateNormalKey) => string;
+export declare const createNormalKeystore: (params: ParamCreateNormalKeystore) => string;
+export declare const decodeTxs: (params: ParamTxs) => string;
+export declare const deriveKeysFromMnemonic: (params: ParamDeriveKeysFromMnemonic) => string;
+export declare const deriveKeysFromMnemonicAndPath: (params: ParamDeriveKeysFromMnemonicAndPath) => string;
+export declare const disCompileCoreScript: (params: ParamCodeCoreScript) => string;
+export declare const encodeTxCurrency: (params: ParamEncodeTxCurrency) => string;
+export declare const encodeTxNumber: (params: ParamEncodeTxNumber) => string;
+export declare const generateMnemonic: (params: ParamGenerateMnemonic) => string;
+export declare const generateMnemonicBySeed: (params: ParamGenerateMnemonicBySeed) => string;
+export declare const getDefFromCoreScript: (params: ParamCodeCoreScript) => string;
+export declare const getHomeShard: (params: ParamGetHomeShard) => number;
+export declare const getLibraryVersions: () => LibraryVersions;
+export declare const gzipAndEncode: (str: string) => string;
+export declare const hash: (params: ParamHash) => string;
+export declare const isGrantConsumingTx: (txTypeStr: string) => GrantConsumeResult;
+export declare const loadMasterKeystore: (params: ParamLoadKeystore) => string;
+export declare const loadNormalKeystore: (params: ParamLoadKeystore) => string;
+export declare const makeCurrency: (params: ParamMakeCurrency) => string;
+export declare const sign: (param: ParamSign) => string;
+export declare const signByMasterKey: (params: ParamSignByMasterKey) => string;
+export declare const signKeyBind: (params: ParamSignKeyBind) => string;
+export declare const testCoreScript: (params: ParamTestCoreScript) => string;
+export declare const verify: (params: ParamVerify) => string;
+export declare const verifyByMasterKey: (params: ParamVerify) => string;
+export declare const verifyMerkleProof: (params: ParamVerifyMerkleProof) => boolean;
+export declare const verifyTx: (jsonTx: string) => string;

package/dist/clients/createClient.d.cts

@@ -0,0 +1,8 @@
+import type { DualKeyAccount } from '../accounts/types.cjs';
+import type { Transport } from '../transports/types.cjs';
+import type { Client } from './types.cjs';
+export type CreateClientArgs<TAccount extends DualKeyAccount | undefined> = {
+    transport: Transport;
+    account?: TAccount;
+};
+export declare function createClient<TAccount extends DualKeyAccount | undefined = undefined>(args: CreateClientArgs<TAccount>): Client<TAccount>;

package/dist/clients/createLocusPublicClient.d.cts

@@ -0,0 +1,100 @@
+import type { TransportConfig } from '../transports/types.cjs';
+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.cjs").Client<undefined> & {
+    readonly allHeights: () => Promise<import("../index.cjs").RpcAccountHeight[]>;
+    readonly balanceGrantList: () => Promise<string[]>;
+    readonly balanceList: () => Promise<string[]>;
+    readonly createAccount: () => Promise<import("../index.cjs").RpcCreateAccountResult>;
+    readonly createNode: (param: import("../index.cjs").ParamsCreateNode) => Promise<import("../index.cjs").RpcCreateNodeResult>;
+    readonly dumpAllAccounts: () => Promise<import("../index.cjs").ResultDumpAccounts>;
+    readonly echo: (str: string) => Promise<string>;
+    readonly gameChainCmd: (param: import("../index.cjs").ParamsGameChainCmd) => Promise<import("../index.cjs").RpcGameChainCmdResult>;
+    readonly getAccountsBalances: (param: import("../index.cjs").ParamsAccounts) => Promise<import("../index.cjs").RpcGetAccountsBalancesResult>;
+    readonly getAccountsHeights: (param: import("../index.cjs").ParamsAccounts) => Promise<import("../index.cjs").RpcGetAccountsHeightsResult>;
+    readonly getContractLog: (param: import("../index.cjs").ParamsContractLog) => Promise<import("../index.cjs").RpcGetContractLogResult>;
+    readonly getGuestsInfo: () => Promise<import("../index.cjs").RpcGetGuestsInfoResult>;
+    readonly getHomeShard: (param: import("../index.cjs").ParamsGetHomeShard) => Promise<import("../index.cjs").RpcGetHomeShardResult>;
+    readonly getImportAccount: (params: import("../index.cjs").ParamsGetImportAccount) => Promise<import("../index.cjs").RpcGetImportAccountResult>;
+    readonly getImportAccountLog: (params: import("../index.cjs").ParamsGetImportAccount) => Promise<import("../index.cjs").RpcImportAccountResult>;
+    readonly getKeys: (params: import("../index.cjs").ParamsAccount) => Promise<import("../index.cjs").RpcGetKeysResult>;
+    readonly getNodeBlocks: () => Promise<import("../index.cjs").RpcGetNodeBlocksResult>;
+    readonly getPeerPool: () => Promise<string[]>;
+    readonly getPeersInfo: () => Promise<import("../index.cjs").GetPeersInfo>;
+    readonly importAccount: (params: import("../index.cjs").ParamsImportAccount) => Promise<import("../index.cjs").RpcImportAccountResult>;
+    readonly initReliableNodes: (param: import("../index.cjs").ParamsInitReliableNodes) => Promise<import("../index.cjs").RpcBoolResult>;
+    readonly noArgsRets: () => Promise<any>;
+    readonly nodeCmd: (cmd: string) => Promise<import("../index.cjs").RpcNodeCmdResult>;
+    readonly removeHoldTxs: (param: import("../index.cjs").ParamsRemoveHoldTxs) => Promise<import("../index.cjs").RetTypeBase>;
+    readonly requestVme: (params: import("../index.cjs").ParamsRequestVme) => Promise<import("../index.cjs").RpcRequestVmeResult>;
+    readonly sendRawTransaction: (params: import("../index.cjs").ParamsSendRawTransaction) => Promise<import("../index.cjs").RpcSendRawTransactionResult>;
+    readonly setImportAccountTx: (params: import("../index.cjs").ParamsSetImportAccountTx) => Promise<import("../index.cjs").RpcSetImportAccountTxResult>;
+    readonly setReliableNode: (param: import("../index.cjs").ParamsSetReliableNode) => Promise<import("../index.cjs").RpcBoolResult>;
+    readonly viewContract: (param: import("../index.cjs").ParamsCallContract) => Promise<import("../index.cjs").RpcViewContractResult>;
+    readonly accountHeightsToDownload: (param: import("../index.cjs").ParamsAccountHeights) => Promise<import("../index.cjs").HeightsResult>;
+    readonly accountHeightsToUpload: (param: import("../index.cjs").ParamsAccountHeights) => Promise<import("../index.cjs").UploadHeightsResult>;
+    readonly calculateSpentByExpress: (param: import("../index.cjs").ParamsCalculateSpentByExpress) => Promise<import("../index.cjs").RpcCalculateSpentByExpressResult>;
+    readonly clientMessage: (param: import("../index.cjs").ParamStr) => Promise<any>;
+    readonly downloadAccountTxs: (param: import("../index.cjs").ParamsDownloadAccountTxs) => Promise<import("../index.cjs").OutputDownloadAccountTxs>;
+    readonly findDuplicateSubscriber: (params: import("../index.cjs").ParamsFindDuplicateSubscriber) => Promise<import("../index.cjs").RpcFindDuplicateSubscriberResult>;
+    readonly generateLatestStoredDataProof: (params: import("../index.cjs").ParamsGenerateLatestStoredDataProof) => Promise<import("../index.cjs").RpcGenerateLatestStoredDataProofResult>;
+    readonly getAccountAssetList: (params: import("../index.cjs").ParamsGetAssetList) => Promise<import("../index.cjs").RpcGetAccountAssetListResult>;
+    readonly getAccountAssetObject: (params: import("../index.cjs").ParamsGetAssetObjects) => Promise<import("../index.cjs").RpcGetAccountAssetObjectResult>;
+    readonly getAccountDetail: (param: import("../index.cjs").ParamsAccount) => Promise<import("../index.cjs").RpcGetAccountDetailResult>;
+    readonly getAccountHistory: (param: import("../index.cjs").ParamsAccountHistory) => Promise<import("../index.cjs").RpcGetAccountHistoryResult>;
+    readonly getAccountTokenList: (params: import("../index.cjs").ParamsAccount) => Promise<import("../index.cjs").RpcGetAccountTokenListResult>;
+    readonly getConciseNodeStatus: () => Promise<import("../index.cjs").RpcGetConciseNodeStatusResult>;
+    readonly getGenesisAccount: () => Promise<import("../index.cjs").RpcGetGenesisAccountResult>;
+    readonly getIdentityProof: (param: import("../index.cjs").ParamsGetIdentityProof) => Promise<import("../index.cjs").RpcGetIdentityProofResult>;
+    readonly getInactiveTxList: (param: import("../index.cjs").ParamsAccount) => Promise<import("../index.cjs").RpcGetInactiveTxListResult>;
+    readonly getMontInfoList: (param: import("../index.cjs").ParamsAccount) => Promise<import("../index.cjs").RpcGetMontInfoListResult>;
+    readonly getNodeStatus: () => Promise<import("../index.cjs").RpcGetNodeStatusResult>;
+    readonly getOwnerBalance: () => Promise<import("../index.cjs").RpcAccountsBalancesResult[]>;
+    readonly getRoundState: (param: import("../index.cjs").ParamsRound) => Promise<import("../index.cjs").RoundStateDetail>;
+    readonly getRoundStatesList: (param: import("../index.cjs").ParamsRS) => Promise<import("../index.cjs").RoundStateAbstract[]>;
+    readonly getShardOfAccount: (params: import("../index.cjs").ParamsAccount) => Promise<import("../index.cjs").RpcGetShardOfAccountResult>;
+    readonly getSyncState: () => Promise<import("../index.cjs").RpcGetSyncStateResult>;
+    readonly getTx: (param: import("../index.cjs").ParamsAccountAndIndex) => Promise<import("../index.cjs").RpcGetTxResult>;
+    readonly getWorldRoundState: (param: import("../index.cjs").ParamsRound) => Promise<import("../index.cjs").RpcGetWorldRoundStateResult>;
+    readonly getWorldRoundStatesList: (param: import("../index.cjs").ParamsRoundList) => Promise<import("../index.cjs").RpcGetWorldRoundStatesListResult>;
+    readonly hasSystemToken: (params: import("../index.cjs").ParamsAccount) => Promise<import("../index.cjs").RpcHasSystemTokenResult>;
+    readonly makeTxProof: (params: import("../index.cjs").ParamsTxList) => Promise<import("../index.cjs").RpcReadTxListWitnessResult>;
+    readonly queryAddress: (params: import("../index.cjs").ParamsQueryAddress) => Promise<import("../index.cjs").RpcQueryAddressResult>;
+    readonly readTxListWitness: (params: import("../index.cjs").ParamsReadTxList) => Promise<import("../index.cjs").RpcReadTxListWitnessResult>;
+    readonly setHost: (param: import("../index.cjs").ParamsSetHost) => Promise<boolean>;
+    readonly subscribeAddress: (params: import("../index.cjs").ParamsSubscribeAddress) => Promise<import("../index.cjs").RpcSubscribeAddressResult>;
+    readonly uploadAccountTxs: (param: import("../index.cjs").ParamsUploadAccountTxs) => Promise<number[]>;
+    readonly verifyAndSignChallenge: (param: import("../index.cjs").ParamsVerifyAndSignChallenge) => Promise<import("../index.cjs").RpcVerifyAndSignChallengeResult>;
+    readonly verifyIdentityProof: (param: import("../index.cjs").ParamsVerifyIdentityProof) => Promise<import("../index.cjs").RpcVerifyIdentityProofResult>;
+    readonly verifyLatestStoredDataProof: (params: import("../index.cjs").ParamsLatestStoredDataProof) => Promise<boolean>;
+    readonly verifyTxListWitness: (params: import("../index.cjs").ParamsTxListWitness) => Promise<boolean>;
+};
+/** 추론된 반환 타입 — 이 클라이언트를 담는 필드/변수의 타입 선언에 사용. */
+export type LocusPublicClient = ReturnType<typeof createLocusPublicClient>;

package/dist/clients/createLocusWalletClient.d.cts

@@ -0,0 +1,57 @@
+import type { DualKeyAccount } from '../accounts/types.cjs';
+import type { TransportConfig } from '../transports/types.cjs';
+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.cjs").Client<DualKeyAccount> & {
+    readonly callContract: (param: import("../index.cjs").ParamsCallContract) => Promise<import("../index.cjs").RpcCreateTxResult>;
+    readonly createContract: (param: import("../index.cjs").ParamsCreateContract) => Promise<import("../index.cjs").RpcCreateTxResult>;
+    readonly createSynthAccount: (param: import("../index.cjs").ParamsCreateSynthAccount) => Promise<import("../index.cjs").RpcCreateTxResult>;
+    readonly postDataToSynthAccount: (param: import("../index.cjs").ParamsPostDataToSynthAccount) => Promise<import("../index.cjs").RpcCreateTxResult>;
+    readonly acceptScript: (params: import("../index.cjs").ParamsAcceptScript) => Promise<import("../index.cjs").RpcCreateTxResult>;
+    readonly becomeGuest: (param: import("../index.cjs").ParamsBecomeGuest) => Promise<import("../index.cjs").RpcCreateTxResult>;
+    readonly becomeHost: (param: import("../index.cjs").ParamsBecomeHost) => Promise<import("../index.cjs").RpcCreateTxResult>;
+    readonly changeKey: (params: import("../index.cjs").ParamsChangeKey) => Promise<import("../index.cjs").RpcCreateTxResult>;
+    readonly changeVkey: (params: import("../index.cjs").ParamsChangeVKey) => Promise<import("../index.cjs").RpcCreateTxResult>;
+    readonly closeAccount: (param: import("../index.cjs").ParamsCloseAccount) => Promise<import("../index.cjs").RpcCreateTxResult>;
+    readonly createAssetObject: (param: import("../index.cjs").ParamsCreateAssetObject) => Promise<import("../index.cjs").RpcCreateTxResult>;
+    readonly createToken: (param: import("../index.cjs").ParamsCreateToken) => Promise<import("../index.cjs").RpcCreateTxResult>;
+    readonly createVme: (param: import("../index.cjs").ParamsCreateVme) => Promise<import("../index.cjs").RpcCreateTxResult>;
+    readonly freezeAccount: (params: import("../index.cjs").ParamsFreezeAccount) => Promise<import("../index.cjs").RpcCreateTxResult>;
+    readonly lockStake: (params: import("../index.cjs").ParamsLockStake) => Promise<import("../index.cjs").RpcCreateTxResult>;
+    readonly openAccount: (param: import("../index.cjs").ParamsOpenAccount) => Promise<import("../index.cjs").RpcCreateTxResult>;
+    readonly postData: (params: import("../index.cjs").InputParamsDataTransfer) => Promise<import("../index.cjs").RpcCreateTxResult>;
+    readonly provideScript: (params: import("../index.cjs").ParamsProvideScript) => Promise<import("../index.cjs").RpcCreateTxResult>;
+    readonly requestDataTrade: (params: import("../index.cjs").ParamsRequestDataTrade) => Promise<import("../index.cjs").RpcDataTradeResult>;
+    readonly transferAssetObject: (params: import("../index.cjs").ParamsTransferAssetObject) => Promise<import("../index.cjs").RpcCreateTxResult>;
+    readonly transferCoin: (param: import("../index.cjs").ParamsTransferCoin) => Promise<import("../index.cjs").RpcCreateTxResult>;
+    readonly transferCoinExpress: (param: import("../index.cjs").ParamsTransferCoinExpress) => Promise<import("../index.cjs").RpcCreateTxResult>;
+    readonly transferToken: (params: import("../index.cjs").ParamsTransferTokens) => Promise<import("../index.cjs").RpcCreateTxResult>;
+    readonly unlockStake: (params: import("../index.cjs").ParamsUnlockStake) => Promise<import("../index.cjs").RpcCreateTxResult>;
+};
+/** 추론된 반환 타입 — 이 클라이언트를 담는 필드/변수의 타입 선언에 사용. */
+export type LocusWalletClient = ReturnType<typeof createLocusWalletClient>;

package/dist/clients/createPublicClient.d.cts

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

package/dist/clients/createWalletClient.d.cts

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

package/dist/clients/index.d.cts

@@ -1,6 +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';
+export * from './types.cjs';
+export * from './createClient.cjs';
+export * from './createPublicClient.cjs';
+export * from './createWalletClient.cjs';
+export * from './createLocusPublicClient.cjs';
+export * from './createLocusWalletClient.cjs';

package/dist/clients/types.d.cts

@@ -0,0 +1,21 @@
+import type { DualKeyAccount } from '../accounts/types.cjs';
+import type { TransportInstance } from '../transports/types.cjs';
+type HeadersInit = Record<string, string>;
+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>;
+export {};

package/dist/clients/types.d.mts

@@ -1,5 +1,6 @@
 import type { DualKeyAccount } from '../accounts/types.mjs';
 import type { TransportInstance } from '../transports/types.mjs';
+type HeadersInit = Record<string, string>;
 export type ClientRequestArgs = {
     method: string;
     params: readonly unknown[];
@@ -17,3 +18,4 @@ export type Client<TAccount extends DualKeyAccount | undefined = DualKeyAccount
 };
 export type PublicClient = Client<undefined>;
 export type WalletClient = Client<DualKeyAccount>;
+export {};

package/dist/constant/index.d.cts

@@ -509,5 +509,5 @@ export declare const FeeType: Readonly<{
     readonly GRANT_ONLY: 1;
 }>;
 export type FeeType = (typeof FeeType)[keyof typeof FeeType];
-export * from '../autogen/types/consts/consts.mjs';
-export * from '../autogen/types/consts/tx-types.mjs';
+export * from '../autogen/types/consts/consts.cjs';
+export * from '../autogen/types/consts/tx-types.cjs';

package/dist/contracts/abis/erc20.d.cts

@@ -0,0 +1,174 @@
+/**
+ * getContract({ abi: erc20Abi, ... }) 에서 쓰는 최소 ERC-20 ABI.
+ * 기존 on-chain 컨트랙트와 그대로 매칭되도록 legacy support/erc20-helper/
+ * erc20.mts 의 정의를 변경 없이 그대로 옮겨왔다.
+ */
+export declare const erc20Abi: readonly [{
+    readonly constant: true;
+    readonly inputs: readonly [];
+    readonly name: "name";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+    }];
+    readonly payable: false;
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly constant: false;
+    readonly inputs: readonly [{
+        readonly name: "_spender";
+        readonly type: "address";
+    }, {
+        readonly name: "_value";
+        readonly type: "uint256";
+    }];
+    readonly name: "approve";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly payable: false;
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly constant: true;
+    readonly inputs: readonly [];
+    readonly name: "totalSupply";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly payable: false;
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly constant: false;
+    readonly inputs: readonly [{
+        readonly name: "_from";
+        readonly type: "address";
+    }, {
+        readonly name: "_to";
+        readonly type: "address";
+    }, {
+        readonly name: "_value";
+        readonly type: "uint256";
+    }];
+    readonly name: "transferFrom";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly payable: false;
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly constant: true;
+    readonly inputs: readonly [];
+    readonly name: "decimals";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint8";
+    }];
+    readonly payable: false;
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly constant: true;
+    readonly inputs: readonly [{
+        readonly name: "_owner";
+        readonly type: "address";
+    }];
+    readonly name: "balanceOf";
+    readonly outputs: readonly [{
+        readonly name: "balance";
+        readonly type: "uint256";
+    }];
+    readonly payable: false;
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly constant: true;
+    readonly inputs: readonly [];
+    readonly name: "symbol";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+    }];
+    readonly payable: false;
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly constant: false;
+    readonly inputs: readonly [{
+        readonly name: "_to";
+        readonly type: "address";
+    }, {
+        readonly name: "_value";
+        readonly type: "uint256";
+    }];
+    readonly name: "transfer";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly payable: false;
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly constant: true;
+    readonly inputs: readonly [{
+        readonly name: "_owner";
+        readonly type: "address";
+    }, {
+        readonly name: "_spender";
+        readonly type: "address";
+    }];
+    readonly name: "allowance";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly payable: false;
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly payable: true;
+    readonly stateMutability: "payable";
+    readonly type: "fallback";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly name: "value";
+        readonly type: "uint256";
+    }];
+    readonly name: "Approval";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly name: "value";
+        readonly type: "uint256";
+    }];
+    readonly name: "Transfer";
+    readonly type: "event";
+}];
+export type Erc20Abi = typeof erc20Abi;

package/dist/contracts/abis/index.d.cts

@@ -0,0 +1 @@
+export * from './erc20.cjs';

package/dist/contracts/getContract.d.cts

@@ -0,0 +1,33 @@
+import type { Client } from '../clients/types.cjs';
+import type { Address } from '../types/primitives.cjs';
+export type InterfaceAbi = ReadonlyArray<Record<string, unknown>> | string | readonly string[];
+export type ReadCallOptions = {
+    /** view 호출의 주체 account. 기본값은 client.account?.address (있으면) 또는 컨트랙트 주소. */
+    caller?: Address;
+    amount?: string;
+    fuelLimit?: string;
+};
+export type GetContractArgs = {
+    address: Address;
+    abi: InterfaceAbi;
+    client: Client;
+};
+export type ContractReadFn = (args?: readonly unknown[], opts?: ReadCallOptions) => Promise<unknown>;
+export type ContractInstance = {
+    address: Address;
+    abi: InterfaceAbi;
+    read: Record<string, ContractReadFn>;
+};
+/**
+ * Locus 의 debug_viewContract RPC 위에 viem 스타일 컨트랙트 핸들을 만든다.
+ * `read.<fn>` 은 ethers(v5) 의 Interface 로 호출을 인코딩하고, 결과 바이트를
+ * convertHexToData 로 Locus `func` 필드에 담아 보낸 뒤, 응답 hex 를
+ * Interface.decodeFunctionResult 로 다시 디코딩한다.
+ *
+ * write 메서드는 이번 단계에서는 의도적으로 빠져 있다. 상태를 바꾸는 호출
+ * 은 생성된 wallet action 을 직접 사용한다:
+ *
+ *   import { callContract } from '@locuschain/lib/autogen';
+ *   await wallet.extend(debugWalletActions).callContract({ ... });
+ */
+export declare function getContract(args: GetContractArgs): ContractInstance;

package/dist/contracts/index.d.cts

@@ -1,2 +1,2 @@
-export * from './getContract.mjs';
-export * from './abis/index.mjs';
+export * from './getContract.cjs';
+export * from './abis/index.cjs';

package/dist/errors/account.d.cts

@@ -0,0 +1,45 @@
+import { BaseError, type BaseErrorOptions } from './base.cjs';
+export declare class AccountRequiredError extends BaseError {
+    name: string;
+    constructor(method: string);
+}
+export declare class InvalidTxResultError extends BaseError {
+    name: string;
+    method?: string;
+    constructor(shortMessage: string, options?: BaseErrorOptions & {
+        method?: string;
+    });
+}
+export declare class SignFailedError extends BaseError {
+    name: string;
+    constructor(shortMessage: string, options?: BaseErrorOptions);
+}
+/**
+ * WASM 의 키 derivation 경로가 동일한 master / normal public key 를 반환한
+ * 경우에 던진다. 과거에는 JS 브릿지가 deterministic seed 를 WASM 으로
+ * 전달하지 못하던 버그 (bug-002, 커밋 e00a35e 에서 해결) 가 원인이었고,
+ * 그 결과 AIMER / HAETAE 조합에서 두 슬롯의 키가 같은 값으로 derive 되곤
+ * 했다. 브릿지 fix 이후 이 가드는 회귀 안전망 역할만 한다 — 생성 시점에
+ * 조용히 실패하면 호출자는 master==normal account 를 들고 있다가 노드의
+ * `openAccount` 단계에서 거부 당하므로, JS 경계에서 미리 surface 한다.
+ */
+export declare class DegenerateKeyError extends BaseError {
+    name: string;
+    algoMaster?: string;
+    algoNormal?: string;
+    constructor(options: {
+        source: string;
+        algoMaster?: string;
+        algoNormal?: string;
+        cause?: unknown;
+    });
+}
+/**
+ * TX 가 `master.signKeyBind` 를 필요로 하는데 (OPEN_ACCOUNT, CHANGE_KEYPAIR)
+ * master KeySource 가 이를 제공하지 않은 경우에 던진다.
+ */
+export declare class SignKeyBindUnsupportedError extends BaseError {
+    name: string;
+    keySourceType: string;
+    constructor(keySourceType: string);
+}

package/dist/errors/base.d.cts

@@ -0,0 +1,13 @@
+export type BaseErrorOptions = {
+    cause?: unknown;
+    details?: string;
+    metaMessages?: string[];
+};
+export declare class BaseError extends Error {
+    name: string;
+    shortMessage: string;
+    metaMessages: string[];
+    details?: string;
+    cause?: unknown;
+    constructor(shortMessage: string, options?: BaseErrorOptions);
+}

package/dist/errors/index.d.cts

@@ -1,4 +1,4 @@
-export * from './base.mjs';
-export * from './rpc.mjs';
-export * from './transport.mjs';
-export * from './account.mjs';
+export * from './base.cjs';
+export * from './rpc.cjs';
+export * from './transport.cjs';
+export * from './account.cjs';

package/dist/errors/rpc.d.cts

@@ -0,0 +1,21 @@
+import { BaseError, type BaseErrorOptions } from './base.cjs';
+export type RpcErrorOptions = BaseErrorOptions & {
+    method?: string;
+    params?: readonly unknown[];
+};
+/** 요청을 전송하기 전에 로컬에서 검증을 통과하지 못한 경우. */
+export declare class RpcRequestError extends BaseError {
+    name: string;
+    method?: string;
+    params?: readonly unknown[];
+    constructor(shortMessage: string, options?: RpcErrorOptions);
+}
+/** 노드가 JSON-RPC error envelope 를 반환한 경우. */
+export declare class RpcResponseError extends BaseError {
+    name: string;
+    code: number | string;
+    method?: string;
+    constructor(shortMessage: string, options: RpcErrorOptions & {
+        code: number | string;
+    });
+}