@firmachain/firma-js 0.3.4 → 0.3.6-beta1

package/dist/sdk/firmachain/common/LedgerWallet.d.ts

@@ -1,6 +1,6 @@
 import { EncodeObject, Registry } from "@cosmjs/proto-signing";
 import { TxRaw } from "cosmjs-types/cosmos/tx/v1beta1/tx";
-import { SignAndBroadcastOptions } from "../common";
+import { SignAndBroadcastOptions } from "./TxCommon";
 export interface LedgerWalletInterface {
     getAddress(): Promise<string>;
     sign(message: string): Promise<Uint8Array>;
@@ -9,6 +9,22 @@ export interface LedgerWalletInterface {
         address: string;
         publicKey: Uint8Array;
     }>;
-    showAddressOnDevice(): Promise<void>;
+    showAddressOnDevice?(): Promise<void>;
 }
-export declare function signFromLedger(ledger: LedgerWalletInterface, messages: EncodeObject[], option: SignAndBroadcastOptions, registry: Registry): Promise<TxRaw>;
+export interface SignerData {
+    readonly account_number: number;
+    readonly sequence: number;
+    readonly chain_id: string;
+}
+/**
+ * Signs a protobuf-based Cosmos transaction using a general Signer
+ * compatible with SIGN_MODE_DIRECT (e.g. Ledger, Keplr, etc.)
+ *
+ * @param signer - SignerInterface instance
+ * @param messages - Cosmos transaction messages
+ * @param signerData - Chain ID, account number, sequence
+ * @param option - Fee, memo, granter info
+ * @param registry - Protobuf registry for message encoding
+ * @returns TxRaw - fully signed transaction
+ */
+export declare function signWithSignerProtobuf(signer: LedgerWalletInterface, messages: EncodeObject[], signerData: SignerData, option: SignAndBroadcastOptions, registry: Registry): Promise<TxRaw>;

package/dist/sdk/firmachain/common/LedgerWallet.js

@@ -14,7 +14,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     function verb(n) { return function (v) { return step([n, v]); }; }
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
+        while (g && (g = 0, op[0] && (_ = 0)), _) 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]) {
@@ -51,93 +51,163 @@ var __read = (this && this.__read) || function (o, n) {
     }
     return ar;
 };
-var __spreadArray = (this && this.__spreadArray) || function (to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    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.signFromLedger = void 0;
-var proto_signing_1 = require("@cosmjs/proto-signing");
+exports.signWithSignerProtobuf = void 0;
+var signing_1 = require("cosmjs-types/cosmos/tx/signing/v1beta1/signing");
 var tx_1 = require("cosmjs-types/cosmos/tx/v1beta1/tx");
-var math_1 = require("@cosmjs/math");
 var encoding_1 = require("@cosmjs/encoding");
-var signdoc_1 = require("../amino/signdoc");
-var encoding_2 = require("../amino/encoding");
-var signdoc_2 = require("../amino/signdoc");
-var encoding_3 = require("@cosmjs/encoding");
-var signing_1 = require("cosmjs-types/cosmos/tx/signing/v1beta1/signing");
-var tx_2 = require("cosmjs-types/cosmos/tx/v1beta1/tx");
-var FirmaUtil_1 = require("../../FirmaUtil");
-var stargate_1 = require("@cosmjs/stargate");
-function makeSignerInfos(signers, signMode) {
-    return signers.map(function (_a) {
-        var pubkey = _a.pubkey, sequence = _a.sequence;
-        return ({
-            publicKey: pubkey,
-            modeInfo: {
-                single: { mode: signMode },
-            },
-            sequence: BigInt(sequence),
-        });
-    });
-}
-function makeAuthInfoBytes(signers, feeAmount, gasLimit, granter, signMode) {
-    if (signMode === void 0) { signMode = signing_1.SignMode.SIGN_MODE_LEGACY_AMINO_JSON; }
+var keys_1 = require("cosmjs-types/cosmos/crypto/secp256k1/keys");
+// Creates AuthInfoBytes for "SIGN_MODE_DIRECT"
+function makeAuthInfoBytesDirect(pubkey, feeAmount, gasLimit, sequence) {
+    var signerInfo = {
+        publicKey: pubkey,
+        modeInfo: {
+            single: { mode: signing_1.SignMode.SIGN_MODE_DIRECT },
+        },
+        sequence: BigInt(sequence),
+    };
     var authInfo = {
-        signerInfos: makeSignerInfos(signers, signMode),
+        signerInfos: [signerInfo],
         fee: {
-            amount: __spreadArray([], __read(feeAmount)),
+            amount: __spreadArray([], __read(feeAmount), false),
             gasLimit: BigInt(gasLimit),
-            granter: granter,
         },
     };
     return tx_1.AuthInfo.encode(tx_1.AuthInfo.fromPartial(authInfo)).finish();
 }
-function signFromLedger(ledger, messages, option, registry) {
+/**
+ * Signs a protobuf-based Cosmos transaction using a general Signer
+ * compatible with SIGN_MODE_DIRECT (e.g. Ledger, Keplr, etc.)
+ *
+ * @param signer - SignerInterface instance
+ * @param messages - Cosmos transaction messages
+ * @param signerData - Chain ID, account number, sequence
+ * @param option - Fee, memo, granter info
+ * @param registry - Protobuf registry for message encoding
+ * @returns TxRaw - fully signed transaction
+ */
+function signWithSignerProtobuf(signer, messages, signerData, option, registry) {
     return __awaiter(this, void 0, void 0, function () {
-        var _a, address, publicKey, signerData, pubkey, aminoTypes, msgs, chainId, accountNumber, sequence, memo, fee, signDoc, signMessage, ledgerSignature, signedTxBody, signedTxBodyEncodeObject, signedTxBodyBytes, signedGasLimit, signedAuthInfoBytes, txRaw;
+        var anyMsgs, txBody, bodyBytes, pubkey, pubkeyProto, feeAmount, authInfoBytes, signDoc, signDocBytes, base64SignBytes, signature, lastError, protobufAttempts, protobufAttempts_1, protobufAttempts_1_1, attempt, signError_1, e_1_1, errorMsg, txRaw;
+        var e_1, _a;
         return __generator(this, function (_b) {
             switch (_b.label) {
-                case 0: return [4 /*yield*/, ledger.getAddressAndPublicKey()];
+                case 0:
+                    anyMsgs = messages.map(function (msg) { return registry.encodeAsAny(msg); });
+                    txBody = tx_1.TxBody.fromPartial({
+                        messages: anyMsgs,
+                        memo: option.memo || "",
+                    });
+                    bodyBytes = tx_1.TxBody.encode(txBody).finish();
+                    return [4 /*yield*/, signer.getPublicKey()];
                 case 1:
-                    _a = _b.sent(), address = _a.address, publicKey = _a.publicKey;
-                    return [4 /*yield*/, FirmaUtil_1.FirmaUtil.getSignerDataForLedger(address)];
+                    pubkey = _b.sent();
+                    pubkeyProto = {
+                        typeUrl: "/cosmos.crypto.secp256k1.PubKey",
+                        value: keys_1.PubKey.encode({ key: pubkey }).finish(),
+                    };
+                    feeAmount = option.fee.amount.map(function (a) { return ({
+                        denom: a.denom,
+                        amount: a.amount,
+                    }); });
+                    authInfoBytes = makeAuthInfoBytesDirect(pubkeyProto, feeAmount, option.fee.gasLimit, signerData.sequence);
+                    signDoc = tx_1.SignDoc.fromPartial({
+                        bodyBytes: bodyBytes,
+                        authInfoBytes: authInfoBytes,
+                        chainId: signerData.chain_id,
+                        accountNumber: BigInt(signerData.account_number),
+                    });
+                    // Verify SignDoc has all required fields
+                    if (!signDoc.chainId) {
+                        throw new Error("SignDoc chainId is missing: ".concat(signDoc.chainId));
+                    }
+                    if (!signDoc.accountNumber) {
+                        throw new Error("SignDoc accountNumber is missing: ".concat(signDoc.accountNumber));
+                    }
+                    signDocBytes = tx_1.SignDoc.encode(signDoc).finish();
+                    base64SignBytes = (0, encoding_1.toBase64)(signDocBytes);
+                    protobufAttempts = [
+                        { name: "SignDoc Base64", data: base64SignBytes },
+                        { name: "SignDoc Hex", data: Buffer.from(signDocBytes).toString('hex') },
+                        { name: "SignDoc Hex with 0x", data: '0x' + Buffer.from(signDocBytes).toString('hex') },
+                    ];
+                    _b.label = 2;
                 case 2:
-                    signerData = _b.sent();
-                    pubkey = proto_signing_1.encodePubkey(encoding_2.encodeSecp256k1Pubkey(publicKey));
-                    aminoTypes = new stargate_1.AminoTypes({});
-                    msgs = messages.map(function (msg) { return aminoTypes.toAmino(msg); });
-                    chainId = signerData.chain_id;
-                    accountNumber = Number.parseInt(signerData.account_number);
-                    sequence = Number.parseInt(signerData.sequence);
-                    memo = option.memo;
-                    fee = { amount: option.fee.amount, gas: option.fee.gas };
-                    signDoc = signdoc_2.makeSignDoc(msgs, fee, chainId, memo, accountNumber, sequence);
-                    signMessage = signdoc_1.serializeSignDoc(signDoc);
-                    return [4 /*yield*/, ledger.sign(encoding_3.fromUtf8(signMessage))];
+                    _b.trys.push([2, 9, 10, 11]);
+                    protobufAttempts_1 = __values(protobufAttempts), protobufAttempts_1_1 = protobufAttempts_1.next();
+                    _b.label = 3;
                 case 3:
-                    ledgerSignature = _b.sent();
-                    ;
-                    signedTxBody = {
-                        messages: signDoc.msgs.map(function (msg) { return aminoTypes.fromAmino(msg); }),
-                        memo: memo,
-                    };
-                    signedTxBodyEncodeObject = {
-                        typeUrl: "/cosmos.tx.v1beta1.TxBody",
-                        value: signedTxBody,
-                    };
-                    signedTxBodyBytes = registry.encode(signedTxBodyEncodeObject);
-                    signedGasLimit = math_1.Int53.fromString(option.fee.gas).toNumber();
-                    signedAuthInfoBytes = makeAuthInfoBytes([{ pubkey: pubkey, sequence: sequence }], option.fee.amount, signedGasLimit, option.fee.granter, signing_1.SignMode.SIGN_MODE_LEGACY_AMINO_JSON);
-                    txRaw = tx_2.TxRaw.fromPartial({
-                        bodyBytes: signedTxBodyBytes,
-                        authInfoBytes: signedAuthInfoBytes,
-                        signatures: [encoding_1.fromBase64(Buffer.from(ledgerSignature).toString('base64'))],
+                    if (!!protobufAttempts_1_1.done) return [3 /*break*/, 8];
+                    attempt = protobufAttempts_1_1.value;
+                    _b.label = 4;
+                case 4:
+                    _b.trys.push([4, 6, , 7]);
+                    return [4 /*yield*/, signer.sign(attempt.data)];
+                case 5:
+                    signature = _b.sent();
+                    if (signature && signature.length > 0) {
+                        return [3 /*break*/, 8]; // Success! Exit loop
+                    }
+                    return [3 /*break*/, 7];
+                case 6:
+                    signError_1 = _b.sent();
+                    lastError = signError_1;
+                    return [3 /*break*/, 7]; // Try next format
+                case 7:
+                    protobufAttempts_1_1 = protobufAttempts_1.next();
+                    return [3 /*break*/, 3];
+                case 8: return [3 /*break*/, 11];
+                case 9:
+                    e_1_1 = _b.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3 /*break*/, 11];
+                case 10:
+                    try {
+                        if (protobufAttempts_1_1 && !protobufAttempts_1_1.done && (_a = protobufAttempts_1.return)) _a.call(protobufAttempts_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                    return [7 /*endfinally*/];
+                case 11:
+                    // If all Protobuf attempts failed, provide guidance
+                    if (!signature || signature.length === 0) {
+                        errorMsg = lastError instanceof Error ? lastError.message : String(lastError);
+                        throw new Error("FirmaChain Ledger app signing failed: ".concat(errorMsg, ". Please ensure FirmaChain app is properly installed and up to date."));
+                    }
+                    // Signature validation
+                    if (!signature || signature.length === 0) {
+                        throw new Error("Signature is empty. Please confirm that the transaction was approved on Ledger or check Ledger connection.");
+                    }
+                    if (signature.length !== 64) {
+                        throw new Error("Unexpected signature length: ".concat(signature.length, " bytes (expected: 64 bytes)"));
+                    }
+                    txRaw = tx_1.TxRaw.fromPartial({
+                        bodyBytes: bodyBytes,
+                        authInfoBytes: authInfoBytes,
+                        signatures: [signature],
                     });
                     return [2 /*return*/, txRaw];
             }
         });
     });
 }
-exports.signFromLedger = signFromLedger;
+exports.signWithSignerProtobuf = signWithSignerProtobuf;

package/dist/sdk/firmachain/common/TendermintQueryClient.js

@@ -14,7 +14,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     function verb(n) { return function (v) { return step([n, v]); }; }
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
+        while (g && (g = 0, op[0] && (_ = 0)), _) 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]) {

package/dist/sdk/firmachain/common/TxCommon.d.ts

@@ -1,22 +1,4 @@
-import { Coin } from "cosmjs-types/cosmos/base/v1beta1/coin";
-import { Any } from "../google/protobuf/any";
-export interface StdFee {
-    amount: Coin[];
-    gas: string;
-    granter: string;
-}
-export interface BasicFeeGrantOption {
-    spendLimit?: number;
-    expiration?: Date;
-}
-export interface PeriodicFeeGrantOption {
-    basicSpendLimit?: number;
-    basicExpiration?: Date;
-    periodSeconds: number;
-    periodSpendLimit: number;
-    periodCanSpend: number;
-    periodReset: Date;
-}
+import { Fee } from "cosmjs-types/cosmos/tx/v1beta1/tx";
 export declare const DefaultBasicFeeGrantOption: {
     spendLimit: undefined;
     expiration: undefined;
@@ -28,7 +10,7 @@ export interface TxMisc {
     feeGranter?: string;
 }
 export interface SignAndBroadcastOptions {
-    fee: StdFee;
+    fee: Fee;
     memo: string;
 }
 export interface MsgCreateValidator {
@@ -72,15 +54,17 @@ export declare enum VotingOption {
     VOTE_OPTION_NO_WITH_VETO = 4,
     UNRECOGNIZED = -1
 }
-export interface ParamChangeOption {
-    subspace: string;
-    key: string;
-    value: string;
+export interface ArbitraryVerifyData {
+    chainId: string;
+    accountNumber: string;
+    sequence: string;
+    bodyBytes: string;
+    authInfoBytes: string;
+    signerAddress: string;
+    pubkey: string;
+    signature: string;
 }
-export interface SoftwareUpgradePlan {
-    name: string;
-    time?: Date;
-    height?: bigint;
-    info?: string;
-    upgradedClientState?: Any;
+export interface MsgSignArbitraryData {
+    signer: string;
+    data: Uint8Array;
 }

package/dist/sdk/firmachain/common/accounts.d.ts

@@ -11,7 +11,7 @@ export interface Account {
  * Represents a generic function that takes an `Any` encoded account from the chain
  * and extracts some common `Account` information from it.
  */
-export declare type AccountParser = (any: Any) => Account;
+export type AccountParser = (any: Any) => Account;
 /**
  * Basic implementation of AccountParser. This is supposed to support the most relevant
  * common Cosmos SDK account types. If you need support for exotic account types,

package/dist/sdk/firmachain/common/accounts.js

@@ -11,7 +11,7 @@ function uint64FromProto(input) {
 }
 function accountFromBaseAccount(input) {
     var address = input.address, pubKey = input.pubKey, accountNumber = input.accountNumber, sequence = input.sequence;
-    var pubkey = proto_signing_1.decodeOptionalPubkey(pubKey);
+    var pubkey = (0, proto_signing_1.decodeOptionalPubkey)(pubKey);
     return {
         address: address,
         pubkey: pubkey,
@@ -33,32 +33,32 @@ function accountFromAny(input) {
             return accountFromBaseAccount(auth_1.BaseAccount.decode(value));
         case "/cosmos.auth.v1beta1.ModuleAccount": {
             var baseAccount = auth_1.ModuleAccount.decode(value).baseAccount;
-            utils_1.assert(baseAccount);
+            (0, utils_1.assert)(baseAccount);
             return accountFromBaseAccount(baseAccount);
         }
         // vesting
         case "/cosmos.vesting.v1beta1.BaseVestingAccount": {
             var baseAccount = (_a = vesting_1.BaseVestingAccount.decode(value)) === null || _a === void 0 ? void 0 : _a.baseAccount;
-            utils_1.assert(baseAccount);
+            (0, utils_1.assert)(baseAccount);
             return accountFromBaseAccount(baseAccount);
         }
         case "/cosmos.vesting.v1beta1.ContinuousVestingAccount": {
             var baseAccount = (_c = (_b = vesting_1.ContinuousVestingAccount.decode(value)) === null || _b === void 0 ? void 0 : _b.baseVestingAccount) === null || _c === void 0 ? void 0 : _c.baseAccount;
-            utils_1.assert(baseAccount);
+            (0, utils_1.assert)(baseAccount);
             return accountFromBaseAccount(baseAccount);
         }
         case "/cosmos.vesting.v1beta1.DelayedVestingAccount": {
             var baseAccount = (_e = (_d = vesting_1.DelayedVestingAccount.decode(value)) === null || _d === void 0 ? void 0 : _d.baseVestingAccount) === null || _e === void 0 ? void 0 : _e.baseAccount;
-            utils_1.assert(baseAccount);
+            (0, utils_1.assert)(baseAccount);
             return accountFromBaseAccount(baseAccount);
         }
         case "/cosmos.vesting.v1beta1.PeriodicVestingAccount": {
             var baseAccount = (_g = (_f = vesting_1.PeriodicVestingAccount.decode(value)) === null || _f === void 0 ? void 0 : _f.baseVestingAccount) === null || _g === void 0 ? void 0 : _g.baseAccount;
-            utils_1.assert(baseAccount);
+            (0, utils_1.assert)(baseAccount);
             return accountFromBaseAccount(baseAccount);
         }
         default:
-            throw new Error("Unsupported type: '" + typeUrl + "'");
+            throw new Error("Unsupported type: '".concat(typeUrl, "'"));
     }
 }
 exports.accountFromAny = accountFromAny;

package/dist/sdk/firmachain/common/events.js

@@ -10,8 +10,8 @@ function fromTendermintEvent(event) {
     return {
         type: event.type,
         attributes: event.attributes.map(function (attr) { return ({
-            key: typeof attr.key == "string" ? attr.key : encoding_1.fromUtf8(attr.key, true),
-            value: typeof attr.value == "string" ? attr.value : encoding_1.fromUtf8(attr.value, true),
+            key: typeof attr.key == "string" ? attr.key : (0, encoding_1.fromUtf8)(attr.key, true),
+            value: typeof attr.value == "string" ? attr.value : (0, encoding_1.fromUtf8)(attr.value, true),
         }); }),
     };
 }

package/dist/sdk/firmachain/common/fee.d.ts

@@ -1,5 +1,5 @@
-import { StdFee } from "@cosmjs/amino";
 import { Decimal } from "@cosmjs/math";
+import { Fee } from "cosmjs-types/cosmos/tx/v1beta1/tx";
 /**
  * A gas price, i.e. the price of a single unit of gas. This is typically a fraction of
  * the smallest fee token unit, such as 0.012utoken.
@@ -23,4 +23,4 @@ export declare class GasPrice {
      */
     toString(): string;
 }
-export declare function calculateFee(gasLimit: number, gasPrice: GasPrice | string): StdFee;
+export declare function calculateFee(gasLimit: number, gasPrice: GasPrice | string): Fee;

package/dist/sdk/firmachain/common/fee.js

@@ -76,8 +76,10 @@ function calculateFee(gasLimit, gasPrice) {
     // which we handle by converting from Decimal to string without going through number.
     var amount = gasPriceAmount.multiply(new math_1.Uint53(gasLimit)).ceil().toString();
     return {
-        amount: proto_signing_1.coins(amount, denom),
-        gas: gasLimit.toString(),
+        gasLimit: BigInt(gasLimit),
+        amount: (0, proto_signing_1.coins)(amount, denom),
+        payer: "",
+        granter: ""
     };
 }
 exports.calculateFee = calculateFee;

package/dist/sdk/firmachain/common/index.d.ts

@@ -1,3 +1,2 @@
 export * from './TxCommon';
 export * from './QueryCommon';
-export { AminoConverter, AminoConverters, AminoTypes } from "./aminotypes";

package/dist/sdk/firmachain/common/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[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];
@@ -10,8 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AminoTypes = void 0;
 __exportStar(require("./TxCommon"), exports);
 __exportStar(require("./QueryCommon"), exports);
-var aminotypes_1 = require("./aminotypes");
-Object.defineProperty(exports, "AminoTypes", { enumerable: true, get: function () { return aminotypes_1.AminoTypes; } });

package/dist/sdk/firmachain/common/signing.d.ts

@@ -2,14 +2,18 @@ import { Coin } from "cosmjs-types/cosmos/base/v1beta1/coin";
 import { SignMode } from "cosmjs-types/cosmos/tx/signing/v1beta1/signing";
 import { SignDoc } from "cosmjs-types/cosmos/tx/v1beta1/tx";
 import { Any } from "cosmjs-types/google/protobuf/any";
-/**
- * Creates and serializes an AuthInfo document.
- *
- * This implementation does not support different signing modes for the different signers.
- */
-export declare function makeAuthInfoBytes(signers: ReadonlyArray<{
+export interface SignerData {
     readonly pubkey: Any;
-    readonly sequence: bigint | number;
-}>, feeAmount: readonly Coin[], gasLimit: number, feeGranter: string | undefined, feePayer: string | undefined, signMode?: SignMode): Uint8Array;
+    readonly sequence: number;
+}
+export declare function makeAuthInfoBytes(signers: ReadonlyArray<SignerData>, feeAmount: readonly Coin[], gasLimit: number, granter?: string, payer?: string, signMode?: SignMode): Uint8Array;
 export declare function makeSignDoc(bodyBytes: Uint8Array, authInfoBytes: Uint8Array, chainId: string, accountNumber: number): SignDoc;
-export declare function makeSignBytes({ accountNumber, authInfoBytes, bodyBytes, chainId }: SignDoc): Uint8Array;
+export declare function makeSignBytes(signDoc: SignDoc): Uint8Array;
+/**
+ * Creates AuthInfo bytes for protobuf signing with enhanced type safety
+ */
+export declare function makeAuthInfoBytesProtobuf(signers: ReadonlyArray<SignerData>, feeAmount: readonly Coin[], gasLimit: bigint | number, granter?: string, payer?: string): Uint8Array;
+/**
+ * Creates a protobuf SignDoc with validation
+ */
+export declare function makeSignDocProtobuf(bodyBytes: Uint8Array, authInfoBytes: Uint8Array, chainId: string, accountNumber: bigint | number): SignDoc;