@firmachain/firma-js 0.2.32 → 0.2.35

package/dist/sdk/FirmaUtil.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __awaiter = (this && this.__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) {
@@ -35,6 +46,9 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSignAndBroadcastOption = exports.DefaultTxMisc = exports.FirmaUtil = void 0;
 var fs_1 = require("fs");
@@ -42,12 +56,19 @@ var tx_1 = require("cosmjs-types/cosmos/tx/v1beta1/tx");
 var TendermintQueryClient_1 = require("./firmachain/common/TendermintQueryClient");
 var encoding_1 = require("@cosmjs/encoding");
 var LedgerSigningStargateClient_1 = require("./firmachain/common/LedgerSigningStargateClient");
+var encoding_2 = require("@cosmjs/encoding");
+var crypto_1 = require("@cosmjs/crypto");
+var amino_1 = require("@cosmjs/amino");
+var signingaminostargateclient_1 = require("./firmachain/common/signingaminostargateclient");
+var proto_signing_1 = require("@cosmjs/proto-signing");
+var signingstargateclient_1 = require("./firmachain/common/signingstargateclient");
+var any_1 = require("./firmachain/google/protobuf/any");
+var long_1 = __importDefault(require("long"));
+var CommonTxClient_1 = require("./firmachain/common/CommonTxClient");
 var CryptoJS = require("crypto-js");
 var sha1 = require("crypto-js/sha1");
 var sha256 = require("crypto-js/sha256");
 var encHex = require("crypto-js/enc-hex");
-var signingaminostargateclient_1 = require("./firmachain/common/signingaminostargateclient");
-var proto_signing_1 = require("@cosmjs/proto-signing");
 var FirmaUtil = /** @class */ (function () {
     function FirmaUtil(firmaConfig) {
         FirmaUtil.config = firmaConfig;
@@ -89,22 +110,25 @@ var FirmaUtil = /** @class */ (function () {
         return Number.parseInt(newBig);
     };
     FirmaUtil.arrayBufferToBase64 = function (buffer) {
-        var binary = '';
+        return Buffer.from(buffer).toString("base64");
+        /*var binary = '';
         var bytes = new Uint8Array(buffer);
         var len = bytes.byteLength;
         for (var i = 0; i < len; i++) {
             binary += String.fromCharCode(bytes[i]);
         }
-        return btoa(binary);
+        return btoa(binary);*/
     };
     FirmaUtil.base64ToArrayBuffer = function (base64) {
-        var binary_string = atob(base64);
-        var len = binary_string.length;
-        var bytes = new Uint8Array(len);
-        for (var i = 0; i < len; i++) {
-            bytes[i] = binary_string.charCodeAt(i);
-        }
-        return bytes;
+        var buffer = Buffer.from(base64, "base64");
+        return new Uint8Array(buffer);
+        /*        var binary_string = atob(base64);
+                var len = binary_string.length;
+                var bytes = new Uint8Array(len);
+                for (var i = 0; i < len; i++) {
+                    bytes[i] = binary_string.charCodeAt(i);
+                }
+                return bytes;*/
     };
     FirmaUtil.getTokenStringFromUToken = function (uTokenAmount, decimal) {
         var fixedUTokenAmount = Math.floor(uTokenAmount);
@@ -201,7 +225,7 @@ var FirmaUtil = /** @class */ (function () {
                     case 0:
                         _a.trys.push([0, 2, , 3]);
                         encodedTx = Uint8Array.from(tx_1.TxRaw.encode(txRaw).finish());
-                        hexTx = "0x" + Buffer.from(encodedTx).toString("hex");
+                        hexTx = "0x".concat(Buffer.from(encodedTx).toString("hex"));
                         queryClient = new TendermintQueryClient_1.TendermintQueryClient(FirmaUtil.config.rpcAddress);
                         return [4 /*yield*/, queryClient.queryEstimateGas(hexTx)];
                     case 1:
@@ -225,7 +249,7 @@ var FirmaUtil = /** @class */ (function () {
                     case 0:
                         _a.trys.push([0, 2, , 3]);
                         encodedTx = Uint8Array.from(txRaw);
-                        hexTx = "0x" + Buffer.from(encodedTx).toString("hex");
+                        hexTx = "0x".concat(Buffer.from(encodedTx).toString("hex"));
                         console.log("hexTx:" + hexTx);
                         queryClient = new TendermintQueryClient_1.TendermintQueryClient(FirmaUtil.config.rpcAddress);
                         return [4 /*yield*/, queryClient.queryEstimateGas(hexTx)];
@@ -245,7 +269,7 @@ var FirmaUtil = /** @class */ (function () {
     FirmaUtil.printLog = function (log) {
         if (FirmaUtil.config.isShowLog === false)
             return;
-        console.log("[FirmaSDK] " + log);
+        console.log("[FirmaSDK] ".concat(log));
     };
     FirmaUtil.experimentalAdr36Sign = function (wallet, data) {
         return __awaiter(this, void 0, void 0, function () {
@@ -291,6 +315,113 @@ var FirmaUtil = /** @class */ (function () {
             });
         });
     };
+    FirmaUtil.recoverSigningAddress = function (signature, hash, recoveryIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var sig, extendedSig, recoveredPubKey, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (recoveryIndex > 3) {
+                            throw new Error('Invalid recovery index');
+                        }
+                        sig = crypto_1.Secp256k1Signature.fromFixedLength((0, encoding_2.fromBase64)(signature));
+                        extendedSig = new crypto_1.ExtendedSecp256k1Signature(sig.r(), sig.s(), recoveryIndex);
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, crypto_1.Secp256k1.recoverPubkey(extendedSig, hash)];
+                    case 2:
+                        recoveredPubKey = _b.sent();
+                        return [2 /*return*/, (0, amino_1.pubkeyToAddress)({
+                                type: 'tendermint/PubKeySecp256k1',
+                                value: (0, encoding_2.toBase64)(crypto_1.Secp256k1.compressPubkey(recoveredPubKey)),
+                            }, 'firma')];
+                    case 3:
+                        _a = _b.sent();
+                        return [2 /*return*/, null];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    FirmaUtil.verifySignature = function (address, signature, hash) {
+        return __awaiter(this, void 0, void 0, function () {
+            var i, recoveredAddress;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        i = 0;
+                        _a.label = 1;
+                    case 1:
+                        if (!(i < 4)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.recoverSigningAddress(signature, hash, i)];
+                    case 2:
+                        recoveredAddress = _a.sent();
+                        if (recoveredAddress === address) {
+                            return [2 /*return*/, true];
+                        }
+                        _a.label = 3;
+                    case 3:
+                        i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/, false];
+                }
+            });
+        });
+    };
+    FirmaUtil.verifyDirectSignature = function (address, signature, signDoc) {
+        var messageHash = (0, crypto_1.sha256)((0, proto_signing_1.makeSignBytes)(signDoc));
+        return this.verifySignature(address, signature, messageHash);
+    };
+    ;
+    FirmaUtil.parseSignDocValues = function (signDocString) {
+        return __assign(__assign({}, signDocString), { bodyBytes: (0, encoding_2.fromHex)(signDocString.bodyBytes), authInfoBytes: (0, encoding_2.fromHex)(signDocString.authInfoBytes), accountNumber: new long_1.default(signDocString.accountNumber) });
+    };
+    FirmaUtil.stringifySignDocValues = function (signDoc) {
+        return __assign(__assign({}, signDoc), { bodyBytes: (0, encoding_2.toHex)(signDoc.bodyBytes), authInfoBytes: (0, encoding_2.toHex)(signDoc.authInfoBytes), accountNumber: signDoc.accountNumber.toString(16) });
+    };
+    FirmaUtil.makeSignDoc = function (signerAddress, messages, txMisc) {
+        if (txMisc === void 0) { txMisc = exports.DefaultTxMisc; }
+        return __awaiter(this, void 0, void 0, function () {
+            var result, chainID, serverUrl, registry;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        result = FirmaUtil.getSignAndBroadcastOption(FirmaUtil.config.denom, txMisc);
+                        chainID = FirmaUtil.config.chainID;
+                        serverUrl = FirmaUtil.config.rpcAddress;
+                        registry = CommonTxClient_1.CommonTxClient.getRegistry();
+                        return [4 /*yield*/, signingstargateclient_1.SigningStargateClient.makeSignDocForSend(signerAddress, messages, result.fee, result.memo, serverUrl, chainID, registry)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    FirmaUtil.makeSignDocWithStringify = function (signerAddress, messages, txMisc) {
+        if (txMisc === void 0) { txMisc = exports.DefaultTxMisc; }
+        return __awaiter(this, void 0, void 0, function () {
+            var signDoc, stringSignDoc;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.makeSignDoc(signerAddress, messages, txMisc)];
+                    case 1:
+                        signDoc = _a.sent();
+                        stringSignDoc = this.stringifySignDocValues(signDoc);
+                        return [2 /*return*/, stringSignDoc];
+                }
+            });
+        });
+    };
+    FirmaUtil.getAnyData = function (registry, message) {
+        var anyData = any_1.Any.fromPartial({
+            typeUrl: message.typeUrl,
+            value: registry.encode(message)
+        });
+        return anyData;
+    };
+    FirmaUtil.getCommonTxClient = function (aliceWallet) {
+        return new CommonTxClient_1.CommonTxClient(aliceWallet, FirmaUtil.config.rpcAddress);
+    };
     FirmaUtil.FctDecimal = 6;
     return FirmaUtil;
 }());

package/dist/sdk/FirmaWalletService.js

@@ -92,7 +92,7 @@ var FirmaWalletService = /** @class */ (function () {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, LedgerWallet_1.signFromLedger(this.ledger, messages, option, registry)];
+                    case 0: return [4 /*yield*/, (0, LedgerWallet_1.signFromLedger)(this.ledger, messages, option, registry)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
@@ -123,7 +123,7 @@ var FirmaWalletService = /** @class */ (function () {
     };
     FirmaWalletService.getHdPath = function (hdPath, accountIndex) {
         try {
-            return [crypto_1.stringToPath(hdPath + accountIndex + "'/0/0")];
+            return [(0, crypto_1.stringToPath)(hdPath + accountIndex + "'/0/0")];
         }
         catch (error) {
             FirmaUtil_1.FirmaUtil.printLog(error);
@@ -169,7 +169,7 @@ var FirmaWalletService = /** @class */ (function () {
                         seed = _a.sent();
                         hdpath = FirmaWalletService.getHdPath(this.getHdPath(), accountIndex);
                         privkey = crypto_1.Slip10.derivePath(crypto_1.Slip10Curve.Secp256k1, seed, hdpath[0]).privkey;
-                        privateKey = "0x" + Buffer.from(privkey).toString("hex");
+                        privateKey = "0x".concat(Buffer.from(privkey).toString("hex"));
                         return [2 /*return*/, privateKey];
                     case 2:
                         error_3 = _a.sent();

package/dist/sdk/firmachain/amino/addresses.js

@@ -8,32 +8,32 @@ var encoding_2 = require("./encoding");
 var pubkeys_1 = require("./pubkeys");
 function rawEd25519PubkeyToRawAddress(pubkeyData) {
     if (pubkeyData.length !== 32) {
-        throw new Error("Invalid Ed25519 pubkey length: " + pubkeyData.length);
+        throw new Error("Invalid Ed25519 pubkey length: ".concat(pubkeyData.length));
     }
-    return crypto_1.sha256(pubkeyData).slice(0, 20);
+    return (0, crypto_1.sha256)(pubkeyData).slice(0, 20);
 }
 exports.rawEd25519PubkeyToRawAddress = rawEd25519PubkeyToRawAddress;
 function rawSecp256k1PubkeyToRawAddress(pubkeyData) {
     if (pubkeyData.length !== 33) {
-        throw new Error("Invalid Secp256k1 pubkey length (compressed): " + pubkeyData.length);
+        throw new Error("Invalid Secp256k1 pubkey length (compressed): ".concat(pubkeyData.length));
     }
-    return crypto_1.ripemd160(crypto_1.sha256(pubkeyData));
+    return (0, crypto_1.ripemd160)((0, crypto_1.sha256)(pubkeyData));
 }
 exports.rawSecp256k1PubkeyToRawAddress = rawSecp256k1PubkeyToRawAddress;
 // For secp256k1 this assumes we already have a compressed pubkey.
 function pubkeyToRawAddress(pubkey) {
-    if (pubkeys_1.isSecp256k1Pubkey(pubkey)) {
-        var pubkeyData = encoding_1.fromBase64(pubkey.value);
+    if ((0, pubkeys_1.isSecp256k1Pubkey)(pubkey)) {
+        var pubkeyData = (0, encoding_1.fromBase64)(pubkey.value);
         return rawSecp256k1PubkeyToRawAddress(pubkeyData);
     }
-    else if (pubkeys_1.isEd25519Pubkey(pubkey)) {
-        var pubkeyData = encoding_1.fromBase64(pubkey.value);
+    else if ((0, pubkeys_1.isEd25519Pubkey)(pubkey)) {
+        var pubkeyData = (0, encoding_1.fromBase64)(pubkey.value);
         return rawEd25519PubkeyToRawAddress(pubkeyData);
     }
-    else if (pubkeys_1.isMultisigThresholdPubkey(pubkey)) {
+    else if ((0, pubkeys_1.isMultisigThresholdPubkey)(pubkey)) {
         // https://github.com/tendermint/tendermint/blob/38b401657e4ad7a7eeb3c30a3cbf512037df3740/crypto/multisig/threshold_pubkey.go#L71-L74
-        var pubkeyData = encoding_2.encodeAminoPubkey(pubkey);
-        return crypto_1.sha256(pubkeyData).slice(0, 20);
+        var pubkeyData = (0, encoding_2.encodeAminoPubkey)(pubkey);
+        return (0, crypto_1.sha256)(pubkeyData).slice(0, 20);
     }
     else {
         throw new Error("Unsupported public key type");

package/dist/sdk/firmachain/amino/aminotypes.js

@@ -26,10 +26,14 @@ var __read = (this && this.__read) || function (o, n) {
     }
     return ar;
 };
-var __spreadArray = (this && this.__spreadArray) || function (to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
 };
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -52,7 +56,7 @@ function omitDefault(input) {
     if (long_1.default.isLong(input)) {
         return input.isZero() ? undefined : input;
     }
-    throw new Error("Got unsupported type '" + typeof input + "'");
+    throw new Error("Got unsupported type '".concat(typeof input, "'"));
 }
 function createDefaultTypes(prefix) {
     return {
@@ -64,7 +68,7 @@ function createDefaultTypes(prefix) {
                 return ({
                     from_address: fromAddress,
                     to_address: toAddress,
-                    amount: __spreadArray([], __read(amount)),
+                    amount: __spreadArray([], __read(amount), false),
                 });
             },
             fromAmino: function (_a) {
@@ -72,7 +76,7 @@ function createDefaultTypes(prefix) {
                 return ({
                     fromAddress: from_address,
                     toAddress: to_address,
-                    amount: __spreadArray([], __read(amount)),
+                    amount: __spreadArray([], __read(amount), false),
                 });
             },
         },
@@ -83,11 +87,11 @@ function createDefaultTypes(prefix) {
                 return ({
                     inputs: inputs.map(function (input) { return ({
                         address: input.address,
-                        coins: __spreadArray([], __read(input.coins)),
+                        coins: __spreadArray([], __read(input.coins), false),
                     }); }),
                     outputs: outputs.map(function (output) { return ({
                         address: output.address,
-                        coins: __spreadArray([], __read(output.coins)),
+                        coins: __spreadArray([], __read(output.coins), false),
                     }); }),
                 });
             },
@@ -96,11 +100,11 @@ function createDefaultTypes(prefix) {
                 return ({
                     inputs: inputs.map(function (input) { return ({
                         address: input.address,
-                        coins: __spreadArray([], __read(input.coins)),
+                        coins: __spreadArray([], __read(input.coins), false),
                     }); }),
                     outputs: outputs.map(function (output) { return ({
                         address: output.address,
-                        coins: __spreadArray([], __read(output.coins)),
+                        coins: __spreadArray([], __read(output.coins), false),
                     }); }),
                 });
             },
@@ -111,14 +115,14 @@ function createDefaultTypes(prefix) {
             toAmino: function (_a) {
                 var amount = _a.amount, depositor = _a.depositor;
                 return ({
-                    amount: __spreadArray([], __read(amount)),
+                    amount: __spreadArray([], __read(amount), false),
                     depositor: depositor,
                 });
             },
             fromAmino: function (_a) {
                 var amount = _a.amount, depositor = _a.depositor;
                 return ({
-                    amount: __spreadArray([], __read(amount)),
+                    amount: __spreadArray([], __read(amount), false),
                     depositor: depositor,
                 });
             },
@@ -205,7 +209,7 @@ function createDefaultTypes(prefix) {
             fromAmino: function (_a) {
                 var option = _a.option, proposal_id = _a.proposal_id, voter = _a.voter;
                 return {
-                    option: gov_1.voteOptionFromJSON(option),
+                    option: (0, gov_1.voteOptionFromJSON)(option),
                     proposalId: long_1.default.fromString(proposal_id),
                     voter: voter,
                 };
@@ -215,7 +219,7 @@ function createDefaultTypes(prefix) {
             aminoType: "cosmos-sdk/MsgSubmitProposal",
             toAmino: function (_a) {
                 var initialDeposit = _a.initialDeposit, proposer = _a.proposer, content = _a.content;
-                utils_1.assertDefinedAndNotNull(content);
+                (0, utils_1.assertDefinedAndNotNull)(content);
                 var proposal;
                 switch (content.typeUrl) {
                     case "/cosmos.gov.v1beta1.TextProposal": {
@@ -230,7 +234,7 @@ function createDefaultTypes(prefix) {
                         break;
                     }
                     default:
-                        throw new Error("Unsupported proposal type: '" + content.typeUrl + "'");
+                        throw new Error("Unsupported proposal type: '".concat(content.typeUrl, "'"));
                 }
                 return {
                     initial_deposit: initialDeposit,
@@ -244,10 +248,10 @@ function createDefaultTypes(prefix) {
                 switch (content.type) {
                     case "cosmos-sdk/TextProposal": {
                         var value = content.value;
-                        utils_1.assert(utils_1.isNonNullObject(value));
+                        (0, utils_1.assert)((0, utils_1.isNonNullObject)(value));
                         var _b = value, title = _b.title, description = _b.description;
-                        utils_1.assert(typeof title === "string");
-                        utils_1.assert(typeof description === "string");
+                        (0, utils_1.assert)(typeof title === "string");
+                        (0, utils_1.assert)(typeof description === "string");
                         any_content = any_1.Any.fromPartial({
                             typeUrl: "/cosmos.gov.v1beta1.TextProposal",
                             value: gov_1.TextProposal.encode(gov_1.TextProposal.fromPartial({
@@ -258,7 +262,7 @@ function createDefaultTypes(prefix) {
                         break;
                     }
                     default:
-                        throw new Error("Unsupported proposal type: '" + content.type + "'");
+                        throw new Error("Unsupported proposal type: '".concat(content.type, "'"));
                 }
                 return {
                     initialDeposit: Array.from(initial_deposit),
@@ -272,7 +276,7 @@ function createDefaultTypes(prefix) {
             aminoType: "cosmos-sdk/MsgBeginRedelegate",
             toAmino: function (_a) {
                 var delegatorAddress = _a.delegatorAddress, validatorSrcAddress = _a.validatorSrcAddress, validatorDstAddress = _a.validatorDstAddress, amount = _a.amount;
-                utils_1.assertDefinedAndNotNull(amount, "missing amount");
+                (0, utils_1.assertDefinedAndNotNull)(amount, "missing amount");
                 return {
                     delegator_address: delegatorAddress,
                     validator_src_address: validatorSrcAddress,
@@ -294,10 +298,10 @@ function createDefaultTypes(prefix) {
             aminoType: "cosmos-sdk/MsgCreateValidator",
             toAmino: function (_a) {
                 var description = _a.description, commission = _a.commission, minSelfDelegation = _a.minSelfDelegation, delegatorAddress = _a.delegatorAddress, validatorAddress = _a.validatorAddress, pubkey = _a.pubkey, value = _a.value;
-                utils_1.assertDefinedAndNotNull(description, "missing description");
-                utils_1.assertDefinedAndNotNull(commission, "missing commission");
-                utils_1.assertDefinedAndNotNull(pubkey, "missing pubkey");
-                utils_1.assertDefinedAndNotNull(value, "missing value");
+                (0, utils_1.assertDefinedAndNotNull)(description, "missing description");
+                (0, utils_1.assertDefinedAndNotNull)(commission, "missing commission");
+                (0, utils_1.assertDefinedAndNotNull)(pubkey, "missing pubkey");
+                (0, utils_1.assertDefinedAndNotNull)(value, "missing value");
                 return {
                     description: {
                         moniker: description.moniker,
@@ -314,16 +318,16 @@ function createDefaultTypes(prefix) {
                     min_self_delegation: minSelfDelegation,
                     delegator_address: delegatorAddress,
                     validator_address: validatorAddress,
-                    pubkey: encoding_2.encodeBech32Pubkey({
+                    pubkey: (0, encoding_2.encodeBech32Pubkey)({
                         type: "tendermint/PubKeySecp256k1",
-                        value: encoding_1.toBase64(pubkey.value),
+                        value: (0, encoding_1.toBase64)(pubkey.value),
                     }, prefix),
                     value: value,
                 };
             },
             fromAmino: function (_a) {
                 var description = _a.description, commission = _a.commission, min_self_delegation = _a.min_self_delegation, delegator_address = _a.delegator_address, validator_address = _a.validator_address, pubkey = _a.pubkey, value = _a.value;
-                var decodedPubkey = encoding_2.decodeBech32Pubkey(pubkey);
+                var decodedPubkey = (0, encoding_2.decodeBech32Pubkey)(pubkey);
                 if (decodedPubkey.type !== "tendermint/PubKeySecp256k1") {
                     throw new Error("Only Secp256k1 public keys are supported");
                 }
@@ -345,7 +349,7 @@ function createDefaultTypes(prefix) {
                     validatorAddress: validator_address,
                     pubkey: {
                         typeUrl: "/cosmos.crypto.secp256k1.PubKey",
-                        value: encoding_1.fromBase64(decodedPubkey.value),
+                        value: (0, encoding_1.fromBase64)(decodedPubkey.value),
                     },
                     value: value,
                 };
@@ -355,7 +359,7 @@ function createDefaultTypes(prefix) {
             aminoType: "cosmos-sdk/MsgDelegate",
             toAmino: function (_a) {
                 var delegatorAddress = _a.delegatorAddress, validatorAddress = _a.validatorAddress, amount = _a.amount;
-                utils_1.assertDefinedAndNotNull(amount, "missing amount");
+                (0, utils_1.assertDefinedAndNotNull)(amount, "missing amount");
                 return {
                     delegator_address: delegatorAddress,
                     validator_address: validatorAddress,
@@ -375,7 +379,7 @@ function createDefaultTypes(prefix) {
             aminoType: "cosmos-sdk/MsgEditValidator",
             toAmino: function (_a) {
                 var description = _a.description, commissionRate = _a.commissionRate, minSelfDelegation = _a.minSelfDelegation, validatorAddress = _a.validatorAddress;
-                utils_1.assertDefinedAndNotNull(description, "missing description");
+                (0, utils_1.assertDefinedAndNotNull)(description, "missing description");
                 return {
                     description: {
                         moniker: description.moniker,
@@ -409,7 +413,7 @@ function createDefaultTypes(prefix) {
             aminoType: "cosmos-sdk/MsgUndelegate",
             toAmino: function (_a) {
                 var delegatorAddress = _a.delegatorAddress, validatorAddress = _a.validatorAddress, amount = _a.amount;
-                utils_1.assertDefinedAndNotNull(amount, "missing amount");
+                (0, utils_1.assertDefinedAndNotNull)(amount, "missing amount");
                 return {
                     delegator_address: delegatorAddress,
                     validator_address: validatorAddress,

package/dist/sdk/firmachain/amino/encoding.js

@@ -15,10 +15,14 @@ var __read = (this && this.__read) || function (o, n) {
     }
     return ar;
 };
-var __spreadArray = (this && this.__spreadArray) || function (to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
 };
 var __values = (this && this.__values) || function(o) {
     var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
@@ -43,58 +47,58 @@ function encodeSecp256k1Pubkey(pubkey) {
     }
     return {
         type: pubkeys_1.pubkeyType.secp256k1,
-        value: encoding_1.toBase64(pubkey),
+        value: (0, encoding_1.toBase64)(pubkey),
     };
 }
 exports.encodeSecp256k1Pubkey = encodeSecp256k1Pubkey;
 // As discussed in https://github.com/binance-chain/javascript-sdk/issues/163
 // Prefixes listed here: https://github.com/tendermint/tendermint/blob/d419fffe18531317c28c29a292ad7d253f6cafdf/docs/spec/blockchain/encoding.md#public-key-cryptography
 // Last bytes is varint-encoded length prefix
-var pubkeyAminoPrefixSecp256k1 = encoding_1.fromHex("eb5ae987" + "21" /* fixed length */);
-var pubkeyAminoPrefixEd25519 = encoding_1.fromHex("1624de64" + "20" /* fixed length */);
-var pubkeyAminoPrefixSr25519 = encoding_1.fromHex("0dfb1005" + "20" /* fixed length */);
+var pubkeyAminoPrefixSecp256k1 = (0, encoding_1.fromHex)("eb5ae987" + "21" /* fixed length */);
+var pubkeyAminoPrefixEd25519 = (0, encoding_1.fromHex)("1624de64" + "20" /* fixed length */);
+var pubkeyAminoPrefixSr25519 = (0, encoding_1.fromHex)("0dfb1005" + "20" /* fixed length */);
 /** See https://github.com/tendermint/tendermint/commit/38b401657e4ad7a7eeb3c30a3cbf512037df3740 */
-var pubkeyAminoPrefixMultisigThreshold = encoding_1.fromHex("22c1f7e2" /* variable length not included */);
+var pubkeyAminoPrefixMultisigThreshold = (0, encoding_1.fromHex)("22c1f7e2" /* variable length not included */);
 /**
  * Decodes a pubkey in the Amino binary format to a type/value object.
  */
 function decodeAminoPubkey(data) {
-    if (utils_1.arrayContentStartsWith(data, pubkeyAminoPrefixSecp256k1)) {
+    if ((0, utils_1.arrayContentStartsWith)(data, pubkeyAminoPrefixSecp256k1)) {
         var rest = data.slice(pubkeyAminoPrefixSecp256k1.length);
         if (rest.length !== 33) {
             throw new Error("Invalid rest data length. Expected 33 bytes (compressed secp256k1 pubkey).");
         }
         return {
             type: pubkeys_1.pubkeyType.secp256k1,
-            value: encoding_1.toBase64(rest),
+            value: (0, encoding_1.toBase64)(rest),
         };
     }
-    else if (utils_1.arrayContentStartsWith(data, pubkeyAminoPrefixEd25519)) {
+    else if ((0, utils_1.arrayContentStartsWith)(data, pubkeyAminoPrefixEd25519)) {
         var rest = data.slice(pubkeyAminoPrefixEd25519.length);
         if (rest.length !== 32) {
             throw new Error("Invalid rest data length. Expected 32 bytes (Ed25519 pubkey).");
         }
         return {
             type: pubkeys_1.pubkeyType.ed25519,
-            value: encoding_1.toBase64(rest),
+            value: (0, encoding_1.toBase64)(rest),
         };
     }
-    else if (utils_1.arrayContentStartsWith(data, pubkeyAminoPrefixSr25519)) {
+    else if ((0, utils_1.arrayContentStartsWith)(data, pubkeyAminoPrefixSr25519)) {
         var rest = data.slice(pubkeyAminoPrefixSr25519.length);
         if (rest.length !== 32) {
             throw new Error("Invalid rest data length. Expected 32 bytes (Sr25519 pubkey).");
         }
         return {
             type: pubkeys_1.pubkeyType.sr25519,
-            value: encoding_1.toBase64(rest),
+            value: (0, encoding_1.toBase64)(rest),
         };
     }
-    else if (utils_1.arrayContentStartsWith(data, pubkeyAminoPrefixMultisigThreshold)) {
+    else if ((0, utils_1.arrayContentStartsWith)(data, pubkeyAminoPrefixMultisigThreshold)) {
         // eslint-disable-next-line @typescript-eslint/no-use-before-define
         return decodeMultisigPubkey(data);
     }
     else {
-        throw new Error("Unsupported public key type. Amino data starts with: " + encoding_1.toHex(data.slice(0, 5)));
+        throw new Error("Unsupported public key type. Amino data starts with: " + (0, encoding_1.toHex)(data.slice(0, 5)));
     }
 }
 exports.decodeAminoPubkey = decodeAminoPubkey;
@@ -133,7 +137,7 @@ function decodeMultisigPubkey(data) {
     var reader = Array.from(data);
     // remove multisig amino prefix;
     var prefixFromReader = reader.splice(0, pubkeyAminoPrefixMultisigThreshold.length);
-    if (!utils_1.arrayContentStartsWith(prefixFromReader, pubkeyAminoPrefixMultisigThreshold)) {
+    if (!(0, utils_1.arrayContentStartsWith)(prefixFromReader, pubkeyAminoPrefixMultisigThreshold)) {
         throw new Error("Invalid multisig prefix.");
     }
     // remove 0x08 threshold prefix;
@@ -188,18 +192,18 @@ function encodeUvarint(value) {
  */
 function encodeAminoPubkey(pubkey) {
     var e_1, _a;
-    if (pubkeys_1.isMultisigThresholdPubkey(pubkey)) {
+    if ((0, pubkeys_1.isMultisigThresholdPubkey)(pubkey)) {
         var out = Array.from(pubkeyAminoPrefixMultisigThreshold);
         out.push(0x08); // TODO: What is this?
         out.push.apply(// TODO: What is this?
-        out, __spreadArray([], __read(encodeUvarint(pubkey.value.threshold))));
+        out, __spreadArray([], __read(encodeUvarint(pubkey.value.threshold)), false));
         try {
             for (var _b = __values(pubkey.value.pubkeys.map(function (p) { return encodeAminoPubkey(p); })), _c = _b.next(); !_c.done; _c = _b.next()) {
                 var pubkeyData = _c.value;
                 out.push(0x12); // TODO: What is this?
                 out.push.apply(// TODO: What is this?
-                out, __spreadArray([], __read(encodeUvarint(pubkeyData.length))));
-                out.push.apply(out, __spreadArray([], __read(pubkeyData)));
+                out, __spreadArray([], __read(encodeUvarint(pubkeyData.length)), false));
+                out.push.apply(out, __spreadArray([], __read(pubkeyData), false));
             }
         }
         catch (e_1_1) { e_1 = { error: e_1_1 }; }
@@ -211,11 +215,11 @@ function encodeAminoPubkey(pubkey) {
         }
         return new Uint8Array(out);
     }
-    else if (pubkeys_1.isEd25519Pubkey(pubkey)) {
-        return new Uint8Array(__spreadArray(__spreadArray([], __read(pubkeyAminoPrefixEd25519)), __read(encoding_1.fromBase64(pubkey.value))));
+    else if ((0, pubkeys_1.isEd25519Pubkey)(pubkey)) {
+        return new Uint8Array(__spreadArray(__spreadArray([], __read(pubkeyAminoPrefixEd25519), false), __read((0, encoding_1.fromBase64)(pubkey.value)), false));
     }
-    else if (pubkeys_1.isSecp256k1Pubkey(pubkey)) {
-        return new Uint8Array(__spreadArray(__spreadArray([], __read(pubkeyAminoPrefixSecp256k1)), __read(encoding_1.fromBase64(pubkey.value))));
+    else if ((0, pubkeys_1.isSecp256k1Pubkey)(pubkey)) {
+        return new Uint8Array(__spreadArray(__spreadArray([], __read(pubkeyAminoPrefixSecp256k1), false), __read((0, encoding_1.fromBase64)(pubkey.value)), false));
     }
     else {
         throw new Error("Unsupported pubkey type");