@firmachain/firma-js 0.2.37 → 0.2.40

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

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCoins = exports.coins = exports.coin = void 0;
+var math_1 = require("@cosmjs/math");
+/**
+ * Creates a coin.
+ *
+ * If your values do not exceed the safe integer range of JS numbers (53 bit),
+ * you can use the number type here. This is the case for all typical Cosmos SDK
+ * chains that use the default 6 decimals.
+ *
+ * In case you need to supportr larger values, use unsigned integer strings instead.
+ */
+function coin(amount, denom) {
+    var outAmount;
+    if (typeof amount === "number") {
+        try {
+            outAmount = new math_1.Uint53(amount).toString();
+        }
+        catch (_err) {
+            throw new Error("Given amount is not a safe integer. Consider using a string instead to overcome the limitations of JS numbers.");
+        }
+    }
+    else {
+        if (!amount.match(/^[0-9]+$/)) {
+            throw new Error("Invalid unsigned integer string format");
+        }
+        outAmount = amount.replace(/^0*/, "") || "0";
+    }
+    return {
+        amount: outAmount,
+        denom: denom,
+    };
+}
+exports.coin = coin;
+/**
+ * Creates a list of coins with one element.
+ */
+function coins(amount, denom) {
+    return [coin(amount, denom)];
+}
+exports.coins = coins;
+/**
+ * Takes a coins list like "819966000ucosm,700000000ustake" and parses it.
+ *
+ * A Stargate-ready variant of this function is available via:
+ *
+ * ```
+ * import { parseCoins } from "@cosmjs/proto-signing";
+ * // or
+ * import { parseCoins } from "@cosmjs/stargate";
+ * ```
+ */
+function parseCoins(input) {
+    return input
+        .replace(/\s/g, "")
+        .split(",")
+        .filter(Boolean)
+        .map(function (part) {
+        var match = part.match(/^([0-9]+)([a-zA-Z]+)/);
+        if (!match)
+            throw new Error("Got an invalid coin string");
+        return {
+            amount: math_1.Uint64.fromString(match[1]).toString(),
+            denom: match[2],
+        };
+    });
+}
+exports.parseCoins = parseCoins;

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

@@ -0,0 +1,24 @@
+import { Pubkey, Secp256k1Pubkey } from "./pubkeys";
+export declare function encodeSecp256k1Pubkey(pubkey: Uint8Array): Secp256k1Pubkey;
+/**
+ * Decodes a pubkey in the Amino binary format to a type/value object.
+ */
+export declare function decodeAminoPubkey(data: Uint8Array): Pubkey;
+/**
+ * Decodes a bech32 pubkey to Amino binary, which is then decoded to a type/value object.
+ * The bech32 prefix is ignored and discareded.
+ *
+ * @param bechEncoded the bech32 encoded pubkey
+ */
+export declare function decodeBech32Pubkey(bechEncoded: string): Pubkey;
+/**
+ * Encodes a public key to binary Amino.
+ */
+export declare function encodeAminoPubkey(pubkey: Pubkey): Uint8Array;
+/**
+ * Encodes a public key to binary Amino and then to bech32.
+ *
+ * @param pubkey the public key to encode
+ * @param prefix the bech32 prefix (human readable part)
+ */
+export declare function encodeBech32Pubkey(pubkey: Pubkey, prefix: string): string;

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

@@ -0,0 +1,238 @@
+"use strict";
+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, 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;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeBech32Pubkey = exports.encodeAminoPubkey = exports.decodeBech32Pubkey = exports.decodeAminoPubkey = exports.encodeSecp256k1Pubkey = void 0;
+var encoding_1 = require("@cosmjs/encoding");
+var math_1 = require("@cosmjs/math");
+var utils_1 = require("@cosmjs/utils");
+var pubkeys_1 = require("./pubkeys");
+function encodeSecp256k1Pubkey(pubkey) {
+    if (pubkey.length !== 33 || (pubkey[0] !== 0x02 && pubkey[0] !== 0x03)) {
+        throw new Error("Public key must be compressed secp256k1, i.e. 33 bytes starting with 0x02 or 0x03");
+    }
+    return {
+        type: pubkeys_1.pubkeyType.secp256k1,
+        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 = (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 = (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 ((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: (0, encoding_1.toBase64)(rest),
+        };
+    }
+    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: (0, encoding_1.toBase64)(rest),
+        };
+    }
+    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: (0, encoding_1.toBase64)(rest),
+        };
+    }
+    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: " + (0, encoding_1.toHex)(data.slice(0, 5)));
+    }
+}
+exports.decodeAminoPubkey = decodeAminoPubkey;
+/**
+ * Decodes a bech32 pubkey to Amino binary, which is then decoded to a type/value object.
+ * The bech32 prefix is ignored and discareded.
+ *
+ * @param bechEncoded the bech32 encoded pubkey
+ */
+function decodeBech32Pubkey(bechEncoded) {
+    var data = encoding_1.Bech32.decode(bechEncoded).data;
+    return decodeAminoPubkey(data);
+}
+exports.decodeBech32Pubkey = decodeBech32Pubkey;
+/**
+ * Uvarint decoder for Amino.
+ * @see https://github.com/tendermint/go-amino/blob/8e779b71f40d175/decoder.go#L64-76
+ * @returns varint as number, and bytes count occupied by varaint
+ */
+function decodeUvarint(reader) {
+    if (reader.length < 1) {
+        throw new Error("Can't decode varint. EOF");
+    }
+    if (reader[0] > 127) {
+        throw new Error("Decoding numbers > 127 is not supported here. Please tell those lazy CosmJS maintainers to port the binary.Varint implementation from the Go standard library and write some tests.");
+    }
+    return [reader[0], 1];
+}
+/**
+ * Decodes a multisig pubkey to type object.
+ * Pubkey structure [ prefix + const + threshold + loop:(const + pubkeyLength + pubkey            ) ]
+ *                  [   4b   + 1b    +  varint   + loop:(1b    +    varint    + pubkeyLength bytes) ]
+ * @param data encoded pubkey
+ */
+function decodeMultisigPubkey(data) {
+    var reader = Array.from(data);
+    // remove multisig amino prefix;
+    var prefixFromReader = reader.splice(0, pubkeyAminoPrefixMultisigThreshold.length);
+    if (!(0, utils_1.arrayContentStartsWith)(prefixFromReader, pubkeyAminoPrefixMultisigThreshold)) {
+        throw new Error("Invalid multisig prefix.");
+    }
+    // remove 0x08 threshold prefix;
+    if (reader.shift() != 0x08) {
+        throw new Error("Invalid multisig data. Expecting 0x08 prefix before threshold.");
+    }
+    // read threshold
+    var _a = __read(decodeUvarint(reader), 2), threshold = _a[0], thresholdBytesLength = _a[1];
+    reader.splice(0, thresholdBytesLength);
+    // read participants pubkeys
+    var pubkeys = [];
+    while (reader.length > 0) {
+        // remove 0x12 threshold prefix;
+        if (reader.shift() != 0x12) {
+            throw new Error("Invalid multisig data. Expecting 0x12 prefix before participant pubkey length.");
+        }
+        // read pubkey length
+        var _b = __read(decodeUvarint(reader), 2), pubkeyLength = _b[0], pubkeyLengthBytesSize = _b[1];
+        reader.splice(0, pubkeyLengthBytesSize);
+        // verify that we can read pubkey
+        if (reader.length < pubkeyLength) {
+            throw new Error("Invalid multisig data length.");
+        }
+        // read and decode participant pubkey
+        var encodedPubkey = reader.splice(0, pubkeyLength);
+        var pubkey = decodeAminoPubkey(Uint8Array.from(encodedPubkey));
+        pubkeys.push(pubkey);
+    }
+    return {
+        type: pubkeys_1.pubkeyType.multisigThreshold,
+        value: {
+            threshold: threshold.toString(),
+            pubkeys: pubkeys,
+        },
+    };
+}
+/**
+ * Uvarint encoder for Amino. This is the same encoding as `binary.PutUvarint` from the Go
+ * standard library.
+ *
+ * @see https://github.com/tendermint/go-amino/blob/8e779b71f40d175/encoder.go#L77-L85
+ */
+function encodeUvarint(value) {
+    var checked = math_1.Uint53.fromString(value.toString()).toNumber();
+    if (checked > 127) {
+        throw new Error("Encoding numbers > 127 is not supported here. Please tell those lazy CosmJS maintainers to port the binary.PutUvarint implementation from the Go standard library and write some tests.");
+    }
+    return [checked];
+}
+/**
+ * Encodes a public key to binary Amino.
+ */
+function encodeAminoPubkey(pubkey) {
+    var e_1, _a;
+    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)), 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)), false));
+                out.push.apply(out, __spreadArray([], __read(pubkeyData), false));
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return new Uint8Array(out);
+    }
+    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 ((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");
+    }
+}
+exports.encodeAminoPubkey = encodeAminoPubkey;
+/**
+ * Encodes a public key to binary Amino and then to bech32.
+ *
+ * @param pubkey the public key to encode
+ * @param prefix the bech32 prefix (human readable part)
+ */
+function encodeBech32Pubkey(pubkey, prefix) {
+    return encoding_1.Bech32.encode(prefix, encodeAminoPubkey(pubkey));
+}
+exports.encodeBech32Pubkey = encodeBech32Pubkey;

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

@@ -0,0 +1,10 @@
+import { MultisigThresholdPubkey, SinglePubkey } from "./pubkeys";
+/**
+ * Compare arrays lexicographically.
+ *
+ * Returns value < 0 if `a < b`.
+ * Returns value > 0 if `a > b`.
+ * Returns 0 if `a === b`.
+ */
+export declare function compareArrays(a: Uint8Array, b: Uint8Array): number;
+export declare function createMultisigThresholdPubkey(pubkeys: readonly SinglePubkey[], threshold: number, nosort?: boolean): MultisigThresholdPubkey;

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMultisigThresholdPubkey = exports.compareArrays = void 0;
+var encoding_1 = require("@cosmjs/encoding");
+var math_1 = require("@cosmjs/math");
+var addresses_1 = require("./addresses");
+/**
+ * Compare arrays lexicographically.
+ *
+ * Returns value < 0 if `a < b`.
+ * Returns value > 0 if `a > b`.
+ * Returns 0 if `a === b`.
+ */
+function compareArrays(a, b) {
+    var aHex = (0, encoding_1.toHex)(a);
+    var bHex = (0, encoding_1.toHex)(b);
+    return aHex === bHex ? 0 : aHex < bHex ? -1 : 1;
+}
+exports.compareArrays = compareArrays;
+function createMultisigThresholdPubkey(pubkeys, threshold, nosort) {
+    if (nosort === void 0) { nosort = false; }
+    var uintThreshold = new math_1.Uint53(threshold);
+    if (uintThreshold.toNumber() > pubkeys.length) {
+        throw new Error("Threshold k = ".concat(uintThreshold.toNumber(), " exceeds number of keys n = ").concat(pubkeys.length));
+    }
+    var outPubkeys = nosort
+        ? pubkeys
+        : Array.from(pubkeys).sort(function (lhs, rhs) {
+            // https://github.com/cosmos/cosmos-sdk/blob/v0.42.2/client/keys/add.go#L172-L174
+            var addressLhs = (0, addresses_1.pubkeyToRawAddress)(lhs);
+            var addressRhs = (0, addresses_1.pubkeyToRawAddress)(rhs);
+            return compareArrays(addressLhs, addressRhs);
+        });
+    return {
+        type: "tendermint/PubKeyMultisigThreshold",
+        value: {
+            threshold: uintThreshold.toString(),
+            pubkeys: outPubkeys,
+        },
+    };
+}
+exports.createMultisigThresholdPubkey = createMultisigThresholdPubkey;

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

@@ -0,0 +1,6 @@
+import { HdPath } from "@cosmjs/crypto";
+/**
+ * The Cosmos Hub derivation path in the form `m/44'/118'/0'/0/a`
+ * with 0-based account index `a`.
+ */
+export declare function makeCosmoshubPath(a: number): HdPath;

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCosmoshubPath = void 0;
+var crypto_1 = require("@cosmjs/crypto");
+/**
+ * The Cosmos Hub derivation path in the form `m/44'/118'/0'/0/a`
+ * with 0-based account index `a`.
+ */
+function makeCosmoshubPath(a) {
+    return [
+        crypto_1.Slip10RawIndex.hardened(44),
+        crypto_1.Slip10RawIndex.hardened(118),
+        crypto_1.Slip10RawIndex.hardened(0),
+        crypto_1.Slip10RawIndex.normal(0),
+        crypto_1.Slip10RawIndex.normal(a),
+    ];
+}
+exports.makeCosmoshubPath = makeCosmoshubPath;

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

@@ -0,0 +1,47 @@
+export interface Pubkey {
+    readonly type: string;
+    readonly value: any;
+}
+export interface Ed25519Pubkey extends SinglePubkey {
+    readonly type: "tendermint/PubKeyEd25519";
+    readonly value: string;
+}
+export declare function isEd25519Pubkey(pubkey: Pubkey): pubkey is Ed25519Pubkey;
+export interface Secp256k1Pubkey extends SinglePubkey {
+    readonly type: "tendermint/PubKeySecp256k1";
+    readonly value: string;
+}
+export declare function isSecp256k1Pubkey(pubkey: Pubkey): pubkey is Secp256k1Pubkey;
+export declare const pubkeyType: {
+    /** @see https://github.com/tendermint/tendermint/blob/v0.33.0/crypto/ed25519/ed25519.go#L22 */
+    secp256k1: "tendermint/PubKeySecp256k1";
+    /** @see https://github.com/tendermint/tendermint/blob/v0.33.0/crypto/secp256k1/secp256k1.go#L23 */
+    ed25519: "tendermint/PubKeyEd25519";
+    /** @see https://github.com/tendermint/tendermint/blob/v0.33.0/crypto/sr25519/codec.go#L12 */
+    sr25519: "tendermint/PubKeySr25519";
+    multisigThreshold: "tendermint/PubKeyMultisigThreshold";
+};
+/**
+ * A pubkey which contains the data directly without further nesting.
+ *
+ * You can think of this as a non-multisig pubkey.
+ */
+export interface SinglePubkey extends Pubkey {
+    readonly type: string;
+    /**
+     * The base64 encoding of the Amino binary encoded pubkey.
+     *
+     * Note: if type is Secp256k1, this must contain a 33 bytes compressed pubkey.
+     */
+    readonly value: string;
+}
+export declare function isSinglePubkey(pubkey: Pubkey): pubkey is SinglePubkey;
+export interface MultisigThresholdPubkey extends Pubkey {
+    readonly type: "tendermint/PubKeyMultisigThreshold";
+    readonly value: {
+        /** A string-encoded integer */
+        readonly threshold: string;
+        readonly pubkeys: readonly SinglePubkey[];
+    };
+}
+export declare function isMultisigThresholdPubkey(pubkey: Pubkey): pubkey is MultisigThresholdPubkey;

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMultisigThresholdPubkey = exports.isSinglePubkey = exports.pubkeyType = exports.isSecp256k1Pubkey = exports.isEd25519Pubkey = void 0;
+function isEd25519Pubkey(pubkey) {
+    return pubkey.type === "tendermint/PubKeyEd25519";
+}
+exports.isEd25519Pubkey = isEd25519Pubkey;
+function isSecp256k1Pubkey(pubkey) {
+    return pubkey.type === "tendermint/PubKeySecp256k1";
+}
+exports.isSecp256k1Pubkey = isSecp256k1Pubkey;
+exports.pubkeyType = {
+    /** @see https://github.com/tendermint/tendermint/blob/v0.33.0/crypto/ed25519/ed25519.go#L22 */
+    secp256k1: "tendermint/PubKeySecp256k1",
+    /** @see https://github.com/tendermint/tendermint/blob/v0.33.0/crypto/secp256k1/secp256k1.go#L23 */
+    ed25519: "tendermint/PubKeyEd25519",
+    /** @see https://github.com/tendermint/tendermint/blob/v0.33.0/crypto/sr25519/codec.go#L12 */
+    sr25519: "tendermint/PubKeySr25519",
+    multisigThreshold: "tendermint/PubKeyMultisigThreshold",
+};
+function isSinglePubkey(pubkey) {
+    var singPubkeyTypes = [exports.pubkeyType.ed25519, exports.pubkeyType.secp256k1, exports.pubkeyType.sr25519];
+    return singPubkeyTypes.includes(pubkey.type);
+}
+exports.isSinglePubkey = isSinglePubkey;
+function isMultisigThresholdPubkey(pubkey) {
+    return pubkey.type === "tendermint/PubKeyMultisigThreshold";
+}
+exports.isMultisigThresholdPubkey = isMultisigThresholdPubkey;

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

@@ -0,0 +1,16 @@
+import { Pubkey } from "./pubkeys";
+export interface StdSignature {
+    readonly pub_key: Pubkey;
+    readonly signature: string;
+}
+/**
+ * Takes a binary pubkey and signature to create a signature object
+ *
+ * @param pubkey a compressed secp256k1 public key
+ * @param signature a 64 byte fixed length representation of secp256k1 signature components r and s
+ */
+export declare function encodeSecp256k1Signature(pubkey: Uint8Array, signature: Uint8Array): StdSignature;
+export declare function decodeSignature(signature: StdSignature): {
+    readonly pubkey: Uint8Array;
+    readonly signature: Uint8Array;
+};

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeSignature = exports.encodeSecp256k1Signature = void 0;
+/* eslint-disable @typescript-eslint/naming-convention */
+var encoding_1 = require("@cosmjs/encoding");
+var encoding_2 = require("./encoding");
+var pubkeys_1 = require("./pubkeys");
+/**
+ * Takes a binary pubkey and signature to create a signature object
+ *
+ * @param pubkey a compressed secp256k1 public key
+ * @param signature a 64 byte fixed length representation of secp256k1 signature components r and s
+ */
+function encodeSecp256k1Signature(pubkey, signature) {
+    if (signature.length !== 64) {
+        throw new Error("Signature must be 64 bytes long. Cosmos SDK uses a 2x32 byte fixed length encoding for the secp256k1 signature integers r and s.");
+    }
+    return {
+        pub_key: (0, encoding_2.encodeSecp256k1Pubkey)(pubkey),
+        signature: (0, encoding_1.toBase64)(signature),
+    };
+}
+exports.encodeSecp256k1Signature = encodeSecp256k1Signature;
+function decodeSignature(signature) {
+    switch (signature.pub_key.type) {
+        // Note: please don't add cases here without writing additional unit tests
+        case pubkeys_1.pubkeyType.secp256k1:
+            return {
+                pubkey: (0, encoding_1.fromBase64)(signature.pub_key.value),
+                signature: (0, encoding_1.fromBase64)(signature.signature),
+            };
+        default:
+            throw new Error("Unsupported pubkey type");
+    }
+}
+exports.decodeSignature = decodeSignature;

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

@@ -0,0 +1,26 @@
+import { Coin } from "./coins";
+export interface AminoMsg {
+    readonly type: string;
+    readonly value: any;
+}
+export interface StdFee {
+    amount: Coin[];
+    gas: string;
+}
+/**
+ * The document to be signed
+ *
+ * @see https://docs.cosmos.network/master/modules/auth/03_types.html#stdsigndoc
+ */
+export interface StdSignDoc {
+    readonly chain_id: string;
+    readonly account_number: string;
+    readonly sequence: string;
+    readonly fee: StdFee;
+    readonly msgs: readonly AminoMsg[];
+    readonly memo: string;
+}
+/** Returns a JSON string with objects sorted by key */
+export declare function sortedJsonStringify(obj: any): string;
+export declare function makeSignDoc(msgs: readonly AminoMsg[], fee: StdFee, chainId: string, memo: string | undefined, accountNumber: number | string, sequence: number | string): StdSignDoc;
+export declare function serializeSignDoc(signDoc: StdSignDoc): Uint8Array;

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeSignDoc = exports.makeSignDoc = exports.sortedJsonStringify = void 0;
+/* eslint-disable @typescript-eslint/naming-convention */
+var encoding_1 = require("@cosmjs/encoding");
+var math_1 = require("@cosmjs/math");
+function sortedObject(obj) {
+    if (typeof obj !== "object" || obj === null) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(sortedObject);
+    }
+    var sortedKeys = Object.keys(obj).sort();
+    var result = {};
+    // NOTE: Use forEach instead of reduce for performance with large objects eg Wasm code
+    sortedKeys.forEach(function (key) {
+        result[key] = sortedObject(obj[key]);
+    });
+    return result;
+}
+/** Returns a JSON string with objects sorted by key */
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+function sortedJsonStringify(obj) {
+    return JSON.stringify(sortedObject(obj));
+}
+exports.sortedJsonStringify = sortedJsonStringify;
+function makeSignDoc(msgs, fee, chainId, memo, accountNumber, sequence) {
+    return {
+        chain_id: chainId,
+        account_number: math_1.Uint53.fromString(accountNumber.toString()).toString(),
+        sequence: math_1.Uint53.fromString(sequence.toString()).toString(),
+        fee: fee,
+        msgs: msgs,
+        memo: memo || "",
+    };
+}
+exports.makeSignDoc = makeSignDoc;
+function serializeSignDoc(signDoc) {
+    return (0, encoding_1.toUtf8)(sortedJsonStringify(signDoc));
+}
+exports.serializeSignDoc = serializeSignDoc;

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

@@ -0,0 +1,32 @@
+import { StdSignature, StdSignDoc } from "@cosmjs/amino";
+export declare type Algo = "secp256k1" | "ed25519" | "sr25519";
+export interface AccountData {
+    /** A printable address (typically bech32 encoded) */
+    readonly address: string;
+    readonly algo: Algo;
+    readonly pubkey: Uint8Array;
+}
+export interface AminoSignResponse {
+    /**
+     * The sign doc that was signed.
+     * This may be different from the input signDoc when the signer modifies it as part of the signing process.
+     */
+    readonly signed: StdSignDoc;
+    readonly signature: StdSignature;
+}
+export interface OfflineAminoSigner {
+    /**
+     * Get AccountData array from wallet. Rejects if not enabled.
+     */
+    readonly getAccounts: () => Promise<readonly AccountData[]>;
+    /**
+     * Request signature from whichever key corresponds to provided bech32-encoded address. Rejects if not enabled.
+     *
+     * The signer implementation may offer the user the ability to override parts of the signDoc. It must
+     * return the doc that was signed in the response.
+     *
+     * @param signerAddress The address of the account that should sign the transaction
+     * @param signDoc The content that should be signed
+     */
+    readonly signAmino: (signerAddress: string, signDoc: StdSignDoc) => Promise<AminoSignResponse>;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,15 @@
+import { StdSignature } from "./signature";
+import { AminoMsg, StdFee, StdSignDoc } from "./signdoc";
+/**
+ * A Cosmos SDK StdTx
+ *
+ * @see https://docs.cosmos.network/master/modules/auth/03_types.html#stdtx
+ */
+export interface StdTx {
+    readonly msg: readonly AminoMsg[];
+    readonly fee: StdFee;
+    readonly signatures: readonly StdSignature[];
+    readonly memo: string | undefined;
+}
+export declare function isStdTx(txValue: unknown): txValue is StdTx;
+export declare function makeStdTx(content: Pick<StdSignDoc, "msgs" | "fee" | "memo">, signatures: StdSignature | readonly StdSignature[]): StdTx;