@firmachain/firma-js 0.2.26 → 0.2.27

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

@@ -1,234 +0,0 @@
-"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) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
-};
-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: 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 */);
-/** See https://github.com/tendermint/tendermint/commit/38b401657e4ad7a7eeb3c30a3cbf512037df3740 */
-var pubkeyAminoPrefixMultisigThreshold = 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)) {
-        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),
-        };
-    }
-    else if (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),
-        };
-    }
-    else if (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),
-        };
-    }
-    else if (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)));
-    }
-}
-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 (!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 (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))));
-        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)));
-            }
-        }
-        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 (pubkeys_1.isEd25519Pubkey(pubkey)) {
-        return new Uint8Array(__spreadArray(__spreadArray([], __read(pubkeyAminoPrefixEd25519)), __read(encoding_1.fromBase64(pubkey.value))));
-    }
-    else if (pubkeys_1.isSecp256k1Pubkey(pubkey)) {
-        return new Uint8Array(__spreadArray(__spreadArray([], __read(pubkeyAminoPrefixSecp256k1)), __read(encoding_1.fromBase64(pubkey.value))));
-    }
-    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

@@ -1,10 +0,0 @@
-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

@@ -1,42 +0,0 @@
-"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 = encoding_1.toHex(a);
-    var bHex = 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 = " + uintThreshold.toNumber() + " exceeds number of keys n = " + 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 = addresses_1.pubkeyToRawAddress(lhs);
-            var addressRhs = 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

@@ -1,6 +0,0 @@
-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

@@ -1,18 +0,0 @@
-"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

@@ -1,47 +0,0 @@
-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

@@ -1,29 +0,0 @@
-"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/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 {};