@locuschain/lib 0.1.31 → 0.1.32

package/dist/utils/index.esm.js

@@ -0,0 +1,271 @@
+import { A as AddressClass } from '../chunks/address-class-CHAZYhdZ.js';
+import { T as verifyTx, d as compileCoreScript, f as convertAddressToHex } from '../chunks/wasm-3LmqFB_i.js';
+export { b as calculateTxLinkHash, e as convertAddressToData, g as convertBase32ToData, h as convertBase32ToHex, i as convertCurrency, j as convertDataTo, k as convertDataToAddress, m as convertDataToBase32, n as convertDataToHex, o as convertDataToString, p as convertHexToAddress, q as convertHexToBase32, r as convertHexToData, s as convertStringToData, t as convertToData, c as createAccountAndKeystore, u as createMasterKeystore, v as createNormalKey, w as createNormalKeystore, x as decodeTxs, y as deriveKeysFromMnemonic, z as deriveKeysFromMnemonicAndPath, A as disCompileCoreScript, B as encodeTxCurrency, C as encodeTxNumber, D as generateMnemonic, E as generateMnemonicBySeed, F as getDefFromCoreScript, G as getHomeShard, H as getLibraryVersions, I as gzipAndEncode, J as hash, K as isGrantConsumingTx, l as loadMasterKeystore, a as loadNormalKeystore, L as makeCurrency, M as sign, N as signByMasterKey, O as signKeyBind, P as testCoreScript, Q as verify, R as verifyByMasterKey, S as verifyMerkleProof } from '../chunks/wasm-3LmqFB_i.js';
+export { c as createKeystoreBundle, s as splitKeystoreBundle, u as unlockKeystoreBundle, a as unlockMasterKeystore, b as unlockNormalKeystore } from '../chunks/keystore-BJ3vekCS.js';
+import { l as load } from '../chunks/lclib-DZydGzkN.js';
+import _ from 'lodash';
+import '../chunks/base-BQXfRsuw.js';
+import '../chunks/account-FZT9LH_s.js';
+import '../chunks/tslib.es6-WQS2tr1v.js';
+
+class TxValidator {
+    constructor() {
+        this.verifyTxParams = (rpcResult, params, options) => {
+            try {
+                if (options.targetTxHash) {
+                    const genHash = JSON.parse(verifyTx(JSON.stringify(rpcResult.tx))).hash;
+                    if (options.targetTxHash !== genHash) {
+                        console.warn(`[TxnIntegrityChecker] Tx hash not matched.`, options.targetTxHash, '!==', genHash);
+                        return { result: false, reason: 'tx verify fail' };
+                    }
+                }
+                const checks = [];
+                const tx = rpcResult.tx;
+                switch (tx.type) {
+                    case 'TX_TRANSFER_COIN':
+                    case 'TX_TRANSFER_COIN_FEE':
+                        checks.push(() => this.checkFields(params, tx, { to: 'target', amount: 'amount' }));
+                        break;
+                    case 'TX_TRANSFER_COIN_EXPRESS':
+                        checks.push(() => this.checkFields(params, tx, {
+                            to: 'target',
+                            amount: 'amount',
+                            'source.owner': 'source.addr',
+                            'source.height': 'source.index'
+                        }));
+                        break;
+                    case 'TX_CREATE_TOKEN':
+                    case 'TX_CREATE_TOKEN_FEE':
+                        checks.push(() => this.checkFields(params, tx, { tokenBalance: 'tokenBalance.v' }));
+                        break;
+                    case 'TX_TRANSFER_TOKEN':
+                    case 'TX_TRANSFER_TOKEN_FEE':
+                        checks.push(() => this.checkFields(params, tx, { to: 'target', amount: 'amount' }), () => this.checkComplexField(params, tx, {
+                            paramPath: 'tokenAmounts',
+                            txPath: 'tokens',
+                            paramTransform: tokens => (tokens !== null && tokens !== void 0 ? tokens : []).map((d) => ({ t: d.tokenId, a: d.amountToken })),
+                            txTransform: tokens => (tokens !== null && tokens !== void 0 ? tokens : []).map((d) => ({ t: d.t, a: d.a }))
+                        }));
+                        break;
+                    case 'TX_CREATE_ASSETOBJECT':
+                    case 'TX_CREATE_ASSETOBJECT_FEE':
+                        checks.push(() => this.checkFields(params, tx, Object.assign({
+                            assetType: 'object.type',
+                            metaData: 'object.metaData'
+                        }, (params.amount === '0' ? {} : { amount: 'object.amount' })))
+                        // TODO: params.operator !== tx.Object.Operator  ("" !== "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHF3E")
+                        );
+                        break;
+                    case 'TX_TRANSFER_ASSETOBJECT':
+                    case 'TX_TRANSFER_ASSETOBJECT_FEE':
+                        checks.push(() => this.checkFields(params, tx, { to: 'target' }), () => this.checkFields(params, tx, {
+                            to: 'target',
+                            amount: 'assetObjects.assetObjects[0].targetObject.amount',
+                            assetId: 'assetObjects.assetObjects[0].targetObject.assetId'
+                        }));
+                        break;
+                    case 'TX_CREATE_CONTRACT':
+                    case 'TX_CREATE_CONTRACT_FEE':
+                        checks.push(() => this.checkFields(params, tx, {
+                            code: 'code',
+                            amount: 'amount',
+                            fuelLimit: 'fuelLimit',
+                            sysId: 'sysId',
+                            until: 'until'
+                        }, {
+                            contractAccount: 'target'
+                        }), () => this.checkComplexField(params, tx, {
+                            paramPath: 'tokenAmounts',
+                            txPath: 'tokens',
+                            paramTransform: tokens => (tokens !== null && tokens !== void 0 ? tokens : []).map((d) => ({ t: d.tokenId, a: d.amountToken })),
+                            txTransform: tokens => (tokens !== null && tokens !== void 0 ? tokens : []).map((d) => ({ t: d.t, a: d.a }))
+                        }));
+                        break;
+                    case 'TX_CALL_CONTRACT':
+                    case 'TX_CALL_CONTRACT_FEE':
+                        checks.push(() => this.checkFields(params, tx, {
+                            contractAccount: 'target',
+                            amount: 'amount',
+                            fuelLimit: 'fuelLimit',
+                            func: 'func',
+                            argData: 'argData'
+                        }), () => this.checkComplexField(params, tx, {
+                            paramPath: 'tokenAmounts',
+                            txPath: 'tokens',
+                            paramTransform: tokens => (tokens !== null && tokens !== void 0 ? tokens : []).map((d) => ({ t: d.tokenId, a: d.amountToken })),
+                            txTransform: tokens => (tokens !== null && tokens !== void 0 ? tokens : []).map((d) => ({ t: d.t, a: d.a }))
+                        })
+                        // TODO: tx.AssetObjects 는 아직 rpc가 만들어지지 않아서 확인을 하지 못했다
+                        );
+                        break;
+                    case 'TX_POST_DATA':
+                    case 'TX_POST_DATA_FEE':
+                        checks.push(() => this.checkFields(params, tx, { data: 'data', label: 'label' }));
+                        break;
+                    case 'TX_OPEN_ACCOUNT':
+                        checks.push(() => this.checkFields(params, tx, { account: 'addr', pk: 'key' }, {
+                            sender: 'refLink.addr',
+                            index: 'refLink.index'
+                        }));
+                        break;
+                    case 'TX_PROVIDE_SCRIPT':
+                        checks.push(() => this.checkFields(params, tx, {
+                            target: 'target',
+                            targetAfterTimeLock: 'targetAfterTimeLock',
+                            amount: 'amount'
+                        }), () => this.checkComplexField(params, tx, {
+                            paramPath: 'scriptProvide',
+                            txPath: 'scriptProvide',
+                            paramTransform: code => compileCoreScript(code),
+                            txTransform: code => code
+                        }), () => this.checkComplexField(params, tx, {
+                            paramPath: 'scriptAccept',
+                            txPath: 'scriptAccept',
+                            paramTransform: code => compileCoreScript(code),
+                            txTransform: code => code
+                        }), () => this.checkComplexField(params, tx, {
+                            paramPath: 'args',
+                            txPath: 'args',
+                            paramTransform: args => args !== null && args !== void 0 ? args : [],
+                            txTransform: args => args !== null && args !== void 0 ? args : []
+                        }));
+                        break;
+                    case 'TX_ACCEPT_SCRIPT':
+                        checks.push(() => this.checkFields(params, tx, { provider: 'refLink.addr', index: 'refLink.index' }), () => this.checkComplexField(params, tx, {
+                            paramPath: 'args',
+                            txPath: 'args',
+                            paramTransform: args => args !== null && args !== void 0 ? args : [],
+                            txTransform: args => args !== null && args !== void 0 ? args : []
+                        }) // 배열 비교라서..
+                        );
+                        break;
+                    case 'TX_CLOSE_ACCOUNT':
+                        checks.push(() => this.checkFields(params, tx, { to: 'target' }));
+                        break;
+                    case 'TX_BECOME_HOST':
+                    case 'TX_BECOME_GUEST':
+                        break;
+                    default:
+                        break;
+                }
+                for (const check of checks) {
+                    const result = check();
+                    if (result !== true)
+                        return result;
+                }
+                return { result: true, reason: 'success' };
+            }
+            catch (e) {
+                console.error(e);
+                return { result: false, reason: `tx verify fail. error: ${e.message}` };
+            }
+        };
+        /**
+         * params 객체와 tx 객체의 필드를 주어진 매핑에 따라 비교합니다.
+         * @param params 파라미터 객체.
+         * @param tx 검증할 트랜잭션 객체.
+         * @param mapping 키는 `params`의 속성 경로, 값은 `tx`의 속성 경로인 객체.
+         * @param optional mapping과 동일한 구조이나, `params` 값이 있을경우만 체크합니다. string은 빈문자열이 아닌 문자열, number는 0을 없다고 판단합니다
+         * @returns 모든 필드가 일치하면 `true`, 실패 시 `IntegrityCheckResult` 객체를 반환합니다.
+         */
+        this.checkFields = (params, tx, mapping, optional) => {
+            for (const paramKey in mapping) {
+                const txKey = mapping[paramKey];
+                const paramValue = this.getByPathIgnoreCase(params, paramKey);
+                const txValue = _.get(tx, txKey);
+                if (paramValue !== txValue) {
+                    return this.logAndFail(tx.type, paramKey, paramValue, txValue);
+                }
+            }
+            for (const paramKey in optional !== null && optional !== void 0 ? optional : {}) {
+                const txKey = optional[paramKey];
+                const paramValue = this.getByPathIgnoreCase(params, paramKey);
+                if (paramValue && paramValue !== '' && paramValue !== 0) {
+                    const txValue = _.get(tx, txKey);
+                    if (paramValue !== txValue) {
+                        return this.logAndFail(tx.type, paramKey, paramValue, txValue);
+                    }
+                }
+            }
+            return true;
+        };
+        this.checkComplexField = (params, tx, { paramPath, txPath, paramTransform, txTransform }) => {
+            const paramValue = paramTransform(this.getByPathIgnoreCase(params, paramPath));
+            const txValue = txTransform(_.get(tx, txPath));
+            if (!_.isEqual(paramValue, txValue)) {
+                return this.logAndFail(tx.type, paramPath, paramValue, txValue);
+            }
+            return true;
+        };
+    }
+    logAndFail(txType, field, expected, actual) {
+        console.warn(`[TxnIntegrityChecker] ${txType} ${field}:`, expected, actual);
+        return { result: false, reason: 'tx integrity check fail', field };
+    }
+    // 속성명의 대소문자를 무시하고 값을 구한다
+    getByPathIgnoreCase(obj, path) {
+        const keys = path.split('.');
+        let current = obj;
+        for (const key of keys) {
+            if (current === null || typeof current !== 'object')
+                return undefined;
+            const actualKey = Object.keys(current).find(k => k.toLowerCase() === key.toLowerCase());
+            if (actualKey === undefined)
+                return undefined;
+            current = current[actualKey];
+        }
+        return current;
+    }
+}
+
+/**
+ * Locus Chain WASM 4 개(Go lclib + AIMER/SMAUGT/HAETAE) 를 fetch 로 로드한다.
+ * 브라우저 / Node 양쪽 모두 동작.
+ */
+const loadLocusWasm = load;
+const txValidator = new TxValidator();
+const verifyTxParams = txValidator.verifyTxParams;
+const getClassByte = (hexstring) => {
+    // 0x 접두사 제거
+    const hex = hexstring.startsWith('0x') || hexstring.startsWith('0X')
+        ? hexstring.slice(2)
+        : hexstring;
+    // addressClassOffset = addressHashEnd - 1 이므로 해시의 마지막 바이트가 class byte
+    // (hex 문자 2개 = 1 byte)
+    const classByte = parseInt(hex.slice(-2), 16);
+    if (Number.isNaN(classByte)) {
+        throw new Error(`Invalid hex string: ${hexstring}`);
+    }
+    // 최상위 비트(0x80)가 세팅되어 있으면 User 클래스로 간주
+    if ((classByte & 0x80) !== 0) {
+        return AddressClass.User;
+    }
+    return classByte;
+};
+const checkAddressType = (address) => {
+    try {
+        const hex = convertAddressToHex(address);
+        const classByte = getClassByte(hex);
+        // console.log('>>>>>>>>>>>', classByte)
+        const key = Object.keys(AddressClass).find(k => classByte === AddressClass[k]);
+        if (!key)
+            return -1;
+        return AddressClass[key];
+        //   console.warn('unknown address type', hex);
+        //   // 참고!! ERC20 토큰은 주소로 알수 없음
+    }
+    catch (e) {
+        console.error(e + ' ' + address);
+        throw new Error('check error');
+    }
+    // return AddressType.UNKNOWN;
+};
+const isAccount = (addressType) => addressType === AddressClass.User || addressType === AddressClass.Synthetic || AddressClass.VmEngine;
+const isContract = (addressType) => addressType === AddressClass.Contract;
+const isToken = (addressType) => addressType === AddressClass.UserToken ||
+    addressType === AddressClass.ContractToken ||
+    addressType === AddressClass.AssetToken ||
+    addressType === AddressClass.AssetNFT;
+const isSystemToken = (addressType) => addressType === AddressClass.UserToken || addressType === AddressClass.ContractToken;
+
+export { checkAddressType, compileCoreScript, convertAddressToHex, isAccount, isContract, isSystemToken, isToken, loadLocusWasm, txValidator, verifyTx, verifyTxParams };

package/dist/utils/keystore.d.mts

@@ -0,0 +1,87 @@
+import type { Address } from '../types/primitives.mjs';
+/** `loadMasterKeystore` 가 반환하는 파싱된 master keystore payload. */
+export type MasterKeyInfo = {
+    address: Address;
+    mkeyAlgorithm: string;
+    msecretKey: string;
+    mpublicKey: string;
+};
+/** `loadNormalKeystore` 가 반환하는 파싱된 normal keystore payload. */
+export type NormalKeyInfo = {
+    address: Address;
+    nkeyAlgorithm: string;
+    nsecretKey: string;
+    npublicKey: string;
+    keyBind: unknown;
+};
+/** 평탄화된 키 자료 — `keysToAccount` 가 받는 형태. */
+export type UnlockedKeyPair = {
+    address: Address;
+    msk: string;
+    mpk: string;
+    nsk: string;
+    npk: string;
+};
+export type CreateKeystoreBundleArgs = {
+    passwordMaster: string;
+    passwordNormal: string;
+    /** 비어 있으면 WASM 헬퍼가 내부적으로 'FALCON+ED25519' 를 기본값으로 쓴다. */
+    algoMaster?: string;
+    /** 비어 있으면 WASM 헬퍼가 내부적으로 'ED25519' 를 기본값으로 쓴다. */
+    algoNormal?: string;
+};
+export type AccountKeystoreBundle = {
+    /** 원본 JSON array 문자열 — 영속화에 적합. */
+    raw: string;
+    /** master / normal 두 반쪽의 개별 JSON 문자열. */
+    masterKsJson: string;
+    normalKsJson: string;
+};
+/**
+ * 새 dual-key keystore 를 만들고 결과 JSON array 를 master / normal 두
+ * 반쪽으로 분리한다. 각 반쪽은 독립적으로 영속화한 뒤 unlockMasterKeystore
+ * / unlockNormalKeystore 로 다시 unlock 할 수 있다.
+ *
+ * WASM 의 `createAccountAndKeystore` 에 대한 얇은 래퍼다. `utils/index.mts`
+ * 가 raw WASM export 도 함께 re-export 하므로 충돌을 피하려고 이름을
+ * 새로 붙였다.
+ */
+export declare function createKeystoreBundle(args: CreateKeystoreBundleArgs): AccountKeystoreBundle;
+/**
+ * WASM `createAccountAndKeystore` 헬퍼가 반환한 `[master, normal]` keystore
+ * 배열을 두 JSON 문자열로 분리한다.
+ */
+export declare function splitKeystoreBundle(bundleJson: string): {
+    masterKsJson: string;
+    normalKsJson: string;
+};
+/**
+ * master keystore JSON 을 password 로 복호화한다.
+ *
+ * WASM 헬퍼가 emit 하는 lowercase-camelCase 필드 (`address`, `mkeyAlgorithm`,
+ * `msecretKey`, `mpublicKey`) 를 그대로 반환한다.
+ */
+export declare function unlockMasterKeystore(args: {
+    ksJson: string;
+    password: string;
+}): MasterKeyInfo;
+/**
+ * normal keystore JSON 을 password 로 복호화한다.
+ *
+ * WASM 헬퍼가 emit 하는 lowercase-camelCase 필드 (`address`, `nkeyAlgorithm`,
+ * `nsecretKey`, `npublicKey`, `keyBind`) 를 그대로 반환한다.
+ */
+export declare function unlockNormalKeystore(args: {
+    ksJson: string;
+    password: string;
+}): NormalKeyInfo;
+/**
+ * one-shot 헬퍼: 전체 `[master, normal]` keystore JSON 과 두 password 를
+ * 받아 `keysToAccount` 가 소비하는 평탄한 (address, msk, mpk, nsk, npk)
+ * tuple 을 반환한다.
+ */
+export declare function unlockKeystoreBundle(args: {
+    ksJsonBundle: string | AccountKeystoreBundle;
+    passwordMaster: string;
+    passwordNormal: string;
+}): UnlockedKeyPair;

package/dist/utils/lclib.d.mts

@@ -0,0 +1,2 @@
+export function load(opts?: {}): Promise<void>;
+export const namespace: string;

package/dist/utils/locus-wasm-bridge.d.mts

@@ -0,0 +1 @@
+export function loadCryptoWasm(opts?: {}): Promise<void>;

package/dist/utils/tx-validator.d.mts

@@ -0,0 +1,26 @@
+export type IntegrityCheckResult = {
+    result: boolean | string;
+    reason: string;
+    field?: string;
+    txHash?: string;
+};
+export declare class TxValidator {
+    verifyTxParams: (rpcResult: {
+        hash: string;
+        tx: any;
+    }, params: any, options: {
+        targetTxHash?: string | false;
+    }) => IntegrityCheckResult;
+    private logAndFail;
+    private getByPathIgnoreCase;
+    /**
+     * params 객체와 tx 객체의 필드를 주어진 매핑에 따라 비교합니다.
+     * @param params 파라미터 객체.
+     * @param tx 검증할 트랜잭션 객체.
+     * @param mapping 키는 `params`의 속성 경로, 값은 `tx`의 속성 경로인 객체.
+     * @param optional mapping과 동일한 구조이나, `params` 값이 있을경우만 체크합니다. string은 빈문자열이 아닌 문자열, number는 0을 없다고 판단합니다
+     * @returns 모든 필드가 일치하면 `true`, 실패 시 `IntegrityCheckResult` 객체를 반환합니다.
+     */
+    private checkFields;
+    private checkComplexField;
+}

package/dist/utils/types.d.mts

@@ -0,0 +1,15 @@
+export interface ParamTxData {
+    round: number;
+    height: number;
+    args: string[];
+}
+export interface MerkleProof {
+    Positions: number[];
+    Siblings: string;
+}
+export interface LibraryVersions {
+    LibraryVersion: number;
+    KeystoreVersion: number;
+    KeystoreVersionMin: number;
+    GoBuildVersion: string;
+}

package/dist/utils/wasm-fetch.d.mts

@@ -0,0 +1,6 @@
+/**
+ * .wasm 바이너리를 Uint8Array 로 가져온다.
+ * @param {URL | string} input
+ * @returns {Promise<Uint8Array>}
+ */
+export function fetchWasmBytes(input: URL | string): Promise<Uint8Array>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@locuschain/lib",
-  "version": "0.1.31",
+  "version": "0.1.32",
   "type": "module",
   "author": "bloomtechnology",
   "license": "MIT",