@firmachain/firma-js 0.3.8 → 0.4.0-beta2

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

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -35,6 +46,17 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+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.");
+};
 var __read = (this && this.__read) || function (o, n) {
     var m = typeof Symbol === "function" && o[Symbol.iterator];
     if (!m) return o;
@@ -60,154 +82,1274 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     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.");
-};
+var _a, _b;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.signWithSignerProtobuf = void 0;
+exports.signWithSignerTextual = exports.buildSimulationTxRawLedger = exports.signWithSignerAuto = exports.signWithSignerAmino = void 0;
+var crypto_1 = require("@cosmjs/crypto");
 var signing_1 = require("cosmjs-types/cosmos/tx/signing/v1beta1/signing");
 var tx_1 = require("cosmjs-types/cosmos/tx/v1beta1/tx");
-var encoding_1 = require("@cosmjs/encoding");
 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: [signerInfo],
-        fee: {
-            amount: __spreadArray([], __read(feeAmount), false),
-            gasLimit: BigInt(gasLimit),
-        },
-    };
-    return tx_1.AuthInfo.encode(tx_1.AuthInfo.fromPartial(authInfo)).finish();
-}
-/**
- * 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) {
+var tx_2 = require("cosmjs-types/cosmos/distribution/v1beta1/tx");
+var tx_3 = require("cosmjs-types/cosmos/staking/v1beta1/tx");
+var authz_1 = require("cosmjs-types/cosmos/staking/v1beta1/authz");
+var authz_2 = require("cosmjs-types/cosmos/bank/v1beta1/authz");
+var authz_3 = require("cosmjs-types/cosmos/authz/v1beta1/authz");
+var feegrant_1 = require("cosmjs-types/cosmos/feegrant/v1beta1/feegrant");
+var tx_4 = require("@kintsugi-tech/cosmjs-types/cosmos/gov/v1/tx");
+var tx_5 = require("@kintsugi-tech/cosmjs-types/cosmos/upgrade/v1beta1/tx");
+var amino_1 = require("@cosmjs/amino");
+var stargate_1 = require("@cosmjs/stargate");
+var signing_2 = require("./signing");
+// Two-tier Ledger debug logging.
+//
+// DEBUG_LEDGER=1 — structural tracing only: connect events, typeUrl, field
+// names. Does NOT expose transaction contents. Safe to enable in shared
+// staging environments.
+//
+// DEBUG_LEDGER_CBOR=1 — full transaction dump: rendered screens (addresses,
+// amounts, memos) and CBOR hex bytes. Reveals every detail of the tx being
+// signed. Do NOT enable in production or on shared hosts.
+var DEBUG_LEDGER = (typeof process !== "undefined" && ((_a = process.env) === null || _a === void 0 ? void 0 : _a.DEBUG_LEDGER) === "1") ||
+    (typeof globalThis !== "undefined" && globalThis.DEBUG_LEDGER === true);
+var DEBUG_LEDGER_CBOR = (typeof process !== "undefined" && ((_b = process.env) === null || _b === void 0 ? void 0 : _b.DEBUG_LEDGER_CBOR) === "1") ||
+    (typeof globalThis !== "undefined" && globalThis.DEBUG_LEDGER_CBOR === true);
+// ─── Minimal CBOR encoder ────────────────────────────────────────────────────
+function concatBytes() {
+    var e_1, _a;
+    var arrays = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        arrays[_i] = arguments[_i];
+    }
+    var total = arrays.reduce(function (acc, a) { return acc + a.length; }, 0);
+    var out = new Uint8Array(total);
+    var off = 0;
+    try {
+        for (var arrays_1 = __values(arrays), arrays_1_1 = arrays_1.next(); !arrays_1_1.done; arrays_1_1 = arrays_1.next()) {
+            var a = arrays_1_1.value;
+            out.set(a, off);
+            off += a.length;
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (arrays_1_1 && !arrays_1_1.done && (_a = arrays_1.return)) _a.call(arrays_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return out;
+}
+function cborMajorN(major, n) {
+    var type = major << 5;
+    if (n <= 23)
+        return new Uint8Array([type | n]);
+    if (n <= 0xff)
+        return new Uint8Array([type | 24, n]);
+    if (n <= 0xffff)
+        return new Uint8Array([type | 25, (n >> 8) & 0xff, n & 0xff]);
+    var b = new Uint8Array(5);
+    b[0] = type | 26;
+    new DataView(b.buffer).setUint32(1, n, false);
+    return b;
+}
+function cborUint(n) { return cborMajorN(0, n); }
+function cborText(s) {
+    var utf8 = new TextEncoder().encode(s);
+    return concatBytes(cborMajorN(3, utf8.length), utf8);
+}
+function encodeSingleScreen(s) {
+    var parts = [];
+    var n = 0;
+    if (s.title) {
+        parts.push(cborUint(1), cborText(s.title));
+        n++;
+    }
+    // always include content: Ledger parser requires key 2 after key 1 (title)
+    parts.push(cborUint(2), cborText(s.content));
+    n++;
+    if (s.indent && s.indent > 0) {
+        parts.push(cborUint(3), cborUint(s.indent));
+        n++;
+    }
+    if (s.expert) {
+        parts.push(cborUint(4), new Uint8Array([0xf5]));
+        n++;
+    }
+    return concatBytes.apply(void 0, __spreadArray([cborMajorN(5, n)], __read(parts), false));
+}
+function encodeTextualCbor(screens) {
+    var items = screens.map(encodeSingleScreen);
+    var arr = concatBytes.apply(void 0, __spreadArray([cborMajorN(4, screens.length)], __read(items), false));
+    return concatBytes(cborMajorN(5, 1), cborUint(1), arr);
+}
+function queryCoinMetadata(restUrl, denom) {
+    var _a;
     return __awaiter(this, void 0, void 0, function () {
-        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) {
+        var resp, data, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
                 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()];
+                    if (!restUrl)
+                        return [2 /*return*/, null];
+                    _c.label = 1;
+                case 1:
+                    _c.trys.push([1, 4, , 5]);
+                    return [4 /*yield*/, fetch("".concat(restUrl, "/cosmos/bank/v1beta1/denoms_metadata/").concat(encodeURIComponent(denom)))];
+                case 2:
+                    resp = _c.sent();
+                    if (!resp.ok)
+                        return [2 /*return*/, null];
+                    return [4 /*yield*/, resp.json()];
+                case 3:
+                    data = _c.sent();
+                    return [2 /*return*/, (_a = data.metadata) !== null && _a !== void 0 ? _a : null];
+                case 4:
+                    _b = _c.sent();
+                    return [2 /*return*/, null];
+                case 5: return [2 /*return*/];
+            }
+        });
+    });
+}
+// Matches cosmos SDK math.FormatInt: adds apostrophe thousand separators
+function formatIntWithSep(v) {
+    var neg = v.startsWith("-");
+    var digits = neg ? v.slice(1) : v;
+    if (digits.length <= 3)
+        return v;
+    var groups = [];
+    var mod3 = digits.length % 3;
+    var i = 0;
+    if (mod3 !== 0) {
+        groups.push(digits.slice(0, mod3));
+        i = mod3;
+    }
+    while (i < digits.length) {
+        groups.push(digits.slice(i, i + 3));
+        i += 3;
+    }
+    return (neg ? "-" : "") + groups.join("'");
+}
+function formatOneCoin(amount, denom, meta) {
+    if (!meta)
+        return "".concat(formatIntWithSep(amount), " ").concat(denom);
+    var baseUnit = meta.denom_units.find(function (u) { return u.denom === denom; });
+    var displayName = meta.display;
+    var displayUnit = meta.denom_units.find(function (u) { return u.denom === displayName || u.denom === displayName.toLowerCase(); });
+    if (!baseUnit || !displayUnit)
+        return "".concat(formatIntWithSep(amount), " ").concat(displayName || denom);
+    var exp = displayUnit.exponent - baseUnit.exponent;
+    if (exp <= 0)
+        return "".concat(formatIntWithSep(amount), " ").concat(displayName);
+    var factor = BigInt(Math.pow(10, exp));
+    var big = BigInt(amount);
+    var whole = big / factor;
+    var rem = big % factor;
+    if (rem === BigInt(0))
+        return "".concat(formatIntWithSep(whole.toString()), " ").concat(displayName);
+    var decimals = rem.toString().padStart(exp, "0").replace(/0+$/, "");
+    return "".concat(formatIntWithSep(whole.toString()), ".").concat(decimals, " ").concat(displayName);
+}
+function formatCoins(coins, restUrl) {
+    return __awaiter(this, void 0, void 0, function () {
+        var parts;
+        var _this = this;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (coins.length === 0)
+                        return [2 /*return*/, "0"];
+                    return [4 /*yield*/, Promise.all(coins.map(function (c) { return __awaiter(_this, void 0, void 0, function () {
+                            var meta;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, queryCoinMetadata(restUrl, c.denom)];
+                                    case 1:
+                                        meta = _a.sent();
+                                        return [2 /*return*/, formatOneCoin(c.amount, c.denom, meta)];
+                                }
+                            });
+                        }); }))];
                 case 1:
-                    pubkey = _b.sent();
+                    parts = _a.sent();
+                    return [2 /*return*/, parts.join(", ")];
+            }
+        });
+    });
+}
+// ─── Formatting helpers ───────────────────────────────────────────────────────
+function formatPubkeyHex(pubkey) {
+    var hex = Buffer.from(pubkey).toString("hex").toUpperCase();
+    var groups = [];
+    for (var i = 0; i < hex.length; i += 4)
+        groups.push(hex.slice(i, i + 4));
+    return groups.join(" ");
+}
+function formatGasLimit(gas) {
+    return BigInt(gas).toString().replace(/\B(?=(\d{3})+(?!\d))/g, "'");
+}
+function computeRawBytesHash(bodyBytes, authInfoBytes) {
+    var buf = new Uint8Array(8 + bodyBytes.length + 8 + authInfoBytes.length);
+    var view = new DataView(buf.buffer);
+    view.setBigUint64(0, BigInt(bodyBytes.length), false);
+    buf.set(bodyBytes, 8);
+    view.setBigUint64(8 + bodyBytes.length, BigInt(authInfoBytes.length), false);
+    buf.set(authInfoBytes, 8 + bodyBytes.length + 8);
+    return Buffer.from((0, crypto_1.sha256)(buf)).toString("hex");
+}
+// Cosmos SDK's formatFieldName splits the proto field name on underscore and
+// title-cases only the first word (preserving inner casing with NoLower). So:
+//   standard Cosmos proto `from_address`   → "From address"
+//   Firma custom proto    `tokenURI`       → "TokenURI"  (no underscore → one word)
+// cosmjs-types TS bindings expose field names in camelCase either way, so we
+// can't derive the proto style from the TS key alone — `fromAddress` could come
+// from `from_address` or `fromAddress`. Instead we key off parentTypeUrl: every
+// Firma custom module declares fields in camelCase, so for `/firmachain.*` we
+// preserve the TS key verbatim (just capitalize the first letter). Other
+// prefixes (cosmos, ibc, etc.) follow the standard Cosmos convention of
+// converting camelCase TS → snake proto → sentence case.
+function fieldToDisplayName(name, parentTypeUrl) {
+    if (parentTypeUrl && parentTypeUrl.startsWith("/firmachain.")) {
+        return name.charAt(0).toUpperCase() + name.slice(1);
+    }
+    var snake = name
+        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2")
+        .replace(/([a-z])([A-Z])/g, "$1_$2")
+        .toLowerCase()
+        .replace(/^_/, "");
+    return snake.replace(/_/g, " ").replace(/^./, function (c) { return c.toUpperCase(); });
+}
+// Returns true if v is a plain proto message object (not Duration, Coin, Any, array, or primitive)
+function isPlainProtoMessage(v) {
+    if (typeof v !== "object" || v === null || Array.isArray(v))
+        return false;
+    if ("seconds" in v)
+        return false; // Duration / Timestamp
+    if ("denom" in v && "amount" in v)
+        return false; // Coin
+    if ("typeUrl" in v)
+        return false; // Any
+    return true;
+}
+var VOTE_OPTION_NAMES = {
+    0: "VOTE_OPTION_UNSPECIFIED",
+    1: "VOTE_OPTION_YES",
+    2: "VOTE_OPTION_ABSTAIN",
+    3: "VOTE_OPTION_NO",
+    4: "VOTE_OPTION_NO_WITH_VETO",
+};
+// Cosmos textual renders enum values as their symbolic name (via fd.Enum()), not
+// as the numeric wire value. Decoded proto objects give us only the number, so
+// we map it back to the canonical name here. Without this, authz stake grants
+// rendered the authorizationType as "1" instead of "AUTHORIZATION_TYPE_DELEGATE"
+// and failed TEXTUAL signature verification.
+var STAKE_AUTHORIZATION_TYPE_NAMES = {
+    0: "AUTHORIZATION_TYPE_UNSPECIFIED",
+    1: "AUTHORIZATION_TYPE_DELEGATE",
+    2: "AUTHORIZATION_TYPE_UNDELEGATE",
+    3: "AUTHORIZATION_TYPE_REDELEGATE",
+    4: "AUTHORIZATION_TYPE_CANCEL_UNBONDING_DELEGATION",
+};
+function isLongObject(v) {
+    return typeof v === "object" && v !== null && "low" in v && "high" in v && typeof v.toString === "function";
+}
+// Converts Uint8Array or a JSON-serialized numeric-keyed object back to Uint8Array
+function toUint8ArraySafe(v) {
+    var e_2, _a;
+    if (v instanceof Uint8Array)
+        return v;
+    if (Buffer.isBuffer(v))
+        return new Uint8Array(v);
+    if (typeof v === "object" && v !== null && !Array.isArray(v)) {
+        var obj_1 = v;
+        var keys = Object.keys(obj_1);
+        if (keys.length > 0 && keys.every(function (k) { return !isNaN(Number(k)) && typeof obj_1[k] === "number"; })) {
+            var arr = new Uint8Array(keys.length);
+            try {
+                for (var keys_2 = __values(keys), keys_2_1 = keys_2.next(); !keys_2_1.done; keys_2_1 = keys_2.next()) {
+                    var k = keys_2_1.value;
+                    arr[Number(k)] = obj_1[k];
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (keys_2_1 && !keys_2_1.done && (_a = keys_2.return)) _a.call(keys_2);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return arr;
+        }
+    }
+    return null;
+}
+// Converts proto Duration { seconds: bigint, nanos: number } to amino nanoseconds string
+function durationToAminoNanos(d) {
+    var _a;
+    return (BigInt(d.seconds.toString()) * BigInt(1000000000) + BigInt((_a = d.nanos) !== null && _a !== void 0 ? _a : 0)).toString();
+}
+// Renders proto Duration as human-readable string (matches Cosmos SDK textual renderer).
+// NOTE: parts are joined with ", " (comma + space), not just space. Cosmos SDK's
+// duration renderer uses comma-separated components; an earlier version of this
+// function joined with " " which produced "5 minutes 1 second" instead of the
+// chain's "5 minutes, 1 second" and broke TEXTUAL signature verification for any
+// message containing a non-trivial Duration (gov Params Update was the trigger).
+function renderDuration(d) {
+    var totalSeconds = BigInt(d.seconds.toString());
+    var days = totalSeconds / BigInt(86400);
+    totalSeconds -= days * BigInt(86400);
+    var hours = totalSeconds / BigInt(3600);
+    totalSeconds -= hours * BigInt(3600);
+    var minutes = totalSeconds / BigInt(60);
+    var seconds = totalSeconds - minutes * BigInt(60);
+    var parts = [];
+    if (days > BigInt(0))
+        parts.push("".concat(days, " day").concat(days === BigInt(1) ? "" : "s"));
+    if (hours > BigInt(0))
+        parts.push("".concat(hours, " hour").concat(hours === BigInt(1) ? "" : "s"));
+    if (minutes > BigInt(0))
+        parts.push("".concat(minutes, " minute").concat(minutes === BigInt(1) ? "" : "s"));
+    if (seconds > BigInt(0))
+        parts.push("".concat(seconds, " second").concat(seconds === BigInt(1) ? "" : "s"));
+    return parts.length > 0 ? parts.join(", ") : "0 seconds";
+}
+// Renders proto Timestamp as RFC3339Nano (matches Cosmos SDK textual renderer
+// time.Format(time.RFC3339Nano) — trailing zeros of subsecond precision trimmed).
+// Added because google.protobuf.Timestamp and google.protobuf.Duration share the
+// {seconds, nanos} shape, and the renderer previously treated every such object
+// as a Duration. That produced e.g. "20930 days, 11 hours, 10 minutes, 25 seconds"
+// for an authz.Grant.expiration Timestamp, while the chain reconstructed the
+// equivalent RFC3339 string ("2027-04-22T11:10:25Z") — CBOR bytes diverged and
+// signature verification failed with `code 4 unauthorized`.
+function renderTimestamp(t) {
+    var _a;
+    var secs = BigInt(t.seconds.toString());
+    var nanos = (_a = t.nanos) !== null && _a !== void 0 ? _a : 0;
+    var ms = Number(secs) * 1000;
+    var iso = new Date(ms).toISOString();
+    if (nanos === 0) {
+        return iso.replace(/\.\d+Z$/, "Z");
+    }
+    var nanoStr = String(nanos).padStart(9, "0").replace(/0+$/, "");
+    return iso.replace(/\.\d+Z$/, ".".concat(nanoStr, "Z"));
+}
+// Proto fields that carry google.protobuf.Timestamp (not Duration). Both have
+// the same {seconds, nanos} shape, so field name is the only disambiguator
+// unless we thread proto type info through the renderer.
+var TIMESTAMP_FIELD_NAMES = new Set([
+    "expiration", "expirationTime", "expiration_time",
+    "periodReset", "period_reset",
+    "time",
+]);
+// cosmos.Dec may reach us as either form:
+//   (a) raw 18-decimal fixed-point integer string ("334000000000000000")
+//   (b) already-formatted decimal string ("0.334000000000000000") — this is what
+//       Cosmos SDK's Dec.String() produces and what REST/LCD returns.
+// Both must render to the Cosmos textual form: integer part with ' thousand
+// separators, trailing fractional zeros stripped (e.g. "1'234.56", "0.334").
+//
+// The earlier implementation assumed (a) only. Given input "0.334000000000000000"
+// it produced "0..334" (the leading "0." was treated as the integer slice and a
+// second "." was injected as the decimal separator), breaking TEXTUAL signature
+// verification for gov.Params (quorum/threshold/etc.) update proposals submitted
+// from firma-station where the params come through pre-formatted from the chain.
+function renderCosmosDecString(s) {
+    var neg = s.startsWith("-");
+    var raw = neg ? s.slice(1) : s;
+    var intPart;
+    var fracPart;
+    if (raw.includes(".")) {
+        var _a = __read(raw.split("."), 2), intPartRaw = _a[0], _b = _a[1], fracPartRaw = _b === void 0 ? "" : _b;
+        intPart = intPartRaw.replace(/^0+/, "") || "0";
+        fracPart = fracPartRaw.replace(/0+$/, "");
+    }
+    else {
+        var DEC_PRECISION = 18;
+        var padded = raw.padStart(DEC_PRECISION + 1, "0");
+        intPart = (padded.slice(0, padded.length - DEC_PRECISION).replace(/^0+/, "") || "0");
+        fracPart = padded.slice(padded.length - DEC_PRECISION).replace(/0+$/, "");
+    }
+    var intFormatted = formatIntWithSep(intPart);
+    return (neg ? "-" : "") + (fracPart ? "".concat(intFormatted, ".").concat(fracPart) : intFormatted);
+}
+// Fields known to carry cosmos.Dec values (18-decimal fixed-point strings)
+var COSMOS_DEC_FIELDS = new Set([
+    "minCommissionRate", "min_commission_rate",
+    "quorum", "threshold", "vetoThreshold", "veto_threshold",
+    "minInitialDepositRatio", "min_initial_deposit_ratio",
+    "proposalCancelRatio", "proposal_cancel_ratio",
+    "expeditedThreshold", "expedited_threshold",
+    "minDepositRatio", "min_deposit_ratio",
+]);
+// Fallback decoders for Any-wrapped messages that the per-tx Registry may not
+// know about. TEXTUAL rendering must descend into the inner message and emit
+// each sub-field as its own screen; without a decoder here we would render only
+// the Any typeUrl and omit every sub-field — which leaves our CBOR shorter than
+// the chain's reconstruction and causes `code 4 unauthorized`. The Authorization
+// entries were added specifically for authz Grant flows (stake delegate grant).
+// Entries are typed via `[string, NestedDecoder]` to prevent TS from narrowing
+// the value type to the first entry's proto class (which would then reject the
+// rest, since each proto's `encode` signature accepts a different message shape).
+var NESTED_ANY_DECODERS = new Map([
+    ["/cosmos.distribution.v1beta1.MsgCommunityPoolSpend", tx_2.MsgCommunityPoolSpend],
+    ["/cosmos.staking.v1beta1.MsgUpdateParams", tx_3.MsgUpdateParams],
+    ["/cosmos.staking.v1beta1.StakeAuthorization", authz_1.StakeAuthorization],
+    ["/cosmos.bank.v1beta1.SendAuthorization", authz_2.SendAuthorization],
+    ["/cosmos.authz.v1beta1.GenericAuthorization", authz_3.GenericAuthorization],
+    ["/cosmos.feegrant.v1beta1.BasicAllowance", feegrant_1.BasicAllowance],
+    ["/cosmos.feegrant.v1beta1.PeriodicAllowance", feegrant_1.PeriodicAllowance],
+    ["/cosmos.feegrant.v1beta1.AllowedMsgAllowance", feegrant_1.AllowedMsgAllowance],
+    ["/cosmos.gov.v1.MsgUpdateParams", tx_4.MsgUpdateParams],
+    ["/cosmos.upgrade.v1beta1.MsgSoftwareUpgrade", tx_5.MsgSoftwareUpgrade],
+]);
+function lookupNestedDecoder(typeUrl, registry) {
+    var _a;
+    try {
+        var t = registry.lookupType(typeUrl);
+        if (t)
+            return t;
+    }
+    catch (_b) { }
+    return (_a = NESTED_ANY_DECODERS.get(typeUrl)) !== null && _a !== void 0 ? _a : null;
+}
+function isSingleAnyObject(v) {
+    return (typeof v === "object" &&
+        v !== null &&
+        !Array.isArray(v) &&
+        "typeUrl" in v &&
+        "value" in v &&
+        typeof v.typeUrl === "string");
+}
+// Cosmos textual Any renderer: replace "{Type} object" header with the typeUrl
+// content, then recursively render the inner message's fields at indent+1.
+//
+// Added because previously `renderFieldValue` for an Any object returned only
+// the typeUrl as a single string and never descended into sub-fields. This was
+// fine for repeated-Any fields (MsgSubmitProposal.messages handled separately),
+// but broke on single-Any fields such as authz.Grant.authorization. The chain's
+// textual renderer always expands the Any body, so dropping the sub-fields on
+// the wallet side left the CBOR short and signatures unverifiable.
+function renderSingleAnyField(fieldName, any, baseIndent, registry, restUrl, screens, parentTypeUrl) {
+    return __awaiter(this, void 0, void 0, function () {
+        var decoder, valueBytes, nested, e_3;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    screens.push({ title: fieldToDisplayName(fieldName, parentTypeUrl), content: any.typeUrl, indent: baseIndent });
+                    decoder = lookupNestedDecoder(any.typeUrl, registry);
+                    valueBytes = toUint8ArraySafe(any.value);
+                    if (!decoder || !valueBytes) {
+                        if (!decoder)
+                            console.warn('[Textual] no decoder for nested Any:', any.typeUrl);
+                        return [2 /*return*/];
+                    }
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    nested = decoder.decode(valueBytes);
+                    return [4 /*yield*/, renderMessageFields(nested, baseIndent + 1, registry, restUrl, screens, any.typeUrl)];
+                case 2:
+                    _a.sent();
+                    return [3 /*break*/, 4];
+                case 3:
+                    e_3 = _a.sent();
+                    console.warn('[Textual] nested Any decode error for', any.typeUrl, ':', e_3);
+                    return [3 /*break*/, 4];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
+// Scalar kind label for Cosmos textual formatRepeated.
+// Matches Go's toSentenceCase(fd.Kind().String()) — first letter capitalized,
+// NO pluralization regardless of count (e.g. "3 String", "1 Any", "2 Int64").
+function getScalarKindLabel(item) {
+    if (typeof item === "string")
+        return "String";
+    if (typeof item === "boolean")
+        return "Bool";
+    if (typeof item === "number" || typeof item === "bigint")
+        return "Int64";
+    if (isLongObject(item))
+        return "Int64";
+    if (item instanceof Uint8Array)
+        return "Bytes";
+    return "Item";
+}
+// Renders a repeated scalar/primitive field (repeated string, int, bool, etc.)
+// as cosmos textual formatRepeated output:
+//   "{Title}: {N} {Kind}"        (kind is capitalized singular, no plural)
+//   "{Title} (1/N): {value}"
+//   ...
+//   "End of {Title}"
+//
+// Added for authz StakeAuthorization.Validators.address (repeated string). The
+// old fallback in renderFieldValue JSON-stringified the array to a single line
+// ('["firmavaloper1...", ...]'), which the chain's textual renderer does NOT
+// produce — it emits the count header + per-item screens + terminal. Mismatch
+// → signature verification failed.
+function renderRepeatedScalar(fieldName, items, baseIndent, restUrl, screens, parentTypeUrl) {
+    return __awaiter(this, void 0, void 0, function () {
+        var count, kind, title, i, itemTitle, content;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    count = items.length;
+                    kind = getScalarKindLabel(items[0]);
+                    title = fieldToDisplayName(fieldName, parentTypeUrl);
+                    screens.push({ title: title, content: "".concat(count, " ").concat(kind), indent: baseIndent });
+                    i = 0;
+                    _a.label = 1;
+                case 1:
+                    if (!(i < count)) return [3 /*break*/, 4];
+                    itemTitle = "".concat(title, " (").concat(i + 1, "/").concat(count, ")");
+                    return [4 /*yield*/, renderFieldValue(items[i], restUrl, fieldName, parentTypeUrl)];
+                case 2:
+                    content = _a.sent();
+                    screens.push({ title: itemTitle, content: content, indent: baseIndent + 1 });
+                    _a.label = 3;
+                case 3:
+                    i++;
+                    return [3 /*break*/, 1];
+                case 4:
+                    screens.push({ content: "End of ".concat(title), indent: baseIndent });
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+// True for arrays that should render as formatRepeated multi-screen (not a single
+// comma-joined line like Coin arrays). Applies to primitives and plain messages.
+function isMultiScreenRepeated(v) {
+    if (v.length === 0)
+        return false;
+    var first = v[0];
+    if (typeof first === "string")
+        return true;
+    if (typeof first === "boolean")
+        return true;
+    if (typeof first === "number" || typeof first === "bigint")
+        return true;
+    if (isLongObject(first))
+        return true;
+    return false;
+}
+// Mirrors proto3 "default value skipping" — the chain's textual renderer
+// omits fields that are at their proto3 default (proto3 doesn't write defaults
+// to the wire, so the chain's Message.Has(fd) returns false for them). If the
+// wallet renders them anyway, our CBOR gains extra screens the chain never
+// produces and signature verification fails. The Any/Timestamp/Uint8Array
+// entries below were added incrementally as failure modes surfaced (most
+// notably Plan.upgraded_client_state, an empty Any that blocked Software
+// Upgrade proposals).
+function shouldSkipField(v) {
+    var _a;
+    if (v === "" || v === false)
+        return true;
+    if (Array.isArray(v) && v.length === 0)
+        return true;
+    if (v === 0 || v === BigInt(0))
+        return true;
+    if (v === null || v === undefined)
+        return true;
+    if (isLongObject(v) && v.low === 0 && v.high === 0)
+        return true;
+    if (v instanceof Uint8Array && v.length === 0)
+        return true;
+    if (typeof v === "object" && v !== null && "seconds" in v && !Array.isArray(v)) {
+        var dur = v;
+        if (BigInt(dur.seconds.toString()) === BigInt(0) && ((_a = dur.nanos) !== null && _a !== void 0 ? _a : 0) === 0)
+            return true;
+    }
+    if (typeof v === "object" && v !== null && "typeUrl" in v && !Array.isArray(v)) {
+        var any = v;
+        if (any.typeUrl === "")
+            return true;
+    }
+    return false;
+}
+// Cosmos textual "{TypeName} object" header uses the proto MESSAGE TYPE name,
+// not the field name. Most of our fields coincidentally match (params→Params,
+// plan→Plan, grant→Grant), but some don't (allow_list→Validators). Hardcode
+// the known overrides; fallback to field-derived display name otherwise.
+//
+// Without this override, StakeAuthorization.allow_list rendered as "Allow list
+// object" while the chain produced "Validators object", and every stake-grant
+// tx failed TEXTUAL signature verification. Extend this map when a new
+// field→type name divergence is discovered in a failing tx.
+function getNestedMessageTypeName(fieldName, parentTypeUrl) {
+    if (parentTypeUrl === "/cosmos.staking.v1beta1.StakeAuthorization") {
+        if (fieldName === "allowList" || fieldName === "denyList")
+            return "Validators";
+    }
+    if (parentTypeUrl === "/cosmos.feegrant.v1beta1.PeriodicAllowance") {
+        // `basic` is a nested BasicAllowance message — chain renderer uses the
+        // proto type name "BasicAllowance" in the "{Type} object" header, not the
+        // field-derived "Basic".
+        if (fieldName === "basic")
+            return "BasicAllowance";
+    }
+    return fieldToDisplayName(fieldName, parentTypeUrl);
+}
+// Renders a nested proto message object as title+content header followed by sub-fields.
+// Mirrors Cosmos SDK MessageValueRenderer: "{TypeName} object" header + sub-fields at indent+1.
+function renderNestedProtoMessage(obj, fieldName, baseIndent, restUrl, screens, registry, parentTypeUrl) {
+    return __awaiter(this, void 0, void 0, function () {
+        var displayName, typeName;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    displayName = fieldToDisplayName(fieldName, parentTypeUrl);
+                    typeName = getNestedMessageTypeName(fieldName, parentTypeUrl);
+                    screens.push({ title: displayName, content: "".concat(typeName, " object"), indent: baseIndent });
+                    return [4 /*yield*/, renderMessageFields(obj, baseIndent + 1, registry, restUrl, screens, parentTypeUrl)];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+// Dispatches a single field to the appropriate renderer (Any / repeated scalar /
+// nested message / scalar fallback). Extracted from the three duplicated loops
+// in renderSingleAnyField, renderNestedProtoMessage, and buildTextualScreens.
+function renderSingleField(fieldName, value, baseIndent, registry, restUrl, screens, parentTypeUrl) {
+    return __awaiter(this, void 0, void 0, function () {
+        var content, e_4;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!isSingleAnyObject(value)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, renderSingleAnyField(fieldName, value, baseIndent, registry, restUrl, screens, parentTypeUrl)];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+                case 2:
+                    if (!(Array.isArray(value) && isMultiScreenRepeated(value))) return [3 /*break*/, 4];
+                    return [4 /*yield*/, renderRepeatedScalar(fieldName, value, baseIndent, restUrl, screens, parentTypeUrl)];
+                case 3:
+                    _a.sent();
+                    return [2 /*return*/];
+                case 4:
+                    if (!isPlainProtoMessage(value)) return [3 /*break*/, 6];
+                    return [4 /*yield*/, renderNestedProtoMessage(value, fieldName, baseIndent, restUrl, screens, registry, parentTypeUrl)];
+                case 5:
+                    _a.sent();
+                    return [2 /*return*/];
+                case 6:
+                    _a.trys.push([6, 8, , 9]);
+                    return [4 /*yield*/, renderFieldValue(value, restUrl, fieldName, parentTypeUrl)];
+                case 7:
+                    content = _a.sent();
+                    return [3 /*break*/, 9];
+                case 8:
+                    e_4 = _a.sent();
+                    console.warn('[Textual] renderFieldValue error for field', fieldName, ':', e_4);
+                    content = "(error)";
+                    return [3 /*break*/, 9];
+                case 9:
+                    screens.push({ title: fieldToDisplayName(fieldName, parentTypeUrl), content: content, indent: baseIndent });
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+// Iterates a proto message's fields, skipping proto3-default values and
+// dispatching the rest through renderSingleField.
+function renderMessageFields(fields, baseIndent, registry, restUrl, screens, parentTypeUrl) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, _b, _c, k, v, e_5_1;
+        var e_5, _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    _e.trys.push([0, 5, 6, 7]);
+                    _a = __values(Object.entries(fields)), _b = _a.next();
+                    _e.label = 1;
+                case 1:
+                    if (!!_b.done) return [3 /*break*/, 4];
+                    _c = __read(_b.value, 2), k = _c[0], v = _c[1];
+                    if (shouldSkipField(v))
+                        return [3 /*break*/, 3];
+                    return [4 /*yield*/, renderSingleField(k, v, baseIndent, registry, restUrl, screens, parentTypeUrl)];
+                case 2:
+                    _e.sent();
+                    _e.label = 3;
+                case 3:
+                    _b = _a.next();
+                    return [3 /*break*/, 1];
+                case 4: return [3 /*break*/, 7];
+                case 5:
+                    e_5_1 = _e.sent();
+                    e_5 = { error: e_5_1 };
+                    return [3 /*break*/, 7];
+                case 6:
+                    try {
+                        if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
+                    }
+                    finally { if (e_5) throw e_5.error; }
+                    return [7 /*endfinally*/];
+                case 7: return [2 /*return*/];
+            }
+        });
+    });
+}
+function renderFieldValue(value, restUrl, fieldName, typeUrl) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function () {
+        var tv, coin, meta;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    if (typeof value === "string") {
+                        if (fieldName && COSMOS_DEC_FIELDS.has(fieldName))
+                            return [2 /*return*/, renderCosmosDecString(value)];
+                        return [2 /*return*/, value];
+                    }
+                    if (typeof value === "number" || typeof value === "bigint") {
+                        // VoteOption enum → string name
+                        if (typeUrl === "/cosmos.gov.v1.MsgVote" && fieldName === "option" && typeof value === "number") {
+                            return [2 /*return*/, (_a = VOTE_OPTION_NAMES[value]) !== null && _a !== void 0 ? _a : String(value)];
+                        }
+                        // StakeAuthorization.AuthorizationType enum → string name
+                        if (typeUrl === "/cosmos.staking.v1beta1.StakeAuthorization" && fieldName === "authorizationType" && typeof value === "number") {
+                            return [2 /*return*/, (_b = STAKE_AUTHORIZATION_TYPE_NAMES[value]) !== null && _b !== void 0 ? _b : String(value)];
+                        }
+                        return [2 /*return*/, formatIntWithSep(value.toString())];
+                    }
+                    // Long.js object (protobufjs uint64/int64) → decimal string with apostrophe separators
+                    if (isLongObject(value))
+                        return [2 /*return*/, formatIntWithSep(value.toString())];
+                    if (typeof value === "boolean")
+                        return [2 /*return*/, value ? "True" : "False"];
+                    if (value instanceof Uint8Array)
+                        return [2 /*return*/, "(".concat(value.length, " bytes)")];
+                    if (Array.isArray(value)) {
+                        if (value.length === 0)
+                            return [2 /*return*/, "(none)"];
+                        if (typeof value[0] === "object" &&
+                            value[0] !== null &&
+                            "denom" in value[0] &&
+                            "amount" in value[0]) {
+                            return [2 /*return*/, formatCoins(value, restUrl)];
+                        }
+                        // Any[] — show typeUrls only to avoid Uint8Array serialization
+                        if (typeof value[0] === "object" && value[0] !== null && "typeUrl" in value[0]) {
+                            return [2 /*return*/, value.map(function (a) { return a.typeUrl; }).join(", ")];
+                        }
+                        return [2 /*return*/, JSON.stringify(value)];
+                    }
+                    if (!(typeof value === "object" && value !== null)) return [3 /*break*/, 3];
+                    // proto Duration / Timestamp { seconds, nanos } — identical shape, disambiguated by field name
+                    if ("seconds" in value) {
+                        tv = value;
+                        if (fieldName && TIMESTAMP_FIELD_NAMES.has(fieldName)) {
+                            return [2 /*return*/, renderTimestamp(tv)];
+                        }
+                        return [2 /*return*/, renderDuration(tv)];
+                    }
+                    if (!("denom" in value && "amount" in value)) return [3 /*break*/, 2];
+                    coin = value;
+                    return [4 /*yield*/, queryCoinMetadata(restUrl, coin.denom)];
+                case 1:
+                    meta = _c.sent();
+                    return [2 /*return*/, formatOneCoin(coin.amount, coin.denom, meta)];
+                case 2:
+                    // Any object — show typeUrl only
+                    if ("typeUrl" in value)
+                        return [2 /*return*/, value.typeUrl];
+                    return [2 /*return*/, JSON.stringify(value)];
+                case 3: return [2 /*return*/, String(value !== null && value !== void 0 ? value : "")];
+            }
+        });
+    });
+}
+// ─── Amino signing (SIGN_MODE_LEGACY_AMINO_JSON) ──────────────────────────────
+function signWithSignerAmino(signer, messages, signerData, option, registry) {
+    return __awaiter(this, void 0, void 0, function () {
+        var pubkey, pubkeyProto, aminoTypes, aminoMsgs, stdFee, signDoc, signStr, signature, anyMsgs, bodyBytes, feeCoins, authInfoBytes;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, signer.getPublicKey()];
+                case 1:
+                    pubkey = _a.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;
+                    aminoTypes = buildAminoTypesForCheck();
+                    aminoMsgs = messages.map(function (msg) { return aminoTypes.toAmino(msg); });
+                    stdFee = {
+                        amount: option.fee.amount.map(function (c) { return ({ denom: c.denom, amount: c.amount }); }),
+                        gas: option.fee.gasLimit.toString(),
+                        granter: option.fee.granter || undefined,
+                        payer: option.fee.payer || undefined,
+                    };
+                    signDoc = (0, amino_1.makeSignDoc)(aminoMsgs, stdFee, signerData.chain_id, option.memo || "", signerData.account_number, signerData.sequence);
+                    signStr = Buffer.from((0, amino_1.serializeSignDoc)(signDoc)).toString("utf8");
+                    return [4 /*yield*/, signer.sign(signStr, 0x00)];
+                case 2:
+                    signature = _a.sent();
+                    if (!signature || signature.length === 0)
+                        throw new Error("Signature is empty. Please confirm the transaction on your Ledger device.");
+                    if (signature.length !== 64)
+                        throw new Error("Unexpected signature length: ".concat(signature.length, " bytes (expected 64)"));
+                    anyMsgs = messages.map(function (msg) { return registry.encodeAsAny(msg); });
+                    bodyBytes = tx_1.TxBody.encode(tx_1.TxBody.fromPartial({ messages: anyMsgs, memo: option.memo || "" })).finish();
+                    feeCoins = option.fee.amount.map(function (a) { return ({ denom: a.denom, amount: a.amount }); });
+                    authInfoBytes = (0, signing_2.makeAuthInfoBytes)([{ pubkey: pubkeyProto, sequence: signerData.sequence }], feeCoins, option.fee.gasLimit, option.fee.granter || undefined, option.fee.payer || undefined, signing_1.SignMode.SIGN_MODE_LEGACY_AMINO_JSON);
+                    return [2 /*return*/, tx_1.TxRaw.fromPartial({ bodyBytes: bodyBytes, authInfoBytes: authInfoBytes, signatures: [signature] })];
+            }
+        });
+    });
+}
+exports.signWithSignerAmino = signWithSignerAmino;
+// ─── Textual signing (SIGN_MODE_TEXTUAL, P2=0x01) ─────────────────────────────
+function buildTextualScreens(messages, signerData, option, pubkey, address, bodyBytes, authInfoBytes, restApiAddress, registry) {
+    return __awaiter(this, void 0, void 0, function () {
+        var screens, count, i, msg, fields, MsgType, encodedBytes, _a, _b, _c, k, v, anyArray, anyCount, fieldTitle, j, anyItem, decoder, valueBytes, nested, e_6, e_7_1, feeCoins, _d, _e;
+        var e_7, _f, _g;
+        return __generator(this, function (_h) {
+            switch (_h.label) {
+                case 0:
+                    screens = [];
+                    screens.push({ title: "Chain id", content: signerData.chain_id });
+                    screens.push({ title: "Account number", content: signerData.account_number.toString() });
+                    screens.push({ title: "Sequence", content: signerData.sequence.toString() });
+                    screens.push({ title: "Address", content: address, expert: true });
+                    screens.push({ title: "Public key", content: "/cosmos.crypto.secp256k1.PubKey", expert: true });
+                    screens.push({ title: "Key", content: formatPubkeyHex(pubkey), indent: 1, expert: true });
+                    count = messages.length;
+                    screens.push({ content: "This transaction has ".concat(count, " Message").concat(count === 1 ? "" : "s") });
+                    i = 0;
+                    _h.label = 1;
+                case 1:
+                    if (!(i < messages.length)) return [3 /*break*/, 19];
+                    msg = messages[i];
+                    screens.push({ title: "Message (".concat(i + 1, "/").concat(count, ")"), content: msg.typeUrl, indent: 1 });
+                    fields = {};
+                    MsgType = registry.lookupType(msg.typeUrl);
+                    if (MsgType) {
+                        try {
+                            encodedBytes = registry.encodeAsAny(msg).value;
+                            fields = MsgType.decode(encodedBytes);
+                        }
+                        catch (_j) {
+                            if (msg.value && typeof msg.value === "object") {
+                                fields = msg.value;
+                            }
+                        }
+                    }
+                    else if (msg.value && typeof msg.value === "object") {
+                        fields = msg.value;
+                    }
+                    if (DEBUG_LEDGER)
+                        console.log('[Textual] typeUrl:', msg.typeUrl, 'fields keys:', Object.keys(fields));
+                    _h.label = 2;
                 case 2:
-                    _b.trys.push([2, 9, 10, 11]);
-                    protobufAttempts_1 = __values(protobufAttempts), protobufAttempts_1_1 = protobufAttempts_1.next();
-                    _b.label = 3;
+                    _h.trys.push([2, 16, 17, 18]);
+                    _a = (e_7 = void 0, __values(Object.entries(fields))), _b = _a.next();
+                    _h.label = 3;
                 case 3:
-                    if (!!protobufAttempts_1_1.done) return [3 /*break*/, 8];
-                    attempt = protobufAttempts_1_1.value;
-                    _b.label = 4;
+                    if (!!_b.done) return [3 /*break*/, 15];
+                    _c = __read(_b.value, 2), k = _c[0], v = _c[1];
+                    if (shouldSkipField(v))
+                        return [3 /*break*/, 14];
+                    if (!(Array.isArray(v) &&
+                        v.length > 0 &&
+                        typeof v[0] === "object" &&
+                        v[0] !== null &&
+                        "typeUrl" in v[0] &&
+                        "value" in v[0] &&
+                        toUint8ArraySafe(v[0].value) !== null)) return [3 /*break*/, 12];
+                    anyArray = v;
+                    anyCount = anyArray.length;
+                    fieldTitle = fieldToDisplayName(k, msg.typeUrl);
+                    // Header: "N Any" matches SDK's formatRepeated count screen (getKind = "Any" for google.protobuf.Any)
+                    screens.push({ title: fieldTitle, content: "".concat(anyCount, " Any"), indent: 2 });
+                    j = 0;
+                    _h.label = 4;
                 case 4:
-                    _b.trys.push([4, 6, , 7]);
-                    return [4 /*yield*/, signer.sign(attempt.data)];
+                    if (!(j < anyArray.length)) return [3 /*break*/, 11];
+                    anyItem = anyArray[j];
+                    // Any renderer replaces "{Type} object" header with typeUrl — use typeUrl as content
+                    screens.push({ title: "".concat(fieldTitle, " (").concat(j + 1, "/").concat(anyCount, ")"), content: anyItem.typeUrl, indent: 3 });
+                    decoder = lookupNestedDecoder(anyItem.typeUrl, registry);
+                    valueBytes = toUint8ArraySafe(anyItem.value);
+                    if (!(decoder && valueBytes)) return [3 /*break*/, 9];
+                    _h.label = 5;
                 case 5:
-                    signature = _b.sent();
-                    if (signature && signature.length > 0) {
-                        return [3 /*break*/, 8]; // Success! Exit loop
-                    }
-                    return [3 /*break*/, 7];
+                    _h.trys.push([5, 7, , 8]);
+                    nested = decoder.decode(valueBytes);
+                    return [4 /*yield*/, renderMessageFields(nested, 4, registry, restApiAddress, screens, anyItem.typeUrl)];
                 case 6:
-                    signError_1 = _b.sent();
-                    lastError = signError_1;
-                    return [3 /*break*/, 7]; // Try next format
+                    _h.sent();
+                    return [3 /*break*/, 8];
                 case 7:
-                    protobufAttempts_1_1 = protobufAttempts_1.next();
-                    return [3 /*break*/, 3];
-                case 8: return [3 /*break*/, 11];
+                    e_6 = _h.sent();
+                    console.warn('[Textual] nested Any decode error for', anyItem.typeUrl, ':', e_6);
+                    return [3 /*break*/, 8];
+                case 8: return [3 /*break*/, 10];
                 case 9:
-                    e_1_1 = _b.sent();
-                    e_1 = { error: e_1_1 };
-                    return [3 /*break*/, 11];
+                    console.warn('[Textual] no decoder for nested Any:', anyItem.typeUrl);
+                    _h.label = 10;
                 case 10:
+                    j++;
+                    return [3 /*break*/, 4];
+                case 11:
+                    // Terminal screen for repeated Any field (mirrors SDK formatRepeated terminalScreen)
+                    screens.push({ content: "End of ".concat(fieldTitle), indent: 2 });
+                    return [3 /*break*/, 14];
+                case 12: 
+                // Non-Any[] fields: dispatch through the shared single-field renderer
+                return [4 /*yield*/, renderSingleField(k, v, 2, registry, restApiAddress, screens, msg.typeUrl)];
+                case 13:
+                    // Non-Any[] fields: dispatch through the shared single-field renderer
+                    _h.sent();
+                    _h.label = 14;
+                case 14:
+                    _b = _a.next();
+                    return [3 /*break*/, 3];
+                case 15: return [3 /*break*/, 18];
+                case 16:
+                    e_7_1 = _h.sent();
+                    e_7 = { error: e_7_1 };
+                    return [3 /*break*/, 18];
+                case 17:
                     try {
-                        if (protobufAttempts_1_1 && !protobufAttempts_1_1.done && (_a = protobufAttempts_1.return)) _a.call(protobufAttempts_1);
+                        if (_b && !_b.done && (_f = _a.return)) _f.call(_a);
                     }
-                    finally { if (e_1) throw e_1.error; }
+                    finally { if (e_7) throw e_7.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],
+                case 18:
+                    i++;
+                    return [3 /*break*/, 1];
+                case 19:
+                    // One "End of Message" terminal after all messages (SDK formatRepeated terminal for Envelope.message field)
+                    screens.push({ content: "End of Message" });
+                    // Memo — chain's envelope renderer emits this iff memo != "" (proto3 default skipped).
+                    // Must sit between "End of Message" and "Fees"; otherwise CBOR diverges from the chain's.
+                    if (option.memo && option.memo.length > 0) {
+                        screens.push({ title: "Memo", content: option.memo });
+                    }
+                    feeCoins = option.fee.amount.map(function (c) { return ({ denom: c.denom, amount: c.amount }); });
+                    _e = (_d = screens).push;
+                    _g = { title: "Fees" };
+                    return [4 /*yield*/, formatCoins(feeCoins, restApiAddress)];
+                case 20:
+                    _e.apply(_d, [(_g.content = _h.sent(), _g)]);
+                    // Fee payer / Fee granter — conditional, non-expert, emitted by chain's renderFee.
+                    if (option.fee.payer) {
+                        screens.push({ title: "Fee payer", content: option.fee.payer });
+                    }
+                    if (option.fee.granter) {
+                        screens.push({ title: "Fee granter", content: option.fee.granter });
+                    }
+                    screens.push({ title: "Gas limit", content: formatGasLimit(option.fee.gasLimit), expert: true });
+                    screens.push({
+                        title: "Hash of raw bytes",
+                        content: computeRawBytesHash(bodyBytes, authInfoBytes),
+                        expert: true,
                     });
-                    return [2 /*return*/, txRaw];
+                    return [2 /*return*/, screens];
+            }
+        });
+    });
+}
+// ─── Auto sign mode routing ───────────────────────────────────────────────────
+function buildAminoTypesForCheck() {
+    var baseConverters = __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({}, (0, stargate_1.createBankAminoConverters)()), (0, stargate_1.createStakingAminoConverters)()), (0, stargate_1.createDistributionAminoConverters)()), (0, stargate_1.createGovAminoConverters)()), (0, stargate_1.createIbcAminoConverters)()), (0, stargate_1.createFeegrantAminoConverters)()), (0, stargate_1.createAuthzAminoConverters)()), (0, stargate_1.createVestingAminoConverters)());
+    // Custom converters for nested governance action messages absent from @cosmjs/stargate 0.34.x
+    var nestedMsgConverters = {
+        "/cosmos.distribution.v1beta1.MsgCommunityPoolSpend": {
+            aminoType: "cosmos-sdk/distr/MsgCommunityPoolSpend",
+            toAmino: function (value) { return ({
+                authority: value.authority,
+                recipient: value.recipient,
+                amount: value.amount,
+            }); },
+            fromAmino: function (value) { return ({
+                authority: value.authority,
+                recipient: value.recipient,
+                amount: value.amount,
+            }); },
+        },
+        "/cosmos.staking.v1beta1.MsgUpdateParams": {
+            aminoType: "cosmos-sdk/x/staking/MsgUpdateParams",
+            toAmino: function (value) {
+                var _a, _b;
+                var p = (_a = value.params) !== null && _a !== void 0 ? _a : {};
+                return {
+                    authority: value.authority,
+                    params: {
+                        unbonding_time: p.unbondingTime ? durationToAminoNanos(p.unbondingTime) : "0",
+                        max_validators: p.maxValidators,
+                        max_entries: p.maxEntries,
+                        historical_entries: p.historicalEntries,
+                        bond_denom: p.bondDenom,
+                        min_commission_rate: (_b = p.minCommissionRate) !== null && _b !== void 0 ? _b : "0",
+                    },
+                };
+            },
+            fromAmino: function (value) { return value; },
+        },
+        "/cosmos.gov.v1.MsgUpdateParams": {
+            aminoType: "cosmos-sdk/x/gov/v1/MsgUpdateParams",
+            toAmino: function (value) {
+                var _a, _b, _c, _d, _e, _f;
+                var p = (_a = value.params) !== null && _a !== void 0 ? _a : {};
+                var result = {
+                    authority: value.authority,
+                    params: __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({}, (((_b = p.minDeposit) === null || _b === void 0 ? void 0 : _b.length) ? { min_deposit: p.minDeposit } : {})), (p.maxDepositPeriod ? { max_deposit_period: durationToAminoNanos(p.maxDepositPeriod) } : {})), (p.votingPeriod ? { voting_period: durationToAminoNanos(p.votingPeriod) } : {})), (p.quorum ? { quorum: p.quorum } : {})), (p.threshold ? { threshold: p.threshold } : {})), (p.vetoThreshold ? { veto_threshold: p.vetoThreshold } : {})), (p.minInitialDepositRatio ? { min_initial_deposit_ratio: p.minInitialDepositRatio } : {})), (p.proposalCancelRatio ? { proposal_cancel_ratio: p.proposalCancelRatio } : {})), (p.proposalCancelDest ? { proposal_cancel_dest: p.proposalCancelDest } : {})), (p.expeditedVotingPeriod ? { expedited_voting_period: durationToAminoNanos(p.expeditedVotingPeriod) } : {})), (p.expeditedThreshold ? { expedited_threshold: p.expeditedThreshold } : {})), (((_c = p.expeditedMinDeposit) === null || _c === void 0 ? void 0 : _c.length) ? { expedited_min_deposit: p.expeditedMinDeposit } : {})), { burn_vote_quorum: (_d = p.burnVoteQuorum) !== null && _d !== void 0 ? _d : false, burn_proposal_deposit_prevote: (_e = p.burnProposalDepositPrevote) !== null && _e !== void 0 ? _e : false, burn_vote_veto: (_f = p.burnVoteVeto) !== null && _f !== void 0 ? _f : false }), (p.minDepositRatio ? { min_deposit_ratio: p.minDepositRatio } : {})),
+                };
+                return result;
+            },
+            fromAmino: function (value) { return value; },
+        },
+        "/cosmos.upgrade.v1beta1.MsgSoftwareUpgrade": {
+            aminoType: "cosmos-sdk/MsgSoftwareUpgrade",
+            toAmino: function (value) {
+                var _a, _b, _c, _d;
+                var plan = (_a = value.plan) !== null && _a !== void 0 ? _a : {};
+                return {
+                    authority: value.authority,
+                    plan: {
+                        name: plan.name,
+                        height: (_c = (_b = plan.height) === null || _b === void 0 ? void 0 : _b.toString()) !== null && _c !== void 0 ? _c : "0",
+                        info: (_d = plan.info) !== null && _d !== void 0 ? _d : "",
+                    },
+                };
+            },
+            fromAmino: function (value) { return value; },
+        },
+    };
+    // Build base amino types (with nested msg converters) for use inside the MsgSubmitProposal toAmino
+    var baseAminoTypes = new stargate_1.AminoTypes(__assign(__assign({}, baseConverters), nestedMsgConverters));
+    // All cosmos.gov.v1 messages are absent from @cosmjs/stargate 0.34.x createGovAminoConverters
+    // (only v1beta1 is present).  Without these converters signWithSignerAuto falls back to
+    // SIGN_MODE_TEXTUAL, which the chain cannot verify.
+    var govV1Converters = {
+        "/cosmos.gov.v1.MsgSubmitProposal": {
+            aminoType: "cosmos-sdk/v1/MsgSubmitProposal",
+            toAmino: function (value) {
+                var e_8, _a;
+                var aminoMessages = [];
+                try {
+                    for (var _b = __values((value.messages || [])), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var anyMsg = _c.value;
+                        var valueBytes = toUint8ArraySafe(anyMsg.value);
+                        var decoder = NESTED_ANY_DECODERS.get(anyMsg.typeUrl);
+                        if (decoder && valueBytes) {
+                            var decoded = decoder.decode(valueBytes);
+                            aminoMessages.push(baseAminoTypes.toAmino({ typeUrl: anyMsg.typeUrl, value: decoded }));
+                        }
+                        else {
+                            try {
+                                aminoMessages.push(baseAminoTypes.toAmino(anyMsg));
+                            }
+                            catch (_d) {
+                                throw new Error("Cannot amino-convert nested message: ".concat(anyMsg.typeUrl));
+                            }
+                        }
+                    }
+                }
+                catch (e_8_1) { e_8 = { error: e_8_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    }
+                    finally { if (e_8) throw e_8.error; }
+                }
+                var result = {
+                    proposer: value.proposer,
+                    title: value.title || "",
+                    summary: value.summary || "",
+                };
+                if (aminoMessages.length > 0)
+                    result.messages = aminoMessages;
+                if (value.initialDeposit && value.initialDeposit.length > 0)
+                    result.initial_deposit = value.initialDeposit;
+                if (value.metadata)
+                    result.metadata = value.metadata;
+                if (value.expedited)
+                    result.expedited = value.expedited;
+                return result;
+            },
+            fromAmino: function (value) {
+                var _a, _b, _c, _d;
+                return ({
+                    messages: (_a = value.messages) !== null && _a !== void 0 ? _a : [],
+                    initialDeposit: (_b = value.initial_deposit) !== null && _b !== void 0 ? _b : [],
+                    proposer: value.proposer,
+                    title: value.title,
+                    summary: value.summary,
+                    metadata: (_c = value.metadata) !== null && _c !== void 0 ? _c : "",
+                    expedited: (_d = value.expedited) !== null && _d !== void 0 ? _d : false,
+                });
+            },
+        },
+        "/cosmos.gov.v1.MsgVote": {
+            aminoType: "cosmos-sdk/v1/MsgVote",
+            toAmino: function (value) {
+                var result = {
+                    proposal_id: value.proposalId.toString(),
+                    voter: value.voter,
+                    option: value.option,
+                };
+                if (value.metadata)
+                    result.metadata = value.metadata;
+                return result;
+            },
+            fromAmino: function (value) {
+                var _a;
+                return ({
+                    proposalId: BigInt(value.proposal_id),
+                    voter: value.voter,
+                    option: value.option,
+                    metadata: (_a = value.metadata) !== null && _a !== void 0 ? _a : "",
+                });
+            },
+        },
+        "/cosmos.gov.v1.MsgVoteWeighted": {
+            aminoType: "cosmos-sdk/v1/MsgVoteWeighted",
+            toAmino: function (value) {
+                var result = {
+                    proposal_id: value.proposalId.toString(),
+                    voter: value.voter,
+                    options: value.options,
+                };
+                if (value.metadata)
+                    result.metadata = value.metadata;
+                return result;
+            },
+            fromAmino: function (value) {
+                var _a;
+                return ({
+                    proposalId: BigInt(value.proposal_id),
+                    voter: value.voter,
+                    options: value.options,
+                    metadata: (_a = value.metadata) !== null && _a !== void 0 ? _a : "",
+                });
+            },
+        },
+        "/cosmos.gov.v1.MsgDeposit": {
+            aminoType: "cosmos-sdk/v1/MsgDeposit",
+            toAmino: function (value) { return ({
+                proposal_id: value.proposalId.toString(),
+                depositor: value.depositor,
+                amount: value.amount,
+            }); },
+            fromAmino: function (value) { return ({
+                proposalId: BigInt(value.proposal_id),
+                depositor: value.depositor,
+                amount: value.amount,
+            }); },
+        },
+        "/cosmos.gov.v1.MsgCancelProposal": {
+            aminoType: "cosmos-sdk/v1/MsgCancelProposal",
+            toAmino: function (value) { return ({
+                proposal_id: value.proposalId.toString(),
+                proposer: value.proposer,
+            }); },
+            fromAmino: function (value) { return ({
+                proposalId: BigInt(value.proposal_id),
+                proposer: value.proposer,
+            }); },
+        },
+    };
+    return new stargate_1.AminoTypes(__assign(__assign(__assign({}, baseConverters), nestedMsgConverters), govV1Converters));
+}
+function signWithSignerAuto(signer, messages, signerData, option, registry, restApiAddress, simulate) {
+    if (restApiAddress === void 0) { restApiAddress = ""; }
+    if (simulate === void 0) { simulate = false; }
+    return __awaiter(this, void 0, void 0, function () {
+        var typeUrls;
+        return __generator(this, function (_a) {
+            if (simulate) {
+                return [2 /*return*/, buildSimulationTxRawLedger(signer, messages, signerData, option, registry)];
+            }
+            if (DEBUG_LEDGER) {
+                typeUrls = messages.map(function (m) { return m.typeUrl; }).join(', ');
+                console.log("[Ledger] sign mode: TEXTUAL | msgs: ".concat(typeUrls));
+            }
+            return [2 /*return*/, signWithSignerTextual(signer, messages, signerData, option, registry, restApiAddress)];
+        });
+    });
+}
+exports.signWithSignerAuto = signWithSignerAuto;
+// Builds an unsigned TxRaw for simulation (gas estimation) without prompting the
+// Ledger device. Uses a 64-byte zero signature; the chain skips signature
+// verification in `runTxModeSimulate`, so the simulated gas is still accurate.
+function buildSimulationTxRawLedger(signer, messages, signerData, option, registry) {
+    return __awaiter(this, void 0, void 0, function () {
+        var pubkey, pubkeyProto, anyMsgs, bodyBytes, feeCoins, authInfoBytes;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, signer.getAddressAndPublicKey()];
+                case 1:
+                    pubkey = (_a.sent()).publicKey;
+                    pubkeyProto = {
+                        typeUrl: "/cosmos.crypto.secp256k1.PubKey",
+                        value: keys_1.PubKey.encode({ key: pubkey }).finish(),
+                    };
+                    anyMsgs = messages.map(function (msg) { return registry.encodeAsAny(msg); });
+                    bodyBytes = tx_1.TxBody.encode(tx_1.TxBody.fromPartial({ messages: anyMsgs, memo: option.memo || "" })).finish();
+                    feeCoins = option.fee.amount.map(function (a) { return ({ denom: a.denom, amount: a.amount }); });
+                    authInfoBytes = (0, signing_2.makeAuthInfoBytes)([{ pubkey: pubkeyProto, sequence: signerData.sequence }], feeCoins, option.fee.gasLimit, option.fee.granter || undefined, option.fee.payer || undefined, signing_1.SignMode.SIGN_MODE_DIRECT);
+                    return [2 /*return*/, tx_1.TxRaw.fromPartial({ bodyBytes: bodyBytes, authInfoBytes: authInfoBytes, signatures: [new Uint8Array(64)] })];
+            }
+        });
+    });
+}
+exports.buildSimulationTxRawLedger = buildSimulationTxRawLedger;
+function signWithSignerTextual(signer, messages, signerData, option, registry, restApiAddress) {
+    if (restApiAddress === void 0) { restApiAddress = ""; }
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, address, pubkey, pubkeyProto, anyMsgs, bodyBytes, feeCoins, authInfoBytes, screens, cborBuffer, signature;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, signer.getAddressAndPublicKey()];
+                case 1:
+                    _a = _b.sent(), address = _a.address, pubkey = _a.publicKey;
+                    pubkeyProto = {
+                        typeUrl: "/cosmos.crypto.secp256k1.PubKey",
+                        value: keys_1.PubKey.encode({ key: pubkey }).finish(),
+                    };
+                    anyMsgs = messages.map(function (msg) { return registry.encodeAsAny(msg); });
+                    bodyBytes = tx_1.TxBody.encode(tx_1.TxBody.fromPartial({ messages: anyMsgs, memo: option.memo || "" })).finish();
+                    feeCoins = option.fee.amount.map(function (a) { return ({ denom: a.denom, amount: a.amount }); });
+                    authInfoBytes = (0, signing_2.makeAuthInfoBytes)([{ pubkey: pubkeyProto, sequence: signerData.sequence }], feeCoins, option.fee.gasLimit, option.fee.granter || undefined, option.fee.payer || undefined, signing_1.SignMode.SIGN_MODE_TEXTUAL);
+                    return [4 /*yield*/, buildTextualScreens(messages, signerData, option, pubkey, address, bodyBytes, authInfoBytes, restApiAddress, registry)];
+                case 2:
+                    screens = _b.sent();
+                    if (DEBUG_LEDGER_CBOR) {
+                        console.log('[Textual] === SCREENS DUMP ===');
+                        screens.forEach(function (s, i) {
+                            var parts = ["[".concat(i, "]")];
+                            if (s.title)
+                                parts.push("title=\"".concat(s.title, "\""));
+                            parts.push("content=\"".concat(s.content, "\""));
+                            if (s.indent)
+                                parts.push("indent=".concat(s.indent));
+                            if (s.expert)
+                                parts.push("expert=true");
+                            console.log('[Textual]', parts.join(' '));
+                        });
+                    }
+                    cborBuffer = encodeTextualCbor(screens);
+                    if (DEBUG_LEDGER_CBOR) {
+                        console.log('[Textual] CBOR hex:', Array.from(cborBuffer).map(function (b) { return b.toString(16).padStart(2, '0'); }).join(''));
+                    }
+                    return [4 /*yield*/, signer.sign(cborBuffer, 0x01)];
+                case 3:
+                    signature = _b.sent();
+                    if (!signature || signature.length === 0)
+                        throw new Error("Signature is empty. Please confirm the transaction on your Ledger device.");
+                    if (signature.length !== 64)
+                        throw new Error("Unexpected signature length: ".concat(signature.length, " bytes (expected 64)"));
+                    return [2 /*return*/, tx_1.TxRaw.fromPartial({ bodyBytes: bodyBytes, authInfoBytes: authInfoBytes, signatures: [signature] })];
             }
         });
     });
 }
-exports.signWithSignerProtobuf = signWithSignerProtobuf;
+exports.signWithSignerTextual = signWithSignerTextual;