@firmachain/firma-js 0.2.31 → 0.2.32

package/dist/sdk/firmachain/staking/StakingQueryClient.js

@@ -113,47 +113,62 @@ var StakingQueryClient = /** @class */ (function () {
             });
         });
     };
-    StakingQueryClient.prototype.queryGetUndelegationListFromValidator = function (address) {
+    StakingQueryClient.prototype.queryGetUndelegationListFromValidator = function (valoperAddress, paginationKey) {
+        if (paginationKey === void 0) { paginationKey = ""; }
         return __awaiter(this, void 0, void 0, function () {
-            var path, result;
+            var path, result, convertPagination;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        path = "/cosmos/staking/v1beta1/validators/" + address + "/unbonding_delegations";
-                        return [4 /*yield*/, this.axios.get(path)];
+                        path = "/cosmos/staking/v1beta1/validators/" + valoperAddress + "/unbonding_delegations";
+                        return [4 /*yield*/, this.axios.get(path, { params: { "pagination.key": paginationKey } })];
                     case 1:
                         result = _a.sent();
-                        return [2 /*return*/, result.data.unbonding_responses];
+                        convertPagination = {
+                            next_key: result.data.pagination.next_key,
+                            total: Number.parseInt(result.data.pagination.total)
+                        };
+                        return [2 /*return*/, { dataList: result.data.unbonding_responses, pagination: convertPagination }];
                 }
             });
         });
     };
-    StakingQueryClient.prototype.queryGetDelegateListFromValidator = function (address) {
+    StakingQueryClient.prototype.queryGetDelegateListFromValidator = function (valoperAddress, paginationKey) {
+        if (paginationKey === void 0) { paginationKey = ""; }
         return __awaiter(this, void 0, void 0, function () {
-            var path, result;
+            var path, result, convertPagination;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        path = "/cosmos/staking/v1beta1/validators/" + address + "/delegations";
-                        return [4 /*yield*/, this.axios.get(path)];
+                        path = "/cosmos/staking/v1beta1/validators/" + valoperAddress + "/delegations";
+                        return [4 /*yield*/, this.axios.get(path, { params: { "pagination.key": paginationKey } })];
                     case 1:
                         result = _a.sent();
-                        return [2 /*return*/, result.data.delegation_responses];
+                        convertPagination = {
+                            next_key: result.data.pagination.next_key,
+                            total: Number.parseInt(result.data.pagination.total)
+                        };
+                        return [2 /*return*/, { dataList: result.data.delegation_responses, pagination: convertPagination }];
                 }
             });
         });
     };
-    StakingQueryClient.prototype.queryGetTotalDelegationInfo = function (address) {
+    StakingQueryClient.prototype.queryGetTotalDelegationInfo = function (address, paginationKey) {
+        if (paginationKey === void 0) { paginationKey = ""; }
         return __awaiter(this, void 0, void 0, function () {
-            var path, result;
+            var path, result, convertPagination;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         path = "/cosmos/staking/v1beta1/delegations/" + address;
-                        return [4 /*yield*/, this.axios.get(path)];
+                        return [4 /*yield*/, this.axios.get(path, { params: { "pagination.key": paginationKey } })];
                     case 1:
                         result = _a.sent();
-                        return [2 /*return*/, result.data.delegation_responses];
+                        convertPagination = {
+                            next_key: result.data.pagination.next_key,
+                            total: Number.parseInt(result.data.pagination.total)
+                        };
+                        return [2 /*return*/, { dataList: result.data.delegation_responses, pagination: convertPagination }];
                 }
             });
         });
@@ -203,17 +218,22 @@ var StakingQueryClient = /** @class */ (function () {
             });
         });
     };
-    StakingQueryClient.prototype.queryValidators = function () {
+    StakingQueryClient.prototype.queryValidators = function (paginationKey) {
+        if (paginationKey === void 0) { paginationKey = ""; }
         return __awaiter(this, void 0, void 0, function () {
-            var path, result;
+            var path, result, convertPagination;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         path = "/cosmos/staking/v1beta1/validators";
-                        return [4 /*yield*/, this.axios.get(path)];
+                        return [4 /*yield*/, this.axios.get(path, { params: { "pagination.key": paginationKey } })];
                     case 1:
                         result = _a.sent();
-                        return [2 /*return*/, result.data.validators];
+                        convertPagination = {
+                            next_key: result.data.pagination.next_key,
+                            total: Number.parseInt(result.data.pagination.total)
+                        };
+                        return [2 /*return*/, { dataList: result.data.validators, pagination: convertPagination }];
                 }
             });
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@firmachain/firma-js",
-  "version": "0.2.31",
+  "version": "0.2.32",
   "description": "The Official FirmaChain Javascript SDK written in Typescript",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",

package/dist/sdk/firmachain/amino/secp256k1hdwallet.d.ts

@@ -1,94 +0,0 @@
-import { EnglishMnemonic, HdPath } from "@cosmjs/crypto";
-import { StdSignDoc } from "./signdoc";
-import { AccountData, AminoSignResponse, OfflineAminoSigner } from "./signer";
-import { EncryptionConfiguration, KdfConfiguration } from "./wallet";
-/**
- * This interface describes a JSON object holding the encrypted wallet and the meta data.
- * All fields in here must be JSON types.
- */
-export interface Secp256k1HdWalletSerialization {
-    /** A format+version identifier for this serialization format */
-    readonly type: string;
-    /** Information about the key derivation function (i.e. password to encryption key) */
-    readonly kdf: KdfConfiguration;
-    /** Information about the symmetric encryption */
-    readonly encryption: EncryptionConfiguration;
-    /** An instance of Secp256k1HdWalletData, which is stringified, encrypted and base64 encoded. */
-    readonly data: string;
-}
-export declare function extractKdfConfiguration(serialization: string): KdfConfiguration;
-export interface Secp256k1HdWalletOptions {
-    /** The password to use when deriving a BIP39 seed from a mnemonic. */
-    readonly bip39Password: string;
-    /** The BIP-32/SLIP-10 derivation paths. Defaults to the Cosmos Hub/ATOM path `m/44'/118'/0'/0/0`. */
-    readonly hdPaths: readonly HdPath[];
-    /** The bech32 address prefix (human readable part). Defaults to "cosmos". */
-    readonly prefix: string;
-}
-interface Secp256k1HdWalletConstructorOptions extends Partial<Secp256k1HdWalletOptions> {
-    readonly seed: Uint8Array;
-}
-export declare class Secp256k1HdWallet implements OfflineAminoSigner {
-    /**
-     * Restores a wallet from the given BIP39 mnemonic.
-     *
-     * @param mnemonic Any valid English mnemonic.
-     * @param options An optional `Secp256k1HdWalletOptions` object optionally containing a bip39Password, hdPaths, and prefix.
-     */
-    static fromMnemonic(mnemonic: string, options?: Partial<Secp256k1HdWalletOptions>): Promise<Secp256k1HdWallet>;
-    /**
-     * Generates a new wallet with a BIP39 mnemonic of the given length.
-     *
-     * @param length The number of words in the mnemonic (12, 15, 18, 21 or 24).
-     * @param options An optional `Secp256k1HdWalletOptions` object optionally containing a bip39Password, hdPaths, and prefix.
-     */
-    static generate(length?: 12 | 15 | 18 | 21 | 24, options?: Partial<Secp256k1HdWalletOptions>): Promise<Secp256k1HdWallet>;
-    /**
-     * Restores a wallet from an encrypted serialization.
-     *
-     * @param password The user provided password used to generate an encryption key via a KDF.
-     *                 This is not normalized internally (see "Unicode normalization" to learn more).
-     */
-    static deserialize(serialization: string, password: string): Promise<Secp256k1HdWallet>;
-    /**
-     * Restores a wallet from an encrypted serialization.
-     *
-     * This is an advanced alternative to calling `deserialize(serialization, password)` directly, which allows
-     * you to offload the KDF execution to a non-UI thread (e.g. in a WebWorker).
-     *
-     * The caller is responsible for ensuring the key was derived with the given KDF configuration. This can be
-     * done using `extractKdfConfiguration(serialization)` and `executeKdf(password, kdfConfiguration)` from this package.
-     */
-    static deserializeWithEncryptionKey(serialization: string, encryptionKey: Uint8Array): Promise<Secp256k1HdWallet>;
-    private static deserializeTypeV1;
-    /** Base secret */
-    private readonly secret;
-    /** BIP39 seed */
-    private readonly seed;
-    /** Derivation instruction */
-    private readonly accounts;
-    protected constructor(mnemonic: EnglishMnemonic, options: Secp256k1HdWalletConstructorOptions);
-    get mnemonic(): string;
-    getAccounts(): Promise<readonly AccountData[]>;
-    signAmino(signerAddress: string, signDoc: StdSignDoc): Promise<AminoSignResponse>;
-    /**
-     * Generates an encrypted serialization of this wallet.
-     *
-     * @param password The user provided password used to generate an encryption key via a KDF.
-     *                 This is not normalized internally (see "Unicode normalization" to learn more).
-     */
-    serialize(password: string): Promise<string>;
-    /**
-     * Generates an encrypted serialization of this wallet.
-     *
-     * This is an advanced alternative to calling `serialize(password)` directly, which allows you to
-     * offload the KDF execution to a non-UI thread (e.g. in a WebWorker).
-     *
-     * The caller is responsible for ensuring the key was derived with the given KDF options. If this
-     * is not the case, the wallet cannot be restored with the original password.
-     */
-    serializeWithEncryptionKey(encryptionKey: Uint8Array, kdfConfiguration: KdfConfiguration): Promise<string>;
-    private getKeyPair;
-    private getAccountsWithPrivkeys;
-}
-export {};

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

@@ -1,437 +0,0 @@
-"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) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    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;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Secp256k1HdWallet = exports.extractKdfConfiguration = void 0;
-var crypto_1 = require("@cosmjs/crypto");
-var encoding_1 = require("@cosmjs/encoding");
-var utils_1 = require("@cosmjs/utils");
-var addresses_1 = require("./addresses");
-var paths_1 = require("./paths");
-var signature_1 = require("./signature");
-var signdoc_1 = require("./signdoc");
-var wallet_1 = require("./wallet");
-var serializationTypeV1 = "secp256k1wallet-v1";
-/**
- * A KDF configuration that is not very strong but can be used on the main thread.
- * It takes about 1 second in Node.js 16.0.0 and should have similar runtimes in other modern Wasm hosts.
- */
-var basicPasswordHashingOptions = {
-    algorithm: "argon2id",
-    params: {
-        outputLength: 32,
-        opsLimit: 24,
-        memLimitKib: 12 * 1024,
-    },
-};
-function isDerivationJson(thing) {
-    if (!utils_1.isNonNullObject(thing))
-        return false;
-    if (typeof thing.hdPath !== "string")
-        return false;
-    if (typeof thing.prefix !== "string")
-        return false;
-    return true;
-}
-function extractKdfConfigurationV1(doc) {
-    return doc.kdf;
-}
-function extractKdfConfiguration(serialization) {
-    var root = JSON.parse(serialization);
-    if (!utils_1.isNonNullObject(root))
-        throw new Error("Root document is not an object.");
-    switch (root.type) {
-        case serializationTypeV1:
-            return extractKdfConfigurationV1(root);
-        default:
-            throw new Error("Unsupported serialization type");
-    }
-}
-exports.extractKdfConfiguration = extractKdfConfiguration;
-var defaultOptions = {
-    bip39Password: "",
-    hdPaths: [paths_1.makeCosmoshubPath(0)],
-    prefix: "cosmos",
-};
-var Secp256k1HdWallet = /** @class */ (function () {
-    function Secp256k1HdWallet(mnemonic, options) {
-        var _a, _b;
-        var hdPaths = (_a = options.hdPaths) !== null && _a !== void 0 ? _a : defaultOptions.hdPaths;
-        var prefix = (_b = options.prefix) !== null && _b !== void 0 ? _b : defaultOptions.prefix;
-        this.secret = mnemonic;
-        this.seed = options.seed;
-        this.accounts = hdPaths.map(function (hdPath) { return ({
-            hdPath: hdPath,
-            prefix: prefix,
-        }); });
-    }
-    /**
-     * Restores a wallet from the given BIP39 mnemonic.
-     *
-     * @param mnemonic Any valid English mnemonic.
-     * @param options An optional `Secp256k1HdWalletOptions` object optionally containing a bip39Password, hdPaths, and prefix.
-     */
-    Secp256k1HdWallet.fromMnemonic = function (mnemonic, options) {
-        if (options === void 0) { options = {}; }
-        return __awaiter(this, void 0, void 0, function () {
-            var mnemonicChecked, seed;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        mnemonicChecked = new crypto_1.EnglishMnemonic(mnemonic);
-                        return [4 /*yield*/, crypto_1.Bip39.mnemonicToSeed(mnemonicChecked, options.bip39Password)];
-                    case 1:
-                        seed = _a.sent();
-                        return [2 /*return*/, new Secp256k1HdWallet(mnemonicChecked, __assign(__assign({}, options), { seed: seed }))];
-                }
-            });
-        });
-    };
-    /**
-     * Generates a new wallet with a BIP39 mnemonic of the given length.
-     *
-     * @param length The number of words in the mnemonic (12, 15, 18, 21 or 24).
-     * @param options An optional `Secp256k1HdWalletOptions` object optionally containing a bip39Password, hdPaths, and prefix.
-     */
-    Secp256k1HdWallet.generate = function (length, options) {
-        if (length === void 0) { length = 12; }
-        if (options === void 0) { options = {}; }
-        return __awaiter(this, void 0, void 0, function () {
-            var entropyLength, entropy, mnemonic;
-            return __generator(this, function (_a) {
-                entropyLength = 4 * Math.floor((11 * length) / 33);
-                entropy = crypto_1.Random.getBytes(entropyLength);
-                mnemonic = crypto_1.Bip39.encode(entropy);
-                return [2 /*return*/, Secp256k1HdWallet.fromMnemonic(mnemonic.toString(), options)];
-            });
-        });
-    };
-    /**
-     * Restores a wallet from an encrypted serialization.
-     *
-     * @param password The user provided password used to generate an encryption key via a KDF.
-     *                 This is not normalized internally (see "Unicode normalization" to learn more).
-     */
-    Secp256k1HdWallet.deserialize = function (serialization, password) {
-        return __awaiter(this, void 0, void 0, function () {
-            var root;
-            return __generator(this, function (_a) {
-                root = JSON.parse(serialization);
-                if (!utils_1.isNonNullObject(root))
-                    throw new Error("Root document is not an object.");
-                switch (root.type) {
-                    case serializationTypeV1:
-                        return [2 /*return*/, Secp256k1HdWallet.deserializeTypeV1(serialization, password)];
-                    default:
-                        throw new Error("Unsupported serialization type");
-                }
-                return [2 /*return*/];
-            });
-        });
-    };
-    /**
-     * Restores a wallet from an encrypted serialization.
-     *
-     * This is an advanced alternative to calling `deserialize(serialization, password)` directly, which allows
-     * you to offload the KDF execution to a non-UI thread (e.g. in a WebWorker).
-     *
-     * The caller is responsible for ensuring the key was derived with the given KDF configuration. This can be
-     * done using `extractKdfConfiguration(serialization)` and `executeKdf(password, kdfConfiguration)` from this package.
-     */
-    Secp256k1HdWallet.deserializeWithEncryptionKey = function (serialization, encryptionKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var root, untypedRoot, _a, decryptedBytes, decryptedDocument, mnemonic, accounts, firstPrefix_1, hdPaths;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        root = JSON.parse(serialization);
-                        if (!utils_1.isNonNullObject(root))
-                            throw new Error("Root document is not an object.");
-                        untypedRoot = root;
-                        _a = untypedRoot.type;
-                        switch (_a) {
-                            case serializationTypeV1: return [3 /*break*/, 1];
-                        }
-                        return [3 /*break*/, 3];
-                    case 1: return [4 /*yield*/, wallet_1.decrypt(encoding_1.fromBase64(untypedRoot.data), encryptionKey, untypedRoot.encryption)];
-                    case 2:
-                        decryptedBytes = _b.sent();
-                        decryptedDocument = JSON.parse(encoding_1.fromUtf8(decryptedBytes));
-                        mnemonic = decryptedDocument.mnemonic, accounts = decryptedDocument.accounts;
-                        utils_1.assert(typeof mnemonic === "string");
-                        if (!Array.isArray(accounts))
-                            throw new Error("Property 'accounts' is not an array");
-                        if (!accounts.every(function (account) { return isDerivationJson(account); })) {
-                            throw new Error("Account is not in the correct format.");
-                        }
-                        firstPrefix_1 = accounts[0].prefix;
-                        if (!accounts.every(function (_a) {
-                            var prefix = _a.prefix;
-                            return prefix === firstPrefix_1;
-                        })) {
-                            throw new Error("Accounts do not all have the same prefix");
-                        }
-                        hdPaths = accounts.map(function (_a) {
-                            var hdPath = _a.hdPath;
-                            return crypto_1.stringToPath(hdPath);
-                        });
-                        return [2 /*return*/, Secp256k1HdWallet.fromMnemonic(mnemonic, {
-                                hdPaths: hdPaths,
-                                prefix: firstPrefix_1,
-                            })];
-                    case 3: throw new Error("Unsupported serialization type");
-                }
-            });
-        });
-    };
-    Secp256k1HdWallet.deserializeTypeV1 = function (serialization, password) {
-        return __awaiter(this, void 0, void 0, function () {
-            var root, encryptionKey;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        root = JSON.parse(serialization);
-                        if (!utils_1.isNonNullObject(root))
-                            throw new Error("Root document is not an object.");
-                        return [4 /*yield*/, wallet_1.executeKdf(password, root.kdf)];
-                    case 1:
-                        encryptionKey = _a.sent();
-                        return [2 /*return*/, Secp256k1HdWallet.deserializeWithEncryptionKey(serialization, encryptionKey)];
-                }
-            });
-        });
-    };
-    Object.defineProperty(Secp256k1HdWallet.prototype, "mnemonic", {
-        get: function () {
-            return this.secret.toString();
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Secp256k1HdWallet.prototype.getAccounts = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var accountsWithPrivkeys;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getAccountsWithPrivkeys()];
-                    case 1:
-                        accountsWithPrivkeys = _a.sent();
-                        return [2 /*return*/, accountsWithPrivkeys.map(function (_a) {
-                                var algo = _a.algo, pubkey = _a.pubkey, address = _a.address;
-                                return ({
-                                    algo: algo,
-                                    pubkey: pubkey,
-                                    address: address,
-                                });
-                            })];
-                }
-            });
-        });
-    };
-    Secp256k1HdWallet.prototype.signAmino = function (signerAddress, signDoc) {
-        return __awaiter(this, void 0, void 0, function () {
-            var accounts, account, privkey, pubkey, message, signature, signatureBytes;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getAccountsWithPrivkeys()];
-                    case 1:
-                        accounts = _a.sent();
-                        account = accounts.find(function (_a) {
-                            var address = _a.address;
-                            return address === signerAddress;
-                        });
-                        if (account === undefined) {
-                            throw new Error("Address " + signerAddress + " not found in wallet");
-                        }
-                        privkey = account.privkey, pubkey = account.pubkey;
-                        message = crypto_1.sha256(signdoc_1.serializeSignDoc(signDoc));
-                        return [4 /*yield*/, crypto_1.Secp256k1.createSignature(message, privkey)];
-                    case 2:
-                        signature = _a.sent();
-                        signatureBytes = new Uint8Array(__spreadArray(__spreadArray([], __read(signature.r(32))), __read(signature.s(32))));
-                        return [2 /*return*/, {
-                                signed: signDoc,
-                                signature: signature_1.encodeSecp256k1Signature(pubkey, signatureBytes),
-                            }];
-                }
-            });
-        });
-    };
-    /**
-     * Generates an encrypted serialization of this wallet.
-     *
-     * @param password The user provided password used to generate an encryption key via a KDF.
-     *                 This is not normalized internally (see "Unicode normalization" to learn more).
-     */
-    Secp256k1HdWallet.prototype.serialize = function (password) {
-        return __awaiter(this, void 0, void 0, function () {
-            var kdfConfiguration, encryptionKey;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        kdfConfiguration = basicPasswordHashingOptions;
-                        return [4 /*yield*/, wallet_1.executeKdf(password, kdfConfiguration)];
-                    case 1:
-                        encryptionKey = _a.sent();
-                        return [2 /*return*/, this.serializeWithEncryptionKey(encryptionKey, kdfConfiguration)];
-                }
-            });
-        });
-    };
-    /**
-     * Generates an encrypted serialization of this wallet.
-     *
-     * This is an advanced alternative to calling `serialize(password)` directly, which allows you to
-     * offload the KDF execution to a non-UI thread (e.g. in a WebWorker).
-     *
-     * The caller is responsible for ensuring the key was derived with the given KDF options. If this
-     * is not the case, the wallet cannot be restored with the original password.
-     */
-    Secp256k1HdWallet.prototype.serializeWithEncryptionKey = function (encryptionKey, kdfConfiguration) {
-        return __awaiter(this, void 0, void 0, function () {
-            var dataToEncrypt, dataToEncryptRaw, encryptionConfiguration, encryptedData, out;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        dataToEncrypt = {
-                            mnemonic: this.mnemonic,
-                            accounts: this.accounts.map(function (_a) {
-                                var hdPath = _a.hdPath, prefix = _a.prefix;
-                                return ({
-                                    hdPath: crypto_1.pathToString(hdPath),
-                                    prefix: prefix,
-                                });
-                            }),
-                        };
-                        dataToEncryptRaw = encoding_1.toUtf8(JSON.stringify(dataToEncrypt));
-                        encryptionConfiguration = {
-                            algorithm: wallet_1.supportedAlgorithms.xchacha20poly1305Ietf,
-                        };
-                        return [4 /*yield*/, wallet_1.encrypt(dataToEncryptRaw, encryptionKey, encryptionConfiguration)];
-                    case 1:
-                        encryptedData = _a.sent();
-                        out = {
-                            type: serializationTypeV1,
-                            kdf: kdfConfiguration,
-                            encryption: encryptionConfiguration,
-                            data: encoding_1.toBase64(encryptedData),
-                        };
-                        return [2 /*return*/, JSON.stringify(out)];
-                }
-            });
-        });
-    };
-    Secp256k1HdWallet.prototype.getKeyPair = function (hdPath) {
-        return __awaiter(this, void 0, void 0, function () {
-            var privkey, pubkey;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        privkey = crypto_1.Slip10.derivePath(crypto_1.Slip10Curve.Secp256k1, this.seed, hdPath).privkey;
-                        return [4 /*yield*/, crypto_1.Secp256k1.makeKeypair(privkey)];
-                    case 1:
-                        pubkey = (_a.sent()).pubkey;
-                        return [2 /*return*/, {
-                                privkey: privkey,
-                                pubkey: crypto_1.Secp256k1.compressPubkey(pubkey),
-                            }];
-                }
-            });
-        });
-    };
-    Secp256k1HdWallet.prototype.getAccountsWithPrivkeys = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                return [2 /*return*/, Promise.all(this.accounts.map(function (_a) {
-                        var hdPath = _a.hdPath, prefix = _a.prefix;
-                        return __awaiter(_this, void 0, void 0, function () {
-                            var _b, privkey, pubkey, address;
-                            return __generator(this, function (_c) {
-                                switch (_c.label) {
-                                    case 0: return [4 /*yield*/, this.getKeyPair(hdPath)];
-                                    case 1:
-                                        _b = _c.sent(), privkey = _b.privkey, pubkey = _b.pubkey;
-                                        address = encoding_1.Bech32.encode(prefix, addresses_1.rawSecp256k1PubkeyToRawAddress(pubkey));
-                                        return [2 /*return*/, {
-                                                algo: "secp256k1",
-                                                privkey: privkey,
-                                                pubkey: pubkey,
-                                                address: address,
-                                            }];
-                                }
-                            });
-                        });
-                    }))];
-            });
-        });
-    };
-    return Secp256k1HdWallet;
-}());
-exports.Secp256k1HdWallet = Secp256k1HdWallet;

package/dist/sdk/firmachain/amino/secp256k1wallet.d.ts

@@ -1,23 +0,0 @@
-import { StdSignDoc } from "./signdoc";
-import { AccountData, AminoSignResponse, OfflineAminoSigner } from "./signer";
-/**
- * A wallet that holds a single secp256k1 keypair.
- *
- * If you want to work with BIP39 mnemonics and multiple accounts, use Secp256k1HdWallet.
- */
-export declare class Secp256k1Wallet implements OfflineAminoSigner {
-    /**
-     * Creates a Secp256k1Wallet from the given private key
-     *
-     * @param privkey The private key.
-     * @param prefix The bech32 address prefix (human readable part). Defaults to "cosmos".
-     */
-    static fromKey(privkey: Uint8Array, prefix?: string): Promise<Secp256k1Wallet>;
-    private readonly pubkey;
-    private readonly privkey;
-    private readonly prefix;
-    private constructor();
-    private get address();
-    getAccounts(): Promise<readonly AccountData[]>;
-    signAmino(signerAddress: string, signDoc: StdSignDoc): Promise<AminoSignResponse>;
-}