postchain-client 1.13.0 → 1.14.0

package/built/cjs/index.js

@@ -4,8 +4,9 @@ var require$$0$1 = require('buffer');
 var bn_js = require('bn.js');
 var crypto = require('crypto');
 var secp256k1 = require('secp256k1');
-var _ = require('lodash');
+var cloneDeep = require('lodash/cloneDeep');
 var events = require('events');
+var zod = require('zod');
 
 function _interopNamespaceDefault(e) {
 	var n = Object.create(null);
@@ -1957,7 +1958,7 @@ const logLevelMap = {
     [LogLevel.Warning]: 1,
     [LogLevel.Info]: 2,
     [LogLevel.Debug]: 3,
-    [LogLevel.Error]: 4,
+    [LogLevel.Error]: 0,
     [LogLevel.Disabled]: -1,
 };
 const DEFAULT_LOG_LEVEL = logLevelMap[LogLevel.Warning];
@@ -2180,7 +2181,7 @@ class UnexpectedResponseError extends Error {
 }
 class InvalidTxRidException extends Error {
     constructor(txRID) {
-        super(`expected length 32 of txRID, but got ${txRID.length}`);
+        super(`expected length 32 of txRID, but got ${txRID && txRID.length}`);
     }
 }
 class SerializedTransactionFormatException extends Error {
@@ -2379,14 +2380,14 @@ class MissingPubKeyError extends Error {
         super(`No public key was provided`);
     }
 }
-class MissingBlockchainError extends Error {
+class MissingBlockchainIdentifierError extends Error {
     constructor() {
-        super(`No target blockchain was provided`);
+        super(`No blockchain identifier was provided. Include either a blockchainRid (string) or a blockchainIid (number).`);
     }
 }
 class MissingNodeUrlError extends Error {
     constructor() {
-        super(`No node url or directory node url was provided`);
+        super(`No node url or directory node url was provided. Include either a nodeUrl (string) or a directory node url (number).`);
     }
 }
 class BlockchainUrlUndefinedException extends Error {
@@ -2540,6 +2541,193 @@ exports.ResponseStatus = void 0;
     ResponseStatus["Waiting"] = "waiting";
 })(exports.ResponseStatus || (exports.ResponseStatus = {}));
 
+const WRONG_STRING_LENGTH = "wrong string length";
+const BlockIdentifierSchema = zod.z.union([
+    zod.z
+        .string()
+        .refine((val) => /^[0-9a-fA-F]{64}$/.test(val), WRONG_STRING_LENGTH),
+    zod.z.number(),
+]);
+const isBlockIdentifierValid = (blockIdentifier, options) => {
+    const ctx = BlockIdentifierSchema.safeParse(blockIdentifier);
+    const { success } = ctx;
+    const hasError = "error" in ctx;
+    const { throwOnError = false } = options || {};
+    if (!hasError) {
+        return { success };
+    }
+    const { error } = ctx;
+    const isInvalidInputType = error.issues.some(({ code }) => code === "invalid_union");
+    const isInvalidStringLength = error.issues.some(({ message }) => message === WRONG_STRING_LENGTH);
+    const message = (() => {
+        if (isInvalidInputType) {
+            return `Invalid "blockIdentifier" type. Expected string or number, but received ${typeof blockIdentifier}.`;
+        }
+        if (isInvalidStringLength) {
+            return "Parameter 'blockIdentifier' does not have the correct format (64-character hexadecimal string).";
+        }
+        return error.issues.map((issue) => issue.message).join(", ");
+    })();
+    if (throwOnError) {
+        throw new Error(message);
+    }
+    return {
+        success,
+        error,
+        message: error.issues.map((issue) => issue.message).join(", "),
+    };
+};
+
+const IdentifierSchema = zod.z.union([
+    zod.z.object({
+        blockchainRid: zod.z.undefined(),
+        blockchainIid: zod.z.number(),
+    }),
+    zod.z.object({
+        blockchainRid: zod.z.string(),
+        blockchainIid: zod.z.undefined(),
+    }),
+]);
+const NodeUrlSchema = zod.z.union([
+    zod.z.object({
+        nodeUrlPool: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]),
+        directoryNodeUrlPool: zod.z.undefined(),
+    }),
+    zod.z.object({
+        nodeUrlPool: zod.z.undefined(),
+        directoryNodeUrlPool: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]),
+    }),
+]);
+const RestNetworkSettingsSchema = zod.z.object({
+    statusPollingInterval: zod.z.number().optional(),
+    statusPollingCount: zod.z.number().optional(),
+    failOverConfig: zod.z
+        .object({
+        strategy: zod.z.nativeEnum(exports.FailoverStrategy).optional(),
+        attemptsPerEndpoint: zod.z.number().optional(),
+        attemptInterval: zod.z.number().optional(),
+        unreachableDuration: zod.z.number().optional(),
+    })
+        .optional(),
+});
+const validateBlockChainIdentifier = (networkSettings, options) => {
+    const { throwOnError = false } = options || {};
+    const identifierValidationContext = IdentifierSchema.safeParse(networkSettings);
+    if ("error" in identifierValidationContext) {
+        const missingBlockchainIdentifierError = new MissingBlockchainIdentifierError();
+        if (throwOnError) {
+            throw missingBlockchainIdentifierError;
+        }
+        return {
+            success: identifierValidationContext.success,
+            error: identifierValidationContext.error,
+            message: missingBlockchainIdentifierError.message,
+        };
+    }
+    return { success: true };
+};
+const validateNodeUrl = (networkSettings, options) => {
+    const { throwOnError = false } = options || {};
+    const nodeUrlValidationContext = NodeUrlSchema.safeParse(networkSettings);
+    if ("error" in nodeUrlValidationContext) {
+        const missingNodeUrlError = new MissingNodeUrlError();
+        if (throwOnError) {
+            throw missingNodeUrlError;
+        }
+        return {
+            success: nodeUrlValidationContext.success,
+            error: nodeUrlValidationContext.error,
+            message: missingNodeUrlError.message,
+        };
+    }
+    return { success: true };
+};
+const validateRestNetworkSettings = (networkSettings, options) => {
+    const { throwOnError = false } = options || {};
+    const restNetworkSettingsValidationContext = RestNetworkSettingsSchema.safeParse(networkSettings);
+    if ("error" in restNetworkSettingsValidationContext) {
+        const { error: { issues }, } = restNetworkSettingsValidationContext;
+        const errorMessage = issues
+            .map(({ message, path }) => `${path[0]}: ${message}`)
+            .join(", ");
+        if (throwOnError) {
+            throw new Error(errorMessage);
+        }
+        return {
+            success: restNetworkSettingsValidationContext.success,
+            error: restNetworkSettingsValidationContext.error,
+            message: errorMessage,
+        };
+    }
+    return { success: true };
+};
+const isNetworkSettingValid = (networkSettings, options) => {
+    const identifierValidationContext = validateBlockChainIdentifier(networkSettings, options);
+    if ("error" in identifierValidationContext) {
+        return identifierValidationContext;
+    }
+    const nodeUrlValidationContext = validateNodeUrl(networkSettings, options);
+    if ("error" in nodeUrlValidationContext) {
+        return nodeUrlValidationContext;
+    }
+    const restNetworkSettingsValidationContext = validateRestNetworkSettings(networkSettings, options);
+    if ("error" in restNetworkSettingsValidationContext) {
+        return restNetworkSettingsValidationContext;
+    }
+    return { success: true };
+};
+
+const BufferSchema = zod.z.instanceof(Buffer);
+
+const KeyPairSchema = zod.z.object({
+    privKey: BufferSchema,
+    pubKey: BufferSchema,
+});
+const SignatureProviderSchema = zod.z.object({
+    pubKey: BufferSchema,
+    sign: zod.z.function().args(BufferSchema).returns(zod.z.promise(BufferSchema)),
+});
+const SignMethodSchema = zod.z.union([
+    KeyPairSchema,
+    SignatureProviderSchema,
+]);
+const isSignMethodValid = (signMethod, options) => {
+    const signMethodValidationCtx = SignMethodSchema.safeParse(signMethod);
+    const { throwOnError = false } = options || {};
+    const hasError = "error" in signMethodValidationCtx;
+    if (!hasError) {
+        return { success: true };
+    }
+    const message = "Invalid sign method";
+    if (throwOnError) {
+        throw new Error(message);
+    }
+    return {
+        success: false,
+        error: signMethodValidationCtx.error,
+        message,
+    };
+};
+
+const TxRidSchema = BufferSchema.refine((x) => x.length === 32, "Rid must be 32 bytes long");
+const isTxRidValid = (rid, options) => {
+    const TxRidValidationContext = TxRidSchema.safeParse(rid);
+    const { throwOnError = false } = options || {};
+    const hasError = "error" in TxRidValidationContext;
+    if (!hasError) {
+        return { success: true };
+    }
+    const validationError = new InvalidTxRidException(rid);
+    if (throwOnError) {
+        throw validationError;
+    }
+    return {
+        success: false,
+        error: TxRidValidationContext.error,
+        message: validationError.message,
+    };
+};
+
 var __awaiter$7 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -2551,6 +2739,7 @@ var __awaiter$7 = (undefined && undefined.__awaiter) || function (thisArg, _argu
 };
 function createClient(settings) {
     return __awaiter$7(this, void 0, void 0, function* () {
+        isNetworkSettingValid(settings, { throwOnError: true });
         return {
             config: yield getClientConfigFromSettings(settings),
             query(nameOrQueryObject, args, callback) {
@@ -2658,6 +2847,7 @@ function createClient(settings) {
                 return promiEvent;
             },
             signAndSendUniqueTransaction(transactionOrOperation, signMethod, doStatusPolling = true, callback = undefined) {
+                isSignMethodValid(signMethod, { throwOnError: true });
                 const promiEvent = new Web3PromiEvent((resolve, reject) => {
                     const transaction = "name" in transactionOrOperation
                         ? {
@@ -2687,11 +2877,12 @@ function createClient(settings) {
             },
             getTransaction(transactionRid, callback) {
                 return __awaiter$7(this, void 0, void 0, function* () {
-                    if (!validTxRid(transactionRid)) {
-                        if (typeof callback === "function") {
-                            callback(new InvalidTxRidException(transactionRid), null);
-                        }
-                        throw new InvalidTxRidException(transactionRid);
+                    try {
+                        isTxRidValid(transactionRid, { throwOnError: true });
+                    }
+                    catch (error) {
+                        callback === null || callback === void 0 ? void 0 : callback(error, null);
+                        throw error;
                     }
                     const { error, statusCode, rspBody } = yield requestWithRetry(Method.GET, `tx/${this.config.blockchainRid}/${transactionRid.toString("hex")}`, this.config);
                     return new Promise((resolve, reject) => {
@@ -2701,11 +2892,11 @@ function createClient(settings) {
             },
             getTransactionStatus(transactionRid, callback) {
                 return __awaiter$7(this, void 0, void 0, function* () {
-                    if (!validTxRid(transactionRid)) {
-                        const error = new InvalidTxRidException(transactionRid);
-                        if (typeof callback === "function") {
-                            callback(error, null);
-                        }
+                    try {
+                        isTxRidValid(transactionRid, { throwOnError: true });
+                    }
+                    catch (error) {
+                        callback === null || callback === void 0 ? void 0 : callback(error, null);
                         throw error;
                     }
                     const { error, statusCode, rspBody } = yield requestWithRetry(Method.GET, `tx/${this.config.blockchainRid}/${transactionRid.toString("hex")}/status`, this.config);
@@ -2715,7 +2906,7 @@ function createClient(settings) {
                 });
             },
             addNop(transaction) {
-                const _transaction = _.cloneDeep(transaction);
+                const _transaction = cloneDeep(transaction);
                 const noOperation = {
                     name: "nop",
                     args: [crypto.randomBytes(32)],
@@ -2747,6 +2938,13 @@ function createClient(settings) {
             },
             getTransactionInfo(transactionRid, callback) {
                 return __awaiter$7(this, void 0, void 0, function* () {
+                    try {
+                        isTxRidValid(transactionRid, { throwOnError: true });
+                    }
+                    catch (error) {
+                        callback === null || callback === void 0 ? void 0 : callback(error, null);
+                        throw error;
+                    }
                     const { error, statusCode, rspBody, } = yield requestWithRetry(Method.GET, `transactions/${this.config.blockchainRid}/${toString(transactionRid)}`, this.config);
                     return new Promise((resolve, reject) => {
                         handleGetResponse(error, statusCode, statusCode === 200 ? formatTransactionInfoResponse(rspBody) : rspBody, callbackPromiseBuilder(reject, resolve, callback));
@@ -2763,14 +2961,7 @@ function createClient(settings) {
             },
             getBlockInfo(blockIdentifier, txs = false, callback) {
                 return __awaiter$7(this, void 0, void 0, function* () {
-                    if (typeof blockIdentifier !== "string" &&
-                        typeof blockIdentifier !== "number") {
-                        throw new TypeError(`Invalid "blockIdentifier" type. Expected string or number, but received ${typeof blockIdentifier}.`);
-                    }
-                    else if (typeof blockIdentifier === "string" &&
-                        !/^[0-9a-fA-F]{64}$/.test(blockIdentifier)) {
-                        throw new TypeError("Parameter 'blockIdentifier' does not have the correct format (64-character hexadecimal string).");
-                    }
+                    isBlockIdentifierValid(blockIdentifier, { throwOnError: true });
                     const queryString = typeof blockIdentifier === "string"
                         ? blockIdentifier
                         : `height/${blockIdentifier}`;
@@ -2837,40 +3028,40 @@ function createClient(settings) {
              */
             getConfirmationProof: function (txRid, callback) {
                 return __awaiter$7(this, void 0, void 0, function* () {
-                    if (!validTxRid(txRid)) {
-                        if (callback) {
-                            callback(new InvalidTxRidException(txRid), null);
-                        }
-                        throw new InvalidTxRidException(txRid);
+                    try {
+                        isTxRidValid(txRid, { throwOnError: true });
                     }
-                    else {
-                        const { error, statusCode, rspBody } = yield requestWithRetry(Method.GET, `tx/${this.config.blockchainRid}/${txRid.toString("hex")}/confirmationProof`, this.config);
-                        const confirmationProof = {
-                            hash: undefined,
-                            blockHeader: undefined,
-                            witness: undefined,
-                            merkleProofTree: "",
-                            txIndex: 0,
-                        };
-                        if (statusCode === 200) {
-                            try {
-                                const decodedProof = decodeValue(toBuffer(rspBody.proof));
-                                confirmationProof.hash = decodedProof.hash;
-                                confirmationProof.blockHeader = decodedProof.blockHeader;
-                                confirmationProof.witness = decodedProof.witness;
-                                confirmationProof.merkleProofTree = decodedProof.merkleProofTree;
-                            }
-                            catch (decodeError) {
-                                if (callback) {
-                                    callback(decodeError, null);
-                                }
-                                throw decodeError;
+                    catch (error) {
+                        callback === null || callback === void 0 ? void 0 : callback(error, null);
+                        throw error;
+                    }
+                    const { error, statusCode, rspBody } = yield requestWithRetry(Method.GET, `tx/${this.config.blockchainRid}/${txRid.toString("hex")}/confirmationProof`, this.config);
+                    const confirmationProof = {
+                        hash: undefined,
+                        blockHeader: undefined,
+                        witness: undefined,
+                        merkleProofTree: "",
+                        txIndex: 0,
+                    };
+                    if (statusCode === 200) {
+                        try {
+                            const decodedProof = decodeValue(toBuffer(rspBody.proof));
+                            confirmationProof.txIndex = decodedProof.txIndex;
+                            confirmationProof.hash = decodedProof.hash;
+                            confirmationProof.blockHeader = decodedProof.blockHeader;
+                            confirmationProof.witness = decodedProof.witness;
+                            confirmationProof.merkleProofTree = decodedProof.merkleProofTree;
+                        }
+                        catch (decodeError) {
+                            if (callback) {
+                                callback(decodeError, null);
                             }
+                            throw decodeError;
                         }
-                        return new Promise((resolve, reject) => {
-                            handleGetResponse(error, statusCode, statusCode === 200 ? confirmationProof : rspBody, callbackPromiseBuilder(reject, resolve, callback));
-                        });
                     }
+                    return new Promise((resolve, reject) => {
+                        handleGetResponse(error, statusCode, statusCode === 200 ? confirmationProof : rspBody, callbackPromiseBuilder(reject, resolve, callback));
+                    });
                 });
             },
         };
@@ -2891,13 +3082,6 @@ require("web3-core-promievent");
 function getClientConfigFromSettings(settings) {
     var _a, _b, _c, _d;
     return __awaiter$6(this, void 0, void 0, function* () {
-        if (!settings.nodeUrlPool && !settings.directoryNodeUrlPool) {
-            throw new MissingNodeUrlError();
-        }
-        if (!settings.blockchainRid &&
-            typeof settings.blockchainIid === "undefined") {
-            throw new MissingBlockchainError();
-        }
         const nodeUrlPoolToUse = yield getNodeUrlsFromSettings(settings);
         const endpointPool = createEndpointObjects(nodeUrlPoolToUse);
         const blockchainRidToUse = settings.blockchainRid ||
@@ -2917,21 +3101,13 @@ function getClientConfigFromSettings(settings) {
         };
     });
 }
-function validTxRid(txRID) {
-    if (txRID.length != 32) {
-        const error$1 = new InvalidTxRidException(txRID);
-        error(error$1.toString());
-        return false;
-    }
-    return true;
-}
 function nodeDiscovery(directoryEndpointPool, failOverConfig, blockchainRid, blockchainIid) {
     return __awaiter$6(this, void 0, void 0, function* () {
         if (directoryEndpointPool.length === 0) {
             throw new DirectoryNodeUrlPoolException();
         }
         if (!(blockchainRid || blockchainIid != undefined)) {
-            throw new MissingBlockchainError();
+            throw new MissingBlockchainIdentifierError();
         }
         const directoryIid = 0;
         const directoryBRID = yield getBlockchainRidFromIid(directoryEndpointPool, directoryIid, failOverConfig);
@@ -2939,7 +3115,7 @@ function nodeDiscovery(directoryEndpointPool, failOverConfig, blockchainRid, blo
             (yield getBlockchainRidFromIid(directoryEndpointPool, blockchainIid, failOverConfig));
         const queryObject = {
             name: "cm_get_blockchain_api_urls",
-            args: { blockchain_rid: blockchainRidToUse },
+            args: { blockchain_rid: toBuffer(blockchainRidToUse) },
         };
         const D1Client = yield createClient({
             nodeUrlPool: getUrlsFromEndpoints(directoryEndpointPool),
@@ -3963,7 +4139,7 @@ exports.InvalidBlockchainRIDException = InvalidBlockchainRIDException;
 exports.InvalidTransactionFormatException = InvalidTransactionFormatException;
 exports.InvalidTxRidException = InvalidTxRidException;
 exports.LostMessageError = LostMessageError;
-exports.MissingBlockchainError = MissingBlockchainError;
+exports.MissingBlockchainIdentifierError = MissingBlockchainIdentifierError;
 exports.MissingGtxException = MissingGtxException;
 exports.MissingNodeUrlError = MissingNodeUrlError;
 exports.MissingPrivKeyArgumentException = MissingPrivKeyArgumentException;