@locuschain/lib 0.1.31 → 0.1.32

package/dist/types/index.d.mts

@@ -0,0 +1,11 @@
+export * from '../autogen/locus-tx.mjs';
+export * from '../autogen/types/tx/index.mjs';
+export * from '../autogen/types/common/index.mjs';
+export * from '../autogen/types/rpc/index.mjs';
+export * from './primitives.mjs';
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type UnionToOptional<T> = {
+    [K in keyof T]: T[K];
+} & {
+    [K in Exclude<KeysOfUnion<T>, keyof T>]?: T extends any ? (K extends keyof T ? T[K] : undefined) : never;
+};

package/dist/types/primitives.d.mts

@@ -0,0 +1,5 @@
+export type Hex = `0x${string}`;
+/** 트랜잭션 해시. Locus 는 이 값을 일반 문자열로 emit 한다. */
+export type Hash = string;
+/** Locus account/contract/token 주소 (Base32 인코딩). */
+export type Address = string;

package/dist/utils/index.amd.js

@@ -0,0 +1,323 @@
+define(['exports', '../chunks/address-class-Dp7aNQb2', '../chunks/wasm-DAQaaEGK', '../chunks/keystore-C0RhMFsU', '../chunks/lclib-CAHiuFux', 'lodash', '../chunks/base-B_kRRfsf', '../chunks/account-BSrvZ7S8', '../chunks/tslib.es6-D29rxPkW'], (function (exports, addressClass, wasm, keystore, lclib, _, base, account, tslib_es6) { 'use strict';
+
+    class TxValidator {
+        constructor() {
+            this.verifyTxParams = (rpcResult, params, options) => {
+                try {
+                    if (options.targetTxHash) {
+                        const genHash = JSON.parse(wasm.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 => wasm.compileCoreScript(code),
+                                txTransform: code => code
+                            }), () => this.checkComplexField(params, tx, {
+                                paramPath: 'scriptAccept',
+                                txPath: 'scriptAccept',
+                                paramTransform: code => wasm.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 = lclib.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.AddressClass.User;
+        }
+        return classByte;
+    };
+    const checkAddressType = (address) => {
+        try {
+            const hex = wasm.convertAddressToHex(address);
+            const classByte = getClassByte(hex);
+            // console.log('>>>>>>>>>>>', classByte)
+            const key = Object.keys(addressClass.AddressClass).find(k => classByte === addressClass.AddressClass[k]);
+            if (!key)
+                return -1;
+            return addressClass.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.AddressClass.User || addressType === addressClass.AddressClass.Synthetic || addressClass.AddressClass.VmEngine;
+    const isContract = (addressType) => addressType === addressClass.AddressClass.Contract;
+    const isToken = (addressType) => addressType === addressClass.AddressClass.UserToken ||
+        addressType === addressClass.AddressClass.ContractToken ||
+        addressType === addressClass.AddressClass.AssetToken ||
+        addressType === addressClass.AddressClass.AssetNFT;
+    const isSystemToken = (addressType) => addressType === addressClass.AddressClass.UserToken || addressType === addressClass.AddressClass.ContractToken;
+
+    exports.calculateTxLinkHash = wasm.calculateTxLinkHash;
+    exports.compileCoreScript = wasm.compileCoreScript;
+    exports.convertAddressToData = wasm.convertAddressToData;
+    exports.convertAddressToHex = wasm.convertAddressToHex;
+    exports.convertBase32ToData = wasm.convertBase32ToData;
+    exports.convertBase32ToHex = wasm.convertBase32ToHex;
+    exports.convertCurrency = wasm.convertCurrency;
+    exports.convertDataTo = wasm.convertDataTo;
+    exports.convertDataToAddress = wasm.convertDataToAddress;
+    exports.convertDataToBase32 = wasm.convertDataToBase32;
+    exports.convertDataToHex = wasm.convertDataToHex;
+    exports.convertDataToString = wasm.convertDataToString;
+    exports.convertHexToAddress = wasm.convertHexToAddress;
+    exports.convertHexToBase32 = wasm.convertHexToBase32;
+    exports.convertHexToData = wasm.convertHexToData;
+    exports.convertStringToData = wasm.convertStringToData;
+    exports.convertToData = wasm.convertToData;
+    exports.createAccountAndKeystore = wasm.createAccountAndKeystore;
+    exports.createMasterKeystore = wasm.createMasterKeystore;
+    exports.createNormalKey = wasm.createNormalKey;
+    exports.createNormalKeystore = wasm.createNormalKeystore;
+    exports.decodeTxs = wasm.decodeTxs;
+    exports.deriveKeysFromMnemonic = wasm.deriveKeysFromMnemonic;
+    exports.deriveKeysFromMnemonicAndPath = wasm.deriveKeysFromMnemonicAndPath;
+    exports.disCompileCoreScript = wasm.disCompileCoreScript;
+    exports.encodeTxCurrency = wasm.encodeTxCurrency;
+    exports.encodeTxNumber = wasm.encodeTxNumber;
+    exports.generateMnemonic = wasm.generateMnemonic;
+    exports.generateMnemonicBySeed = wasm.generateMnemonicBySeed;
+    exports.getDefFromCoreScript = wasm.getDefFromCoreScript;
+    exports.getHomeShard = wasm.getHomeShard;
+    exports.getLibraryVersions = wasm.getLibraryVersions;
+    exports.gzipAndEncode = wasm.gzipAndEncode;
+    exports.hash = wasm.hash;
+    exports.isGrantConsumingTx = wasm.isGrantConsumingTx;
+    exports.loadMasterKeystore = wasm.loadMasterKeystore;
+    exports.loadNormalKeystore = wasm.loadNormalKeystore;
+    exports.makeCurrency = wasm.makeCurrency;
+    exports.sign = wasm.sign;
+    exports.signByMasterKey = wasm.signByMasterKey;
+    exports.signKeyBind = wasm.signKeyBind;
+    exports.testCoreScript = wasm.testCoreScript;
+    exports.verify = wasm.verify;
+    exports.verifyByMasterKey = wasm.verifyByMasterKey;
+    exports.verifyMerkleProof = wasm.verifyMerkleProof;
+    exports.verifyTx = wasm.verifyTx;
+    exports.createKeystoreBundle = keystore.createKeystoreBundle;
+    exports.splitKeystoreBundle = keystore.splitKeystoreBundle;
+    exports.unlockKeystoreBundle = keystore.unlockKeystoreBundle;
+    exports.unlockMasterKeystore = keystore.unlockMasterKeystore;
+    exports.unlockNormalKeystore = keystore.unlockNormalKeystore;
+    exports.checkAddressType = checkAddressType;
+    exports.isAccount = isAccount;
+    exports.isContract = isContract;
+    exports.isSystemToken = isSystemToken;
+    exports.isToken = isToken;
+    exports.loadLocusWasm = loadLocusWasm;
+    exports.txValidator = txValidator;
+    exports.verifyTxParams = verifyTxParams;
+
+}));