example-js-sdk 0.0.1

package/lib/util/tx.js

@@ -0,0 +1,168 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLibMsg = exports.useSignDirectForMetamask = exports.TxGasCostTypeMap = exports.TxMinGasPriceTypeDefaultKey = exports.TxGasCostTypeDefaultKey = exports.DEFAULT_SIGN_OPTS = exports.Types = exports.CarbonCustomError = exports.ErrorType = exports.BroadcastTxMode = exports.getSender = exports.decode = void 0;
+const codec_1 = require("../codec");
+const CosmosModels = __importStar(require("../codec/cosmos-models"));
+const constant_1 = require("../constant");
+const address_1 = require("./address");
+const bytes_1 = require("../util/bytes");
+const msgUpdateClientInnerFields = [
+    "lastCommitHash",
+    "dataHash",
+    "validatorsHash",
+    "nextValidatorsHash",
+    "consensusHash",
+    "appHash",
+    "lastResultsHash",
+    "evidenceHash",
+    "hash",
+    "signature",
+    "proposerAddress",
+    "validatorAddress",
+    "address",
+    "ed25519",
+    "data",
+];
+const msgRecvPacketInnerFields = ["proofCommitment", "data"];
+const decodeHexList = [...msgUpdateClientInnerFields, ...msgRecvPacketInnerFields];
+const decodeNestedMsg = (obj) => {
+    for (const key in obj) {
+        const value = obj[key];
+        if (decodeHexList.includes(key) && value instanceof Uint8Array) {
+            obj[key] = Buffer.from(value).toString("hex");
+        }
+        else if (typeof value === "object" &&
+            value?.typeUrl !== undefined &&
+            value?.value !== undefined &&
+            Object.values(codec_1.TxTypes).includes(value?.typeUrl)) {
+            obj[key].value = codec_1.registry.decode(value);
+            obj[key] = decodeNestedMsg(value);
+        }
+        else if (value instanceof Object) {
+            obj[key] = decodeNestedMsg(value);
+        }
+    }
+    return obj;
+};
+const decode = (bytes) => {
+    if (!bytes)
+        return bytes;
+    const decodedTx = CosmosModels.Tx.Tx.decode((0, bytes_1.toUint8Array)(bytes));
+    const carbonTx = { ...decodedTx, body: undefined };
+    if (decodedTx.body) {
+        carbonTx.body = { ...decodedTx.body, messages: [] };
+        for (const message of decodedTx.body.messages) {
+            try {
+                carbonTx.body.messages.push({
+                    typeUrl: message.typeUrl,
+                    value: decodeNestedMsg(codec_1.registry.decode(message)),
+                });
+            }
+            catch (error) {
+                console.error(`failed to decode tx message: ${message?.typeUrl}`);
+                console.error(error);
+                carbonTx.body.messages.push(message);
+            }
+        }
+    }
+    else {
+        delete carbonTx.body;
+    }
+    return carbonTx;
+};
+exports.decode = decode;
+const getSender = (decodedTx, opts) => {
+    const publicKey = decodedTx.authInfo?.signerInfos?.[0].publicKey?.value;
+    if (!publicKey) {
+        throw new Error(`could not get signer public key`);
+    }
+    const keyBuffer = Buffer.from(publicKey).slice(2);
+    return address_1.SWTHAddress.publicKeyToAddress(keyBuffer, opts);
+};
+exports.getSender = getSender;
+var BroadcastTxMode;
+(function (BroadcastTxMode) {
+    BroadcastTxMode["BroadcastTxSync"] = "sync";
+    BroadcastTxMode["BroadcastTxAsync"] = "async";
+    BroadcastTxMode["BroadcastTxBlock"] = "block";
+})(BroadcastTxMode || (exports.BroadcastTxMode = BroadcastTxMode = {}));
+var ErrorType;
+(function (ErrorType) {
+    ErrorType["SIGNATURE_REJECTION"] = "signature_rejection";
+    ErrorType["BROADCAST_FAIL"] = "broadcast_fail";
+    ErrorType["BLOCK_FAIL"] = "block_fail";
+})(ErrorType || (exports.ErrorType = ErrorType = {}));
+class CarbonCustomError extends Error {
+    constructor(msg, type, data) {
+        super(msg);
+        this.type = type;
+        this.data = data;
+    }
+}
+exports.CarbonCustomError = CarbonCustomError;
+exports.Types = codec_1.TxTypes;
+exports.DEFAULT_SIGN_OPTS = {
+    fee: constant_1.DEFAULT_FEE,
+    memo: "",
+};
+exports.TxGasCostTypeDefaultKey = "default_fee";
+exports.TxMinGasPriceTypeDefaultKey = "swth";
+exports.TxGasCostTypeMap = {};
+const LibPackages = ['ibc', 'cosmos', 'alliance'];
+const BacklistedMessages = [
+    '/cosmos.authz.v1beta1.MsgExec',
+    '/cosmos.authz.v1beta1.MsgGrant',
+    '/cosmos.feegrant.v1beta1.MsgGrantAllowance',
+    '/cosmos.feegrant.v1beta1.MsgRevokeAllowance',
+];
+// to use signDirect for metamask signing if messages are from libraries (cosmos-sdk, ibc, alliance).
+// Reasons:
+// 1. There is decoding issue with MsgGrantAllowance in amino
+// 2. For Ibc MsgTransfer, there is an overflow issue with timeouttimestamp overflow (from uint32) during unmarshalJSON, even though it is defined as uint64
+// (This can be resolved from the client side by use sendIBCTransfer instead of sendIBCTransferV2) but using signDirect here fixes it too.
+// 3. Ethermint is still using legacyMsg.getSigners() to verify many amino signed eip712 txs. However, getSigners() is deprecated and not implmented in messages from cosmos-sdk anymore.
+// 4. as of comsos-sdk v0.50 --> very few messages are using legacyDec so we can safely use signDirect
+const useSignDirectForMetamask = (messages) => {
+    const typeUrls = messages.map(m => m.typeUrl);
+    return !!Object.values(codec_1.TxTypes).find(typeUrl => (0, exports.isLibMsg)(typeUrl) && typeUrls.includes(typeUrl));
+};
+exports.useSignDirectForMetamask = useSignDirectForMetamask;
+const isLibMsg = (typeUrl) => {
+    // /ibc.core.client.v1.UpgradeProposal --> ibc
+    const pkg = typeUrl.split('.')[0].substring(1);
+    return LibPackages.includes(pkg) && !BacklistedMessages.includes(typeUrl);
+};
+exports.isLibMsg = isLibMsg;

package/lib/util/type.d.ts

@@ -0,0 +1,22 @@
+import { Network } from "../constant";
+export interface SimpleMap<T = unknown> {
+    [index: string]: T;
+}
+export interface NetworkMap<T> {
+    [Network.MainNet]: T;
+    [Network.TestNet]: T;
+    [Network.DevNet]: T;
+    [Network.LocalHost]: T;
+}
+export type OptionalNetworkMap<T> = Partial<NetworkMap<T>>;
+/**
+ * converts snakecase strings to camelcase
+ * @param snakeStr string to convert to camelcase
+ */
+export declare const snakeToCamel: (snakeStr: string) => string;
+/**
+ * converts snakecase strings to camelcase
+ * @param camelStr string to convert to camelcase
+ */
+export declare const camelToSnake: (camelStr: string) => string;
+export declare const isDurationType: (value: any) => boolean;

package/lib/util/type.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDurationType = exports.camelToSnake = exports.snakeToCamel = void 0;
+const constant_1 = require("../constant");
+const long_1 = __importDefault(require("long"));
+/**
+ * converts snakecase strings to camelcase
+ * @param snakeStr string to convert to camelcase
+ */
+const snakeToCamel = (snakeStr) => {
+    if (!snakeStr.includes("_")) {
+        return snakeStr;
+    }
+    const camelArr = snakeStr.split("_").map((snakeItem, index) => {
+        if (index === 0) {
+            return snakeItem;
+        }
+        return snakeItem.length > 1 ? `${snakeItem[0].toUpperCase()}${snakeItem.substr(1)}` : snakeItem.toUpperCase();
+    });
+    return camelArr.join("");
+};
+exports.snakeToCamel = snakeToCamel;
+/**
+ * converts snakecase strings to camelcase
+ * @param camelStr string to convert to camelcase
+ */
+const camelToSnake = (camelStr) => {
+    if (camelStr.length <= 1) {
+        return camelStr;
+    }
+    let newSnake = "";
+    for (const letter of camelStr) {
+        const newLetter = letter !== letter.toLowerCase() ? `_${letter.toLowerCase()}` : letter;
+        newSnake = `${newSnake}${newLetter}`;
+    }
+    return newSnake;
+};
+exports.camelToSnake = camelToSnake;
+const isDurationType = (value) => {
+    return long_1.default.isLong(value?.seconds) && typeof value?.nanos === "number";
+};
+exports.isDurationType = isDurationType;

package/lib/wallet/CarbonSigner.d.ts

@@ -0,0 +1,67 @@
+import CarbonSDK from "../CarbonSDK";
+import { SignDoc } from "cosmjs-types/cosmos/tx/v1beta1/tx";
+import { CosmosLedger } from "../provider";
+import { AminoSignResponse, OfflineAminoSigner, Secp256k1Wallet, StdSignDoc } from "@cosmjs/amino";
+import { AccountData, DirectSecp256k1Wallet, DirectSignResponse, OfflineDirectSigner, OfflineSigner } from "@cosmjs/proto-signing";
+import { ethers } from "ethers";
+export declare enum CarbonSignerTypes {
+    Ledger = 0,
+    PrivateKey = 1,
+    BrowserInjected = 2,
+    PublicKey = 3
+}
+export interface EvmSigner {
+    readonly sendEvmTransaction: (api: CarbonSDK, req: ethers.providers.TransactionRequest) => Promise<string>;
+}
+export interface ArbitraryMessageSigner {
+    readonly signMessage: (address: string, message: string) => Promise<string>;
+}
+export interface EIP712Signer extends EvmSigner {
+    legacyEip712SignMode: boolean;
+    readonly signLegacyEip712: (signerAddress: string, signDoc: StdSignDoc) => Promise<LegacyEIP712AminoSignResponse>;
+}
+export type CarbonSigner = DirectCarbonSigner | AminoCarbonSigner | CarbonEIP712Signer;
+export type CarbonEIP712Signer = (DirectCarbonSigner | AminoCarbonSigner) & EIP712Signer & ArbitraryMessageSigner;
+export type DirectCarbonSigner = OfflineDirectSigner & EvmSigner & ArbitraryMessageSigner & {
+    type: CarbonSignerTypes;
+};
+export type AminoCarbonSigner = OfflineAminoSigner & EvmSigner & ArbitraryMessageSigner & {
+    type: CarbonSignerTypes;
+};
+export type LegacyEIP712AminoSignResponse = AminoSignResponse & {
+    feePayer: string;
+};
+export declare function isCarbonEIP712Signer(signer: OfflineSigner): boolean;
+export declare class CarbonPrivateKeySigner implements DirectCarbonSigner, AminoCarbonSigner {
+    readonly privateKey: Uint8Array;
+    readonly prefix: string;
+    type: CarbonSignerTypes;
+    wallet?: DirectSecp256k1Wallet;
+    aminoWallet?: Secp256k1Wallet;
+    constructor(privateKey: Uint8Array, prefix: string);
+    initWallet(): Promise<DirectSecp256k1Wallet>;
+    initAminoWallet(): Promise<Secp256k1Wallet>;
+    getAccounts(): Promise<readonly AccountData[]>;
+    signAmino(signerAddress: string, signDoc: StdSignDoc): Promise<AminoSignResponse>;
+    signDirect(signerAddress: string, signDoc: SignDoc): Promise<DirectSignResponse>;
+    sendEvmTransaction(api: CarbonSDK, req: ethers.providers.TransactionRequest): Promise<string>;
+    signMessage(address: string, message: string): Promise<string>;
+}
+export declare class CarbonNonSigner implements DirectCarbonSigner {
+    type: CarbonSignerTypes;
+    getAccounts(): Promise<readonly AccountData[]>;
+    signDirect(): Promise<DirectSignResponse>;
+    sendEvmTransaction(api: CarbonSDK, req: ethers.providers.TransactionRequest): Promise<string>;
+    signMessage(address: string, message: string): Promise<string>;
+}
+export declare class CarbonLedgerSigner implements AminoCarbonSigner {
+    readonly ledger: CosmosLedger;
+    type: CarbonSignerTypes;
+    account?: AccountData;
+    retrieveAccount(): Promise<AccountData>;
+    getAccounts(): Promise<readonly AccountData[]>;
+    signAmino(_: string, doc: StdSignDoc): Promise<AminoSignResponse>;
+    sendEvmTransaction(api: CarbonSDK, req: ethers.providers.TransactionRequest): Promise<string>;
+    signMessage(_: string, message: string): Promise<string>;
+    constructor(ledger: CosmosLedger);
+}

package/lib/wallet/CarbonSigner.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CarbonLedgerSigner = exports.CarbonNonSigner = exports.CarbonPrivateKeySigner = exports.CarbonSignerTypes = void 0;
+exports.isCarbonEIP712Signer = isCarbonEIP712Signer;
+const constant_1 = require("../constant");
+const ethermint_1 = require("../util/ethermint");
+const generic_1 = require("../util/generic");
+const message_1 = require("../util/message");
+const amino_1 = require("@cosmjs/amino");
+const proto_signing_1 = require("@cosmjs/proto-signing");
+const ethers_1 = require("ethers");
+var CarbonSignerTypes;
+(function (CarbonSignerTypes) {
+    CarbonSignerTypes[CarbonSignerTypes["Ledger"] = 0] = "Ledger";
+    CarbonSignerTypes[CarbonSignerTypes["PrivateKey"] = 1] = "PrivateKey";
+    CarbonSignerTypes[CarbonSignerTypes["BrowserInjected"] = 2] = "BrowserInjected";
+    CarbonSignerTypes[CarbonSignerTypes["PublicKey"] = 3] = "PublicKey";
+})(CarbonSignerTypes || (exports.CarbonSignerTypes = CarbonSignerTypes = {}));
+function isCarbonEIP712Signer(signer) {
+    return signer.signLegacyEip712 !== undefined;
+}
+class CarbonPrivateKeySigner {
+    constructor(privateKey, prefix) {
+        this.privateKey = privateKey;
+        this.prefix = prefix;
+        this.type = CarbonSignerTypes.PrivateKey;
+    }
+    async initWallet() {
+        if (!this.wallet)
+            this.wallet = await proto_signing_1.DirectSecp256k1Wallet.fromKey(this.privateKey, this.prefix);
+        return this.wallet;
+    }
+    async initAminoWallet() {
+        if (!this.aminoWallet)
+            this.aminoWallet = await amino_1.Secp256k1Wallet.fromKey(this.privateKey, this.prefix);
+        return this.aminoWallet;
+    }
+    async getAccounts() {
+        const wallet = await this.initWallet();
+        return wallet.getAccounts();
+    }
+    async signAmino(signerAddress, signDoc) {
+        const aminoWallet = await this.initAminoWallet();
+        return await aminoWallet.signAmino(signerAddress, signDoc);
+    }
+    async signDirect(signerAddress, signDoc) {
+        const wallet = await this.initWallet();
+        return await wallet.signDirect(signerAddress, signDoc);
+    }
+    async sendEvmTransaction(api, req) {
+        const unsignedTx = await (0, ethermint_1.populateUnsignedEvmTranscation)(api, req);
+        const provider = new ethers_1.ethers.providers.JsonRpcProvider(constant_1.NetworkConfigs[api.network].evmJsonRpcUrl);
+        const evmWallet = new ethers_1.ethers.Wallet(api.wallet?.privateKey ?? '', provider);
+        const transactionResponse = await evmWallet.sendTransaction({
+            ...unsignedTx,
+            type: unsignedTx.type ?? 2,
+        });
+        return transactionResponse.hash;
+    }
+    async signMessage(address, message) {
+        const aminoWallet = await this.initAminoWallet();
+        const signedDoc = await aminoWallet.signAmino(address, (0, message_1.constructAdr36SignDoc)(address, message));
+        return Buffer.from(signedDoc.signature.signature, 'base64').toString('hex');
+    }
+}
+exports.CarbonPrivateKeySigner = CarbonPrivateKeySigner;
+class CarbonNonSigner {
+    constructor() {
+        this.type = CarbonSignerTypes.PublicKey;
+    }
+    async getAccounts() {
+        throw new Error("signing not available");
+    }
+    async signDirect() {
+        throw new Error("signing not available");
+    }
+    async sendEvmTransaction(api, req) {
+        throw new Error("signing not available");
+    }
+    async signMessage(address, message) {
+        throw new Error("signing not available");
+    }
+}
+exports.CarbonNonSigner = CarbonNonSigner;
+// Uses amino because ledger does not work with protobuf yet
+class CarbonLedgerSigner {
+    async retrieveAccount() {
+        if (!this.account) {
+            const address = await this.ledger.getCosmosAddress();
+            const pubkey = await this.ledger.getPubKey();
+            this.account = {
+                address,
+                algo: "secp256k1",
+                pubkey,
+            };
+        }
+        return this.account;
+    }
+    async getAccounts() {
+        const account = await this.retrieveAccount();
+        return [account];
+    }
+    async signAmino(_, doc) {
+        const account = await this.retrieveAccount();
+        const { pubkey } = account;
+        const msg = JSON.stringify((0, generic_1.sortObject)(doc));
+        const signBytes = await this.ledger.sign(msg);
+        const signature = (0, amino_1.encodeSecp256k1Signature)(pubkey, signBytes);
+        return {
+            signed: doc,
+            signature,
+        };
+    }
+    async sendEvmTransaction(api, req) {
+        throw new Error("signing not available");
+    }
+    async signMessage(_, message) {
+        const account = await this.retrieveAccount();
+        const { pubkey, address } = account;
+        const doc = (0, message_1.constructAdr36SignDoc)(address, message);
+        const msg = JSON.stringify((0, generic_1.sortObject)(doc));
+        const signBytes = await this.ledger.sign(msg);
+        const { signature } = (0, amino_1.encodeSecp256k1Signature)(pubkey, signBytes);
+        return Buffer.from(signature, 'base64').toString('hex');
+    }
+    constructor(ledger) {
+        this.ledger = ledger;
+        this.type = CarbonSignerTypes.Ledger;
+    }
+}
+exports.CarbonLedgerSigner = CarbonLedgerSigner;

package/lib/wallet/CarbonSigningClient.d.ts

@@ -0,0 +1,41 @@
+import { TxRaw } from "../codec/cosmos/tx/v1beta1/tx";
+import { CarbonSignerData } from "../util/tx";
+import { AminoMsg } from "@cosmjs/amino";
+import { EncodeObject, OfflineSigner, Registry } from "@cosmjs/proto-signing";
+import { AminoTypes, GasPrice, SigningStargateClientOptions, StargateClient, StdFee } from "@cosmjs/stargate";
+import { Tendermint37Client } from "@cosmjs/tendermint-rpc";
+export interface StdSignDoc {
+    readonly chain_id: string;
+    readonly account_number: string;
+    readonly sequence: string;
+    readonly fee: StdFee;
+    readonly msgs: readonly AminoMsg[];
+    readonly memo: string;
+    readonly timeout_height: string;
+}
+export declare function makeSignDocAmino(msgs: readonly AminoMsg[], fee: StdFee, chainId: string, memo: string | undefined, accountNumber: number | string, sequence: number | string, timeoutHeight?: number | string): StdSignDoc;
+export declare class CarbonSigningClient extends StargateClient {
+    readonly signer: OfflineSigner;
+    readonly options: SigningStargateClientOptions;
+    readonly registry: Registry;
+    readonly aminoTypes: AminoTypes;
+    readonly broadcastTimeoutMs?: number;
+    readonly broadcastPollIntervalMs?: number;
+    readonly gasPrice?: GasPrice;
+    constructor(tmClient: Tendermint37Client, signer: OfflineSigner, options?: SigningStargateClientOptions);
+    /**
+     * @see SigningStargateClient
+     * Gets account number and sequence from the API, creates a sign doc,
+     * creates a single signature and assembles the signed transaction.
+     *
+     * The sign mode (SIGN_MODE_DIRECT or SIGN_MODE_LEGACY_AMINO_JSON) is determined by this client's signer.
+     *
+     * You can pass signer data (account number, sequence and chain ID) explicitly instead of querying them
+     * from the chain. This is needed when signing for a multisig account, but it also allows for offline signing
+     * (See the SigningStargateClient.offline constructor).
+     */
+    sign(signerAddress: string, messages: readonly EncodeObject[], fee: StdFee, memo: string, signerData: CarbonSignerData, granterAddress?: string): Promise<TxRaw>;
+    private signDirect;
+    private signAmino;
+    private signLegacyEip712;
+}

package/lib/wallet/CarbonSigningClient.js

@@ -0,0 +1,201 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CarbonSigningClient = void 0;
+exports.makeSignDocAmino = makeSignDocAmino;
+const codec_1 = require("../codec");
+const tx_1 = require("../codec/cosmos/tx/v1beta1/tx");
+const web3_1 = require("../codec/ethermint/types/v1/web3");
+const ethermint_1 = require("../util/ethermint");
+const tx_2 = require("../util/tx");
+const amino_1 = require("@cosmjs/amino");
+const encoding_1 = require("@cosmjs/encoding");
+const math_1 = require("@cosmjs/math");
+const proto_signing_1 = require("@cosmjs/proto-signing");
+const stargate_1 = require("@cosmjs/stargate");
+const long_1 = __importDefault(require("long"));
+const provider_1 = require("../provider");
+const CarbonSigner_1 = require("./CarbonSigner");
+// Added SignMode enum from cosmjs-types to resolve build error
+var SignMode;
+(function (SignMode) {
+    /**
+     * SIGN_MODE_UNSPECIFIED - SIGN_MODE_UNSPECIFIED specifies an unknown signing mode and will be
+     * rejected
+     */
+    SignMode[SignMode["SIGN_MODE_UNSPECIFIED"] = 0] = "SIGN_MODE_UNSPECIFIED";
+    /**
+     * SIGN_MODE_DIRECT - SIGN_MODE_DIRECT specifies a signing mode which uses SignDoc and is
+     * verified with raw bytes from Tx
+     */
+    SignMode[SignMode["SIGN_MODE_DIRECT"] = 1] = "SIGN_MODE_DIRECT";
+    /**
+     * SIGN_MODE_TEXTUAL - SIGN_MODE_TEXTUAL is a future signing mode that will verify some
+     * human-readable textual representation on top of the binary representation
+     * from SIGN_MODE_DIRECT
+     */
+    SignMode[SignMode["SIGN_MODE_TEXTUAL"] = 2] = "SIGN_MODE_TEXTUAL";
+    /**
+     * SIGN_MODE_LEGACY_AMINO_JSON - SIGN_MODE_LEGACY_AMINO_JSON is a backwards compatibility mode which uses
+     * Amino JSON and will be removed in the future
+     */
+    SignMode[SignMode["SIGN_MODE_LEGACY_AMINO_JSON"] = 127] = "SIGN_MODE_LEGACY_AMINO_JSON";
+    SignMode[SignMode["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(SignMode || (SignMode = {}));
+function makeSignDocAmino(msgs, fee, chainId, memo, accountNumber, sequence, timeoutHeight = 0) {
+    const timeoutHeightStr = typeof timeoutHeight === "number" ? timeoutHeight.toString(10) : timeoutHeight;
+    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 || "",
+        timeout_height: timeoutHeightStr,
+    };
+}
+class CarbonSigningClient extends stargate_1.StargateClient {
+    constructor(tmClient, signer, options = {}) {
+        super(tmClient, options);
+        this.signer = signer;
+        this.options = options;
+        const { registry = codec_1.registry, aminoTypes = provider_1.AminoTypesMap } = options;
+        this.registry = registry;
+        this.aminoTypes = aminoTypes;
+        this.signer = signer;
+        this.broadcastTimeoutMs = options.broadcastTimeoutMs;
+        this.broadcastPollIntervalMs = options.broadcastPollIntervalMs;
+        this.gasPrice = options.gasPrice;
+    }
+    /**
+     * @see SigningStargateClient
+     * Gets account number and sequence from the API, creates a sign doc,
+     * creates a single signature and assembles the signed transaction.
+     *
+     * The sign mode (SIGN_MODE_DIRECT or SIGN_MODE_LEGACY_AMINO_JSON) is determined by this client's signer.
+     *
+     * You can pass signer data (account number, sequence and chain ID) explicitly instead of querying them
+     * from the chain. This is needed when signing for a multisig account, but it also allows for offline signing
+     * (See the SigningStargateClient.offline constructor).
+     */
+    async sign(signerAddress, messages, fee, memo, signerData, granterAddress) {
+        if ((0, CarbonSigner_1.isCarbonEIP712Signer)(this.signer)) {
+            if (this.signer.legacyEip712SignMode) {
+                return this.signLegacyEip712(signerAddress, messages, fee, memo, signerData);
+            }
+            // workaround to use signDirect
+            if ((0, tx_2.useSignDirectForMetamask)(messages))
+                return this.signDirect(signerAddress, messages, fee, memo, signerData, granterAddress);
+            // Use amino sigining for metamask as there is a bug with signDirect signature verification
+            // ethermint verifies sign direct legacyDec type as shifted by 18dp when it should be unshifted (verified with keplr)
+            // therefore the alternative which works here would be to use signamino where the verification is not broken on ethermint.
+            return this.signAmino(signerAddress, messages, fee, memo, signerData, granterAddress);
+        }
+        return (0, proto_signing_1.isOfflineDirectSigner)(this.signer)
+            ? this.signDirect(signerAddress, messages, fee, memo, signerData, granterAddress)
+            : this.signAmino(signerAddress, messages, fee, memo, signerData, granterAddress);
+    }
+    async signDirect(signerAddress, messages, fee, memo, { accountNumber, sequence, chainId, timeoutHeight }, granterAddress) {
+        const signer = this.signer;
+        const accountFromSigner = (await this.signer.getAccounts()).find((account) => account.address === signerAddress);
+        if (!(0, CarbonSigner_1.isCarbonEIP712Signer)(this.signer) && !accountFromSigner) {
+            throw new Error("Failed to retrieve account from signer");
+        }
+        const pubKeyBz = accountFromSigner ? accountFromSigner.pubkey : (await this.signer.getAccounts())[0].pubkey;
+        const pubkey = (0, CarbonSigner_1.isCarbonEIP712Signer)(this.signer) ? (0, ethermint_1.encodeAnyEthSecp256k1PubKey)(pubKeyBz) : (0, proto_signing_1.encodePubkey)((0, amino_1.encodeSecp256k1Pubkey)(pubKeyBz));
+        const txBodyEncodeObject = {
+            typeUrl: "/cosmos.tx.v1beta1.TxBody",
+            value: {
+                messages: messages,
+                memo: memo,
+                ...(timeoutHeight && {
+                    timeoutHeight: long_1.default.fromNumber(timeoutHeight),
+                }),
+            },
+        };
+        const txBodyBytes = this.registry.encode(txBodyEncodeObject);
+        const gasLimit = math_1.Int53.fromString(fee.gas).toNumber();
+        const authInfoBytes = (0, proto_signing_1.makeAuthInfoBytes)([{ pubkey, sequence }], fee.amount, gasLimit, granterAddress, (granterAddress ? signerAddress : undefined));
+        const signDoc = (0, proto_signing_1.makeSignDoc)(txBodyBytes, authInfoBytes, chainId, accountNumber);
+        const { signature, signed } = await signer.signDirect(signerAddress, signDoc);
+        return tx_1.TxRaw.fromPartial({
+            bodyBytes: signed.bodyBytes,
+            authInfoBytes: signed.authInfoBytes,
+            signatures: [(0, encoding_1.fromBase64)(signature.signature)],
+        });
+    }
+    async signAmino(signerAddress, messages, fee, memo, { accountNumber, sequence, chainId, timeoutHeight }, granterAddress) {
+        const signer = this.signer;
+        const accountFromSigner = (await this.signer.getAccounts()).find((account) => account.address === signerAddress);
+        if (!(0, CarbonSigner_1.isCarbonEIP712Signer)(this.signer) && !accountFromSigner) {
+            throw new Error("Failed to retrieve account from signer");
+        }
+        const pubKeyBz = accountFromSigner ? accountFromSigner.pubkey : (await this.signer.getAccounts())[0].pubkey;
+        const pubkey = (0, CarbonSigner_1.isCarbonEIP712Signer)(this.signer) ? (0, ethermint_1.encodeAnyEthSecp256k1PubKey)(pubKeyBz) : (0, proto_signing_1.encodePubkey)((0, amino_1.encodeSecp256k1Pubkey)(pubKeyBz));
+        const signMode = SignMode.SIGN_MODE_LEGACY_AMINO_JSON;
+        const msgs = messages.map((msg) => this.aminoTypes.toAmino(msg));
+        const signDoc = makeSignDocAmino(msgs, fee, chainId, memo, accountNumber, sequence, timeoutHeight ?? 0);
+        const { signature, signed } = await signer.signAmino(signerAddress, signDoc);
+        const signedTxBody = {
+            messages: signed.msgs.map((msg) => this.aminoTypes.fromAmino(msg)),
+            memo: signed.memo,
+            ...(timeoutHeight && {
+                timeoutHeight: long_1.default.fromNumber(timeoutHeight),
+            }),
+        };
+        const signedTxBodyEncodeObject = {
+            typeUrl: "/cosmos.tx.v1beta1.TxBody",
+            value: signedTxBody,
+        };
+        const signedTxBodyBytes = this.registry.encode(signedTxBodyEncodeObject);
+        const signedGasLimit = math_1.Int53.fromString(signed.fee.gas).toNumber();
+        const signedSequence = math_1.Int53.fromString(signed.sequence).toNumber();
+        const signedAuthInfoBytes = (0, proto_signing_1.makeAuthInfoBytes)([{ pubkey, sequence: signedSequence }], signed.fee.amount, signedGasLimit, granterAddress, (granterAddress ? signerAddress : undefined), signMode);
+        return tx_1.TxRaw.fromPartial({
+            bodyBytes: signedTxBodyBytes,
+            authInfoBytes: signedAuthInfoBytes,
+            signatures: [(0, encoding_1.fromBase64)(signature.signature)],
+        });
+    }
+    async signLegacyEip712(signerAddress, messages, fee, memo, { accountNumber, sequence, evmChainId }, granterAddress) {
+        if (!evmChainId) {
+            throw new Error("evmChainId required for legacyEip712 tx");
+        }
+        const signer = this.signer;
+        const pubKeyBz = (await this.signer.getAccounts())[0].pubkey;
+        const pubkey = (0, ethermint_1.encodeAnyEthSecp256k1PubKey)(pubKeyBz);
+        const signMode = SignMode.SIGN_MODE_LEGACY_AMINO_JSON;
+        const msgs = messages.map((msg) => this.aminoTypes.toAmino(msg));
+        const signDoc = makeSignDocAmino(msgs, fee, evmChainId, memo, accountNumber, sequence);
+        const { signature, signed, feePayer } = await signer.signLegacyEip712(signerAddress, signDoc);
+        const eip712ExtensionOptions = {
+            typeUrl: "/ethermint.types.v1.ExtensionOptionsWeb3Tx",
+            value: web3_1.ExtensionOptionsWeb3Tx.encode(web3_1.ExtensionOptionsWeb3Tx.fromPartial({
+                typedDataChainId: (0, ethermint_1.parseChainId)(evmChainId),
+                feePayer,
+                feePayerSig: (0, encoding_1.fromBase64)(signature.signature),
+            })).finish(),
+        };
+        const signedGasLimit = math_1.Int53.fromString(signed.fee.gas).toNumber();
+        const signedSequence = math_1.Int53.fromString(signed.sequence).toNumber();
+        const signedAuthInfoBytes = (0, proto_signing_1.makeAuthInfoBytes)([{ pubkey, sequence: signedSequence }], signed.fee.amount, signedGasLimit, granterAddress, (granterAddress ? signerAddress : undefined), signMode);
+        const signedTxBody = {
+            messages: signed.msgs.map((msg) => this.aminoTypes.fromAmino(msg)),
+            memo: signed.memo,
+            extensionOptions: [eip712ExtensionOptions],
+        };
+        const signedTxBodyEncodeObject = {
+            typeUrl: "/cosmos.tx.v1beta1.TxBody",
+            value: signedTxBody,
+        };
+        const signedTxBodyBytes = this.registry.encode(signedTxBodyEncodeObject);
+        return tx_1.TxRaw.fromPartial({
+            bodyBytes: signedTxBodyBytes,
+            authInfoBytes: signedAuthInfoBytes,
+            signatures: [new Uint8Array()],
+        });
+    }
+}
+exports.CarbonSigningClient = CarbonSigningClient;