diff --git a/app/src/crypto.c b/app/src/crypto.c
index 94073890..a3c86695 100644
--- a/app/src/crypto.c
+++ b/app/src/crypto.c
@@ -215,7 +215,7 @@ zxerr_t crypto_hashSigSection(const signature_section_t *signature_section, cons
             break;
         }
         case Address:
-            CHECK_CX_OK(cx_sha256_update(&sha256, signature_section->address.ptr, signature_section->address.len));
+            CHECK_CX_OK(cx_sha256_update(&sha256, signature_section->addressBytes.ptr, signature_section->addressBytes.len));
             break;
 
         default:
diff --git a/app/src/parser_impl_common.h b/app/src/parser_impl_common.h
index c458000b..6b41b0a6 100644
--- a/app/src/parser_impl_common.h
+++ b/app/src/parser_impl_common.h
@@ -100,9 +100,10 @@ parser_error_t readFieldSizeU16(parser_context_t *ctx, uint16_t *size);
 parser_error_t checkTag(parser_context_t *ctx, uint8_t expectedTag);
 parser_error_t readPubkey(parser_context_t *ctx, bytes_t *pubkey);
 
-parser_error_t readToken(const bytes_t *token, const char **symbol);
+parser_error_t readToken(const AddressAlt *token, const char **symbol);
 parser_error_t readAddress(bytes_t pubkeyHash, char *address, uint16_t addressLen);
-parser_error_t encodeAddress(AddressAlt *addr, char *address, uint16_t addressLen);
+parser_error_t readAddressAlt(parser_context_t *ctx, AddressAlt *obj);
+parser_error_t encodeAddress(const AddressAlt *addr, char *address, uint16_t addressLen);
 parser_error_t readVote(bytes_t *vote, yay_vote_type_e type, char *strVote, uint16_t strVoteLen);
 
 parser_error_t readHeader(parser_context_t *ctx, parser_tx_t *v);
diff --git a/app/src/parser_impl_txn.c b/app/src/parser_impl_txn.c
index aa77f5c9..c55bd763 100644
--- a/app/src/parser_impl_txn.c
+++ b/app/src/parser_impl_txn.c
@@ -910,14 +910,14 @@ parser_error_t readIbcTokenHash(parser_context_t *ctx, IbcTokenHash *obj) {
   return parser_ok;
 }
 
-parser_error_t readToken(const bytes_t *token, const char **symbol) {
+parser_error_t readToken(const AddressAlt *token, const char **symbol) {
     if (token == NULL || symbol == NULL) {
         return parser_unexpected_value;
     }
 
     // Convert token to address
     char address[53] = {0};
-    CHECK_ERROR(readAddress(*token, address, sizeof(address)))
+    CHECK_ERROR(encodeAddress(token, address, sizeof(address)))
 
     *symbol = NULL;
 
@@ -990,7 +990,7 @@ parser_error_t readAddress(bytes_t pubkeyHash, char *address, uint16_t addressLe
     return parser_ok;
 }
 
-parser_error_t encodeAddress(AddressAlt *addr, char *address, uint16_t addressLen) {
+parser_error_t encodeAddress(const AddressAlt *addr, char *address, uint16_t addressLen) {
     uint8_t tmpBuffer[ADDRESS_LEN_BYTES] = {0};
 
     switch (addr->tag) {
@@ -1145,8 +1145,7 @@ static parser_error_t readPGFInternal(parser_context_t *ctx, pgf_payment_action_
     }
 
     // Read target
-    paymentAction->internal.address.len = ADDRESS_LEN_BYTES;
-    CHECK_ERROR(readBytes(ctx, &paymentAction->internal.address.ptr, paymentAction->internal.address.len))
+    CHECK_ERROR(readAddressAlt(ctx, &paymentAction->internal.address))
     // Read amount
     paymentAction->internal.amount.len = 32;
     CHECK_ERROR(readBytes(ctx, &paymentAction->internal.amount.ptr, paymentAction->internal.amount.len))
@@ -1240,9 +1239,8 @@ static parser_error_t readInitProposalTxn(const bytes_t *data, const section_t *
     v->initProposal.content_sechash.len = HASH_LEN;
     CHECK_ERROR(readBytes(&ctx, &v->initProposal.content_sechash.ptr, v->initProposal.content_sechash.len))
 
-    // Author, should be of length ADDRESS_LEN_BYTES
-    v->initProposal.author.len = ADDRESS_LEN_BYTES;
-    CHECK_ERROR(readBytes(&ctx, &v->initProposal.author.ptr, v->initProposal.author.len))
+    // Author
+    CHECK_ERROR(readAddressAlt(&ctx, &v->initProposal.author))
 
     // Proposal type
     v->initProposal.has_proposal_code = 0;
@@ -1264,11 +1262,11 @@ static parser_error_t readInitProposalTxn(const bytes_t *data, const section_t *
             v->initProposal.pgf_steward_actions.len = 0;
 
             uint8_t add_rem_discriminant = 0;
-            bytes_t tmpBytes = {.ptr = NULL, .len = ADDRESS_LEN_BYTES};
+            AddressAlt tmpBytes;
             for (uint32_t i = 0; i < v->initProposal.pgf_steward_actions_num; i++) {
                 CHECK_ERROR(readByte(&ctx, &add_rem_discriminant))
-                CHECK_ERROR(readBytes(&ctx, &tmpBytes.ptr, tmpBytes.len))
-                v->initProposal.pgf_steward_actions.len += 1 + ADDRESS_LEN_BYTES;
+                CHECK_ERROR(readAddressAlt(&ctx, &tmpBytes))
+                v->initProposal.pgf_steward_actions.len = ctx.buffer + ctx.offset - v->initProposal.pgf_steward_actions.ptr;
             }
             break;
         }
@@ -1353,17 +1351,19 @@ static parser_error_t readVoteProposalTxn(const bytes_t *data, parser_tx_t *v) {
         return parser_unexpected_value;
     }
 
-    // Voter, should be of length ADDRESS_LEN_BYTES
-    v->voteProposal.voter.len = ADDRESS_LEN_BYTES;
-    CHECK_ERROR(readBytes(&ctx, &v->voteProposal.voter.ptr, v->voteProposal.voter.len))
+    CHECK_ERROR(readAddressAlt(&ctx, &v->voteProposal.voter))
 
     // Delegators
     v->voteProposal.number_of_delegations = 0;
     CHECK_ERROR(readUint32(&ctx, &v->voteProposal.number_of_delegations))
     v->voteProposal.delegations.len = 0;
     if (v->voteProposal.number_of_delegations > 0 ){
-        v->voteProposal.delegations.len = ADDRESS_LEN_BYTES*v->voteProposal.number_of_delegations;
-        CHECK_ERROR(readBytes(&ctx, &v->voteProposal.delegations.ptr, v->voteProposal.delegations.len))
+          v->voteProposal.delegations.ptr = ctx.buffer + ctx.offset;
+        for (uint32_t i = 0; i < v->voteProposal.number_of_delegations; i++) {
+          AddressAlt tmp;
+          CHECK_ERROR(readAddressAlt(&ctx, &tmp))
+        }
+        v->voteProposal.delegations.len = ctx.buffer + ctx.offset - v->voteProposal.delegations.ptr;
     }
 
     if ((ctx.offset != ctx.bufferLen)) {
@@ -1390,16 +1390,14 @@ static parser_error_t readWithdrawTxn(bytes_t *buffer, parser_tx_t *v) {
     parser_context_t ctx = {.buffer = buffer->ptr, .bufferLen = buffer->len, .offset = 0, .tx_obj = NULL};
 
     // Validator
-    v->withdraw.validator.len = ADDRESS_LEN_BYTES;
-    CHECK_ERROR(readBytes(&ctx, &v->withdraw.validator.ptr, v->withdraw.validator.len))
+    CHECK_ERROR(readAddressAlt(&ctx, &v->withdraw.validator))
 
     // Does this tx specify the source
     CHECK_ERROR(readByte(&ctx, &v->withdraw.has_source))
 
     // Source
     if (v->withdraw.has_source != 0) {
-        v->withdraw.source.len = ADDRESS_LEN_BYTES;
-        CHECK_ERROR(readBytes(&ctx, &v->withdraw.source.ptr, v->withdraw.source.len))
+        CHECK_ERROR(readAddressAlt(&ctx, &v->withdraw.source))
     }
 
     if (ctx.offset != ctx.bufferLen) {
@@ -1412,8 +1410,7 @@ static parser_error_t readCommissionChangeTxn(bytes_t *buffer, parser_tx_t *v) {
     parser_context_t ctx = {.buffer = buffer->ptr, .bufferLen = buffer->len, .offset = 0, .tx_obj = NULL};
 
     // Validator
-    v->commissionChange.validator.len = ADDRESS_LEN_BYTES;
-    CHECK_ERROR(readBytes(&ctx, &v->commissionChange.validator.ptr, v->commissionChange.validator.len))
+    CHECK_ERROR(readAddressAlt(&ctx, &v->commissionChange.validator))
 
     // Read new commission rate
     v->commissionChange.new_rate.len = 32;
@@ -1434,8 +1431,7 @@ static parser_error_t readUpdateVPTxn(const bytes_t *data, const section_t *extr
     parser_context_t ctx = {.buffer = data->ptr, .bufferLen = data->len, .offset = 0, .tx_obj = NULL};
 
     // Address
-    v->updateVp.address.len = ADDRESS_LEN_BYTES;
-    CHECK_ERROR(readBytes(&ctx, &v->updateVp.address.ptr, v->updateVp.address.len))
+    CHECK_ERROR(readAddressAlt(&ctx, &v->updateVp.address))
 
     // VP code hash (optional)
     CHECK_ERROR(readByte(&ctx, &v->updateVp.has_vp_code));
@@ -1498,8 +1494,7 @@ static parser_error_t readTransferTxn(const bytes_t *data, parser_tx_t *v) {
     CHECK_ERROR(readAddressAlt(&ctx, &v->transfer.target_address))
 
     // Token
-    v->transfer.token.len = ADDRESS_LEN_BYTES;
-    CHECK_ERROR(readBytes(&ctx, &v->transfer.token.ptr, v->transfer.token.len))
+    CHECK_ERROR(readAddressAlt(&ctx, &v->transfer.token))
     // Get symbol from token
     CHECK_ERROR(readToken(&v->transfer.token, &v->transfer.symbol))
 
@@ -1541,8 +1536,7 @@ static parser_error_t readResignSteward(const bytes_t *data, tx_resign_steward_t
     parser_context_t ctx = {.buffer = data->ptr, .bufferLen = data->len, .offset = 0, .tx_obj = NULL};
 
     // Validator
-    resignSteward->steward.len = ADDRESS_LEN_BYTES;
-    CHECK_ERROR(readBytes(&ctx, &resignSteward->steward.ptr, resignSteward->steward.len))
+    CHECK_ERROR(readAddressAlt(&ctx, &resignSteward->steward))
     if (ctx.offset != ctx.bufferLen) {
         return parser_unexpected_characters;
     }
@@ -1553,8 +1547,7 @@ static parser_error_t readChangeConsensusKey(const bytes_t *data, tx_consensus_k
     parser_context_t ctx = {.buffer = data->ptr, .bufferLen = data->len, .offset = 0, .tx_obj = NULL};
 
     // Validator
-    consensusKeyChange->validator.len = ADDRESS_LEN_BYTES;
-    CHECK_ERROR(readBytes(&ctx, &consensusKeyChange->validator.ptr, consensusKeyChange->validator.len))
+    CHECK_ERROR(readAddressAlt(&ctx, &consensusKeyChange->validator))
     // Consensus key
     CHECK_ERROR(readPubkey(&ctx, &consensusKeyChange->consensus_key))
 
@@ -1568,18 +1561,17 @@ static parser_error_t readUpdateStewardCommission(const bytes_t *data, tx_update
     parser_context_t ctx = {.buffer = data->ptr, .bufferLen = data->len, .offset = 0, .tx_obj = NULL};
 
     // Address
-    updateStewardCommission->steward.len = ADDRESS_LEN_BYTES;
-    CHECK_ERROR(readBytes(&ctx, &updateStewardCommission->steward.ptr, updateStewardCommission->steward.len))
+    CHECK_ERROR(readAddressAlt(&ctx, &updateStewardCommission->steward))
 
     updateStewardCommission->commissionLen = 0;
     CHECK_ERROR(readUint32(&ctx, &updateStewardCommission->commissionLen))
 
     updateStewardCommission->commission.ptr = ctx.buffer + ctx.offset;
     const uint16_t startOffset = ctx.offset;
-    bytes_t address = {.ptr = NULL, .len = ADDRESS_LEN_BYTES};
+    AddressAlt address;
     bytes_t amount = {.ptr = NULL, .len = 32};
     for (uint32_t i = 0; i < updateStewardCommission->commissionLen; i++) {
-        CHECK_ERROR(readBytes(&ctx, &address.ptr, address.len))
+        CHECK_ERROR(readAddressAlt(&ctx, &address))
         CHECK_ERROR(readBytes(&ctx, &amount.ptr, amount.len))
     }
     updateStewardCommission->commission.len = ctx.offset - startOffset;
@@ -1594,8 +1586,7 @@ static parser_error_t readChangeValidatorMetadata(const bytes_t *data, tx_metada
     parser_context_t ctx = {.buffer = data->ptr, .bufferLen = data->len, .offset = 0, .tx_obj = NULL};
 
     // Validator
-    metadataChange->validator.len = ADDRESS_LEN_BYTES;
-    CHECK_ERROR(readBytes(&ctx, &metadataChange->validator.ptr, metadataChange->validator.len))
+    CHECK_ERROR(readAddressAlt(&ctx, &metadataChange->validator))
 
     uint32_t tmpValue = 0;
     // The validator email
@@ -1701,8 +1692,7 @@ static parser_error_t readBridgePoolTransfer(const bytes_t *data, tx_bridge_pool
     bridgePoolTransfer->recipient.len = ETH_ADDRESS_LEN;
     CHECK_ERROR(readBytes(&ctx, &bridgePoolTransfer->recipient.ptr, bridgePoolTransfer->recipient.len))
 
-    bridgePoolTransfer->sender.len = ADDRESS_LEN_BYTES;
-    CHECK_ERROR(readBytes(&ctx, &bridgePoolTransfer->sender.ptr, bridgePoolTransfer->sender.len))
+    CHECK_ERROR(readAddressAlt(&ctx, &bridgePoolTransfer->sender))
 
     bridgePoolTransfer->amount.len = 32;
     CHECK_ERROR(readBytes(&ctx, &bridgePoolTransfer->amount.ptr, bridgePoolTransfer->amount.len))
@@ -1710,11 +1700,9 @@ static parser_error_t readBridgePoolTransfer(const bytes_t *data, tx_bridge_pool
     bridgePoolTransfer->gasAmount.len = 32;
     CHECK_ERROR(readBytes(&ctx, &bridgePoolTransfer->gasAmount.ptr, bridgePoolTransfer->gasAmount.len))
 
-    bridgePoolTransfer->gasPayer.len = ADDRESS_LEN_BYTES;
-    CHECK_ERROR(readBytes(&ctx, &bridgePoolTransfer->gasPayer.ptr, bridgePoolTransfer->gasPayer.len))
+    CHECK_ERROR(readAddressAlt(&ctx, &bridgePoolTransfer->gasPayer))
 
-    bridgePoolTransfer->gasToken.len = ADDRESS_LEN_BYTES;
-    CHECK_ERROR(readBytes(&ctx, &bridgePoolTransfer->gasToken.ptr, bridgePoolTransfer->gasToken.len))
+    CHECK_ERROR(readAddressAlt(&ctx, &bridgePoolTransfer->gasToken))
 
     if (ctx.offset != ctx.bufferLen) {
         return parser_unexpected_characters;
@@ -1890,8 +1878,7 @@ parser_error_t readHeader(parser_context_t *ctx, parser_tx_t *v) {
     CHECK_ERROR(readByte(ctx, &v->transaction.header.fees.denom))
 
     // Fee.address
-    v->transaction.header.fees.address.len = ADDRESS_LEN_BYTES;
-    CHECK_ERROR(readBytes(ctx, &v->transaction.header.fees.address.ptr, v->transaction.header.fees.address.len))
+    CHECK_ERROR(readAddressAlt(ctx, &v->transaction.header.fees.address))
     // Get symbol from token
     CHECK_ERROR(readToken(&v->transaction.header.fees.address, &v->transaction.header.fees.symbol))
 
@@ -2022,8 +2009,9 @@ static parser_error_t readSignatureSection(parser_context_t *ctx, signature_sect
         break;
 
         case Address:
-        signature->address.len = ADDRESS_LEN_BYTES;
-        CHECK_ERROR(readBytes(ctx, &signature->address.ptr, signature->address.len))
+          signature->addressBytes.ptr = ctx->buffer + ctx->offset;
+        CHECK_ERROR(readAddressAlt(ctx, &signature->address))
+          signature->addressBytes.len = ctx->buffer + ctx->offset - signature->addressBytes.ptr;
         break;
 
         default:
diff --git a/app/src/parser_print_common.c b/app/src/parser_print_common.c
index 5e396c68..292682bb 100644
--- a/app/src/parser_print_common.c
+++ b/app/src/parser_print_common.c
@@ -91,7 +91,7 @@ parser_error_t printAddress( bytes_t pubkeyHash,
     return parser_ok;
 }
 
-parser_error_t printAddressAlt( AddressAlt *addr,
+parser_error_t printAddressAlt( const AddressAlt *addr,
                              char *outVal, uint16_t outValLen,
                              uint8_t pageIdx, uint8_t *pageCount) {
 
@@ -288,13 +288,13 @@ parser_error_t printProposal(const tx_init_proposal_t *initProposal, uint8_t dis
 
     } else if (initProposal->proposal_type == PGFSteward) {
         uint8_t add_rem_discriminant = 0;
-        bytes_t tmpBytes = {.ptr = NULL, .len = ADDRESS_LEN_BYTES};
+        AddressAlt tmpBytes;
         parser_context_t tmpCtx = { .buffer = initProposal->pgf_steward_actions.ptr,
                                     .bufferLen = initProposal->pgf_steward_actions.len,
                                     .offset = 0};
         for (uint32_t i = 0; i < displayIdx; i++) {
             CHECK_ERROR(readByte(&tmpCtx, &add_rem_discriminant))
-            CHECK_ERROR(readBytes(&tmpCtx, &tmpBytes.ptr, tmpBytes.len))
+            CHECK_ERROR(readAddressAlt(&tmpCtx, &tmpBytes))
         }
 
         // Add = 0 | Remove = 1
@@ -303,7 +303,7 @@ parser_error_t printProposal(const tx_init_proposal_t *initProposal, uint8_t dis
             snprintf(outKey, outKeyLen, "Remove");
         }
 
-        CHECK_ERROR(printAddress(tmpBytes, outVal, outValLen, pageIdx, pageCount))
+        CHECK_ERROR(printAddressAlt(&tmpBytes, outVal, outValLen, pageIdx, pageCount))
 
     } else if (initProposal->proposal_type == PGFPayment) {
         pgf_payment_action_t pgfPayment = {0};
@@ -340,7 +340,7 @@ parser_error_t printProposal(const tx_init_proposal_t *initProposal, uint8_t dis
 
                 case 1:
                     snprintf(outKey, outKeyLen, "Target");
-                    CHECK_ERROR(printAddress(pgfPayment.internal.address, outVal, outValLen, pageIdx, pageCount))
+                    CHECK_ERROR(printAddressAlt(&pgfPayment.internal.address, outVal, outValLen, pageIdx, pageCount))
                     break;
 
                 case 0:
@@ -447,7 +447,7 @@ parser_error_t printExpert( const parser_context_t *ctx,
                 CHECK_ERROR(printAmount(&ctx->tx_obj->transaction.header.fees.amount, true, ctx->tx_obj->transaction.header.fees.denom, "", outVal, outValLen, pageIdx, pageCount))
             } else {
                 snprintf(outKey, outKeyLen, "Fee token");
-                CHECK_ERROR(printAddress(ctx->tx_obj->transaction.header.fees.address, outVal, outValLen, pageIdx, pageCount))
+                CHECK_ERROR(printAddressAlt(&ctx->tx_obj->transaction.header.fees.address, outVal, outValLen, pageIdx, pageCount))
             }
             break;
         }
diff --git a/app/src/parser_print_common.h b/app/src/parser_print_common.h
index 572337e1..5c11c7a5 100644
--- a/app/src/parser_print_common.h
+++ b/app/src/parser_print_common.h
@@ -50,7 +50,7 @@ parser_error_t printAddress(bytes_t pubkeyHash,
                             char *outVal, uint16_t outValLen,
                             uint8_t pageIdx, uint8_t *pageCount);
 
-parser_error_t printAddressAlt(AddressAlt *addr,
+parser_error_t printAddressAlt(const AddressAlt *addr,
                             char *outVal, uint16_t outValLen,
                             uint8_t pageIdx, uint8_t *pageCount);
 
diff --git a/app/src/parser_print_txn.c b/app/src/parser_print_txn.c
index ee064db1..dfc6d03d 100644
--- a/app/src/parser_print_txn.c
+++ b/app/src/parser_print_txn.c
@@ -56,11 +56,11 @@ static parser_error_t printBondTxn( const parser_context_t *ctx,
                 return parser_unexpected_value;
             }
             snprintf(outKey, outKeyLen, "Source");
-            CHECK_ERROR(printAddress(ctx->tx_obj->bond.source, outVal, outValLen, pageIdx, pageCount))
+            CHECK_ERROR(printAddressAlt(&ctx->tx_obj->bond.source, outVal, outValLen, pageIdx, pageCount))
             break;
         case 2:
             snprintf(outKey, outKeyLen, "Validator");
-            CHECK_ERROR(printAddress(ctx->tx_obj->bond.validator, outVal, outValLen, pageIdx, pageCount))
+            CHECK_ERROR(printAddressAlt(&ctx->tx_obj->bond.validator, outVal, outValLen, pageIdx, pageCount))
             break;
         case 3:
             snprintf(outKey, outKeyLen, "Amount");
@@ -103,7 +103,7 @@ static parser_error_t printResignSteward( const parser_context_t *ctx,
             break;
         case 1:
             snprintf(outKey, outKeyLen, "Steward");
-            CHECK_ERROR(printAddress(ctx->tx_obj->resignSteward.steward, outVal, outValLen, pageIdx, pageCount))
+            CHECK_ERROR(printAddressAlt(&ctx->tx_obj->resignSteward.steward, outVal, outValLen, pageIdx, pageCount))
             break;
         case 2:
             CHECK_ERROR(printMemo(ctx, outKey, outKeyLen, outVal, outValLen, pageIdx, pageCount))
@@ -159,7 +159,7 @@ static parser_error_t printTransferTxn( const parser_context_t *ctx,
                                     outVal, outValLen, pageIdx, pageCount))
             } else {
                 snprintf(outKey, outKeyLen, "Token");
-                CHECK_ERROR(printAddress(ctx->tx_obj->transfer.token, outVal, outValLen, pageIdx, pageCount))
+                CHECK_ERROR(printAddressAlt(&ctx->tx_obj->transfer.token, outVal, outValLen, pageIdx, pageCount))
             }
             break;
         case 4:
@@ -349,7 +349,7 @@ static parser_error_t printInitProposalTxn(  const parser_context_t *ctx,
 
         case 3:
             snprintf(outKey, outKeyLen, "Author");
-            CHECK_ERROR(printAddress(ctx->tx_obj->initProposal.author, outVal, outValLen, pageIdx, pageCount))
+            CHECK_ERROR(printAddressAlt(&ctx->tx_obj->initProposal.author, outVal, outValLen, pageIdx, pageCount))
             break;
         case 4:
             snprintf(outKey, outKeyLen, "Voting start epoch");
@@ -469,7 +469,7 @@ static parser_error_t printVoteProposalTxn(  const parser_context_t *ctx,
             break;
         case 3:
             snprintf(outKey, outKeyLen, "Voter");
-            CHECK_ERROR(printAddress(voteProposal->voter, outVal, outValLen, pageIdx, pageCount))
+            CHECK_ERROR(printAddressAlt(&voteProposal->voter, outVal, outValLen, pageIdx, pageCount))
             break;
         case 4:
             if (voteProposal->number_of_delegations == 0) {
@@ -479,9 +479,13 @@ static parser_error_t printVoteProposalTxn(  const parser_context_t *ctx,
             if (displayIdx - adjustedDisplayIdx >= voteProposal->number_of_delegations) {
                 return parser_value_out_of_range;
             }
-            const uint16_t delegationOffset = (displayIdx - adjustedDisplayIdx) * ADDRESS_LEN_BYTES;
-            const bytes_t tmpProposal = {.ptr = voteProposal->delegations.ptr + delegationOffset, .len = ADDRESS_LEN_BYTES};
-            CHECK_ERROR(printAddress(tmpProposal, outVal, outValLen, pageIdx, pageCount))
+            parser_context_t tmpCtx = {.buffer = voteProposal->delegations.ptr, .bufferLen = voteProposal->delegations.len, .offset = 0};
+            AddressAlt tmpProposal;
+            for(uint32_t i = 0; i <= displayIdx - adjustedDisplayIdx; i++) {
+              CHECK_ERROR(readAddressAlt(&tmpCtx, &tmpProposal))
+            }
+            
+            CHECK_ERROR(printAddressAlt(&tmpProposal, outVal, outValLen, pageIdx, pageCount))
             break;
         case 5:
             CHECK_ERROR(printMemo(ctx, outKey, outKeyLen, outVal, outValLen, pageIdx, pageCount))
@@ -564,7 +568,7 @@ static parser_error_t printChangeConsensusKeyTxn( const parser_context_t *ctx,
             break;
         case 2:
             snprintf(outKey, outKeyLen, "Validator");
-            CHECK_ERROR(printAddress(ctx->tx_obj->consensusKeyChange.validator, outVal, outValLen, pageIdx, pageCount))
+            CHECK_ERROR(printAddressAlt(&ctx->tx_obj->consensusKeyChange.validator, outVal, outValLen, pageIdx, pageCount))
             break;
         case 3:
             CHECK_ERROR(printMemo(ctx, outKey, outKeyLen, outVal, outValLen, pageIdx, pageCount))
@@ -602,7 +606,7 @@ static parser_error_t printUnjailValidatorTxn(const parser_context_t *ctx,
             break;
         case 1:
             snprintf(outKey, outKeyLen, "Validator");
-            CHECK_ERROR(printAddress(ctx->tx_obj->unjailValidator.validator, outVal, outValLen, pageIdx, pageCount))
+            CHECK_ERROR(printAddressAlt(&ctx->tx_obj->unjailValidator.validator, outVal, outValLen, pageIdx, pageCount))
             break;
         case 2:
             CHECK_ERROR(printMemo(ctx, outKey, outKeyLen, outVal, outValLen, pageIdx, pageCount))
@@ -642,7 +646,7 @@ static parser_error_t printActivateValidator(const parser_context_t *ctx,
             break;
         case 1:
             snprintf(outKey, outKeyLen, "Validator");
-            CHECK_ERROR(printAddress(ctx->tx_obj->activateValidator.validator, outVal, outValLen, pageIdx, pageCount))
+            CHECK_ERROR(printAddressAlt(&ctx->tx_obj->activateValidator.validator, outVal, outValLen, pageIdx, pageCount))
             break;
         case 2:
             CHECK_ERROR(printMemo(ctx, outKey, outKeyLen, outVal, outValLen, pageIdx, pageCount))
@@ -699,7 +703,7 @@ static parser_error_t printUpdateVPTxn(const parser_context_t *ctx,
             break;
         case 1:
             snprintf(outKey, outKeyLen, "Address");
-            CHECK_ERROR(printAddress(updateVp->address, outVal, outValLen, pageIdx, pageCount))
+            CHECK_ERROR(printAddressAlt(&updateVp->address, outVal, outValLen, pageIdx, pageCount))
             break;
 
         case 2: {
@@ -783,7 +787,7 @@ static parser_error_t printBecomeValidatorTxn(  const parser_context_t *ctx,
             break;
         case 1: {
             snprintf(outKey, outKeyLen, "Address");
-            CHECK_ERROR(printAddress(ctx->tx_obj->becomeValidator.address, outVal, outValLen, pageIdx, pageCount))
+            CHECK_ERROR(printAddressAlt(&ctx->tx_obj->becomeValidator.address, outVal, outValLen, pageIdx, pageCount))
             break;
         }
         case 2: {
@@ -898,11 +902,11 @@ static parser_error_t printWithdrawTxn( const parser_context_t *ctx,
                 return parser_unexpected_value;
             }
             snprintf(outKey, outKeyLen, "Source");
-            CHECK_ERROR(printAddress(withdraw->source, outVal, outValLen, pageIdx, pageCount))
+            CHECK_ERROR(printAddressAlt(&withdraw->source, outVal, outValLen, pageIdx, pageCount))
             break;
         case 2:
             snprintf(outKey, outKeyLen, "Validator");
-            CHECK_ERROR(printAddress(withdraw->validator, outVal, outValLen, pageIdx, pageCount))
+            CHECK_ERROR(printAddressAlt(&withdraw->validator, outVal, outValLen, pageIdx, pageCount))
             break;
         case 3:
             CHECK_ERROR(printMemo(ctx, outKey, outKeyLen, outVal, outValLen, pageIdx, pageCount))
@@ -945,7 +949,7 @@ static parser_error_t printCommissionChangeTxn( const parser_context_t *ctx,
             break;
         case 2:
             snprintf(outKey, outKeyLen, "Validator");
-            CHECK_ERROR(printAddress(ctx->tx_obj->commissionChange.validator, outVal, outValLen, pageIdx, pageCount))
+            CHECK_ERROR(printAddressAlt(&ctx->tx_obj->commissionChange.validator, outVal, outValLen, pageIdx, pageCount))
             break;
         case 3:
             CHECK_ERROR(printMemo(ctx, outKey, outKeyLen, outVal, outValLen, pageIdx, pageCount))
@@ -1071,7 +1075,7 @@ static parser_error_t printUpdateStewardCommission( const parser_context_t *ctx,
 
     if (displayIdx == 1) {
         snprintf(outKey, outKeyLen, "Steward");
-        CHECK_ERROR(printAddress(ctx->tx_obj->updateStewardCommission.steward, outVal, outValLen, pageIdx, pageCount))
+        CHECK_ERROR(printAddressAlt(&ctx->tx_obj->updateStewardCommission.steward, outVal, outValLen, pageIdx, pageCount))
         return parser_ok;
     }
 
@@ -1079,19 +1083,19 @@ static parser_error_t printUpdateStewardCommission( const parser_context_t *ctx,
     if (displayIdx >= 2 &&  displayIdx < (2 + 2 * updateStewardCommission->commissionLen)) {
         const bool printValidator = displayIdx % 2 == 0;
 
-        bytes_t address = {.ptr = NULL, .len = ADDRESS_LEN_BYTES};
+        AddressAlt address;
         bytes_t amount = {.ptr = NULL, .len = 32};
         parser_context_t tmpCtx = { .buffer = updateStewardCommission->commission.ptr,
                                     .bufferLen = updateStewardCommission->commission.len,
                                     .offset = 0};
         for (uint8_t i = 0; i < displayIdx / 2; i++) {
-            CHECK_ERROR(readBytes(&tmpCtx, &address.ptr, address.len))
+            CHECK_ERROR(readAddressAlt(&tmpCtx, &address))
             CHECK_ERROR(readBytes(&tmpCtx, &amount.ptr, amount.len))
         }
 
         if (printValidator) {
             snprintf(outKey, outKeyLen, "Validator");
-            CHECK_ERROR(printAddress(address, outVal, outValLen, pageIdx, pageCount));
+            CHECK_ERROR(printAddressAlt(&address, outVal, outValLen, pageIdx, pageCount));
         } else {
             snprintf(outKey, outKeyLen, "Commission Rate");
             CHECK_ERROR(printAmount(&amount, true, POS_DECIMAL_PRECISION, "", outVal, outValLen, pageIdx, pageCount))
@@ -1157,7 +1161,7 @@ static parser_error_t printChangeValidatorMetadata(  const parser_context_t *ctx
             break;
         case 1: {
             snprintf(outKey, outKeyLen, "Validator");
-            printAddress(metadataChange->validator, outVal, outValLen, pageIdx, pageCount);
+            printAddressAlt(&metadataChange->validator, outVal, outValLen, pageIdx, pageCount);
             break;
         }
         case 2: {
@@ -1239,7 +1243,7 @@ static parser_error_t printBridgePoolTransfer(  const parser_context_t *ctx,
         }
         case 2: {
             snprintf(outKey, outKeyLen, "Transfer Sender");
-            CHECK_ERROR(printAddress(bridgePoolTransfer->sender, outVal, outValLen, pageIdx, pageCount))
+            CHECK_ERROR(printAddressAlt(&bridgePoolTransfer->sender, outVal, outValLen, pageIdx, pageCount))
             break;
         }
         case 3: {
@@ -1265,12 +1269,12 @@ static parser_error_t printBridgePoolTransfer(  const parser_context_t *ctx,
         }
           case 6: {
             snprintf(outKey, outKeyLen, "Gas Payer");
-            CHECK_ERROR(printAddress(bridgePoolTransfer->gasPayer, outVal, outValLen, pageIdx, pageCount))
+            CHECK_ERROR(printAddressAlt(&bridgePoolTransfer->gasPayer, outVal, outValLen, pageIdx, pageCount))
             break;
         }
         case 7: {
             snprintf(outKey, outKeyLen, "Gas Token");
-            CHECK_ERROR(printAddress(bridgePoolTransfer->gasToken, outVal, outValLen, pageIdx, pageCount))
+            CHECK_ERROR(printAddressAlt(&bridgePoolTransfer->gasToken, outVal, outValLen, pageIdx, pageCount))
             break;
         }
         case 8: {
diff --git a/app/src/parser_txdef.h b/app/src/parser_txdef.h
index 34b4694e..b60f896b 100644
--- a/app/src/parser_txdef.h
+++ b/app/src/parser_txdef.h
@@ -60,7 +60,8 @@ typedef struct {
     uint8_t idx;
     concatenated_hashes_t hashes;
     signer_discriminant_e signerDiscriminant;
-    bytes_t address;
+    AddressAlt address;
+  bytes_t addressBytes;
     uint32_t pubKeysLen;
     bytes_t pubKeys;
     uint32_t signaturesLen;
diff --git a/app/src/parser_types.h b/app/src/parser_types.h
index ef669dbb..a39023f4 100644
--- a/app/src/parser_types.h
+++ b/app/src/parser_types.h
@@ -98,13 +98,105 @@ typedef struct {
     uint16_t len;
 } bytes_t;
 
+typedef struct {
+  uint8_t f0[20];
+} IbcTokenHash;
+
+typedef struct {
+  uint8_t f0[20];
+} EthAddress;
+
+typedef struct {
+  uint8_t f0[20];
+} PublicKeyHash;
+
+typedef struct {
+  uint8_t hash[20];
+} EstablishedAddress;
+
+typedef struct {
+  EstablishedAddress f0;
+} AddressEstablished;
+
+typedef struct {
+  PublicKeyHash f0;
+} ImplicitAddress;
+
+typedef struct {
+  ImplicitAddress f0;
+} AddressImplicit;
+
+typedef struct {
+  EthAddress f0;
+} InternalAddressErc20;
+
+typedef struct {} InternalAddressEthBridge;
+
+typedef struct {} InternalAddressEthBridgePool;
+
+typedef struct {} InternalAddressGovernance;
+
+typedef struct {} InternalAddressIbc;
+
+typedef struct {
+  IbcTokenHash f0;
+} InternalAddressIbcToken;
+
+typedef struct {} InternalAddressMasp;
+
+typedef struct {} InternalAddressMultitoken;
+
+typedef struct {
+  EthAddress f0;
+} InternalAddressNut;
+
+typedef struct {} InternalAddressParameters;
+
+typedef struct {} InternalAddressPgf;
+
+typedef struct {} InternalAddressPoS;
+
+typedef struct {} InternalAddressPosSlashPool;
+
+typedef struct {
+  uint8_t tag;
+  union {
+  InternalAddressPoS PoS;
+  InternalAddressPosSlashPool PosSlashPool;
+  InternalAddressParameters Parameters;
+  InternalAddressIbc Ibc;
+  InternalAddressIbcToken IbcToken;
+  InternalAddressGovernance Governance;
+  InternalAddressEthBridge EthBridge;
+  InternalAddressEthBridgePool EthBridgePool;
+  InternalAddressErc20 Erc20;
+  InternalAddressNut Nut;
+  InternalAddressMultitoken Multitoken;
+  InternalAddressPgf Pgf;
+  InternalAddressMasp Masp;
+  };
+} InternalAddress;
+
+typedef struct {
+  InternalAddress f0;
+} AddressInternal;
+
+typedef struct {
+  uint8_t tag;
+  union {
+  AddressEstablished Established;
+  AddressImplicit Implicit;
+  AddressInternal Internal;
+  };
+} AddressAlt;
+
 typedef struct {
     uint8_t *ptr;
     uint32_t len;
 } mut_bytes_t;
 
 typedef struct {
-    bytes_t address;
+    AddressAlt address;
     bytes_t amount;
 } pgf_internal_t;
 
@@ -129,7 +221,7 @@ typedef struct {
     uint64_t proposal_id;
     bytes_t content_hash;
     bytes_t content_sechash;
-    bytes_t author;
+    AddressAlt author;
     uint64_t voting_start_epoch;
     uint64_t voting_end_epoch;
     uint64_t grace_epoch;
@@ -174,7 +266,7 @@ typedef struct {
     bytes_t councils;
     bytes_t eth_bridge_signature;
     // proposal author address
-    bytes_t voter;
+    AddressAlt voter;
     // Delegator addresses
     uint32_t number_of_delegations;
     bytes_t delegations;
@@ -191,16 +283,16 @@ typedef struct {
 } tx_init_account_t;
 
 typedef struct {
-    bytes_t validator;
+    AddressAlt validator;
     bytes_t amount;
     uint8_t has_source;
-    bytes_t source;
+    AddressAlt source;
 } tx_bond_t;
 
 typedef struct {
-    bytes_t src_validator;
-    bytes_t dest_validator;
-    bytes_t owner;
+    AddressAlt src_validator;
+    AddressAlt dest_validator;
+    AddressAlt owner;
     bytes_t amount;
 } tx_redelegation_t;
 
@@ -211,24 +303,24 @@ typedef struct {
 } tx_reveal_pubkey_t;
 
 typedef struct {
-    bytes_t validator;
+    AddressAlt validator;
     uint8_t has_source;
-    bytes_t source;
+    AddressAlt source;
 } tx_withdraw_t;
 
 typedef struct {
-    bytes_t validator;
+    AddressAlt validator;
 } tx_unjail_validator_t;
 
 typedef tx_unjail_validator_t tx_activate_validator_t;
 
 typedef struct {
-    bytes_t validator;
+    AddressAlt validator;
     bytes_t new_rate;
 } tx_commission_change_t;
 
 typedef struct {
-    bytes_t address;
+    AddressAlt address;
     bytes_t consensus_key;
     bytes_t eth_cold_key;
     bytes_t eth_hot_key;
@@ -243,7 +335,7 @@ typedef struct {
 } tx_become_validator_t;
 
 typedef struct {
-    bytes_t address;
+    AddressAlt address;
     uint32_t number_of_pubkeys;
     bytes_t pubkeys;
     uint8_t has_threshold;
@@ -255,103 +347,11 @@ typedef struct {
     const char* vp_type_text;
 } tx_update_vp_t;
 
-typedef struct {
-  uint8_t f0[20];
-} IbcTokenHash;
-
-typedef struct {
-  uint8_t f0[20];
-} EthAddress;
-
-typedef struct {
-  uint8_t f0[20];
-} PublicKeyHash;
-
-typedef struct {
-  uint8_t hash[20];
-} EstablishedAddress;
-
-typedef struct {
-  EstablishedAddress f0;
-} AddressEstablished;
-
-typedef struct {
-  PublicKeyHash f0;
-} ImplicitAddress;
-
-typedef struct {
-  ImplicitAddress f0;
-} AddressImplicit;
-
-typedef struct {
-  EthAddress f0;
-} InternalAddressErc20;
-
-typedef struct {} InternalAddressEthBridge;
-
-typedef struct {} InternalAddressEthBridgePool;
-
-typedef struct {} InternalAddressGovernance;
-
-typedef struct {} InternalAddressIbc;
-
-typedef struct {
-  IbcTokenHash f0;
-} InternalAddressIbcToken;
-
-typedef struct {} InternalAddressMasp;
-
-typedef struct {} InternalAddressMultitoken;
-
-typedef struct {
-  EthAddress f0;
-} InternalAddressNut;
-
-typedef struct {} InternalAddressParameters;
-
-typedef struct {} InternalAddressPgf;
-
-typedef struct {} InternalAddressPoS;
-
-typedef struct {} InternalAddressPosSlashPool;
-
-typedef struct {
-  uint8_t tag;
-  union {
-  InternalAddressPoS PoS;
-  InternalAddressPosSlashPool PosSlashPool;
-  InternalAddressParameters Parameters;
-  InternalAddressIbc Ibc;
-  InternalAddressIbcToken IbcToken;
-  InternalAddressGovernance Governance;
-  InternalAddressEthBridge EthBridge;
-  InternalAddressEthBridgePool EthBridgePool;
-  InternalAddressErc20 Erc20;
-  InternalAddressNut Nut;
-  InternalAddressMultitoken Multitoken;
-  InternalAddressPgf Pgf;
-  InternalAddressMasp Masp;
-  };
-} InternalAddress;
-
-typedef struct {
-  InternalAddress f0;
-} AddressInternal;
-
-typedef struct {
-  uint8_t tag;
-  union {
-  AddressEstablished Established;
-  AddressImplicit Implicit;
-  AddressInternal Internal;
-  };
-} AddressAlt;
-
 typedef struct {
     AddressAlt source_address;
     AddressAlt target_address;
     // Transferred token address
-    bytes_t token;
+    AddressAlt token;
     uint8_t has_sub_prefix;
     bytes_t sub_prefix;
     bytes_t amount;
@@ -377,16 +377,16 @@ typedef struct {
 } tx_ibc_t;
 
 typedef struct {
-    bytes_t steward;
+    AddressAlt steward;
 } tx_resign_steward_t;
 
 typedef struct {
-    bytes_t validator;
+    AddressAlt validator;
     bytes_t consensus_key;
 } tx_consensus_key_change_t;
 
 typedef struct {
-    bytes_t steward;
+    AddressAlt steward;
     uint32_t commissionLen;
     bytes_t commission;
 } tx_update_steward_commission_t;
@@ -395,16 +395,16 @@ typedef struct {
     uint8_t kind;
     bytes_t asset;
     bytes_t recipient;
-    bytes_t sender;
+    AddressAlt sender;
     bytes_t amount;
 
-    bytes_t gasToken;
+    AddressAlt gasToken;
     bytes_t gasAmount;
-    bytes_t gasPayer;
+    AddressAlt gasPayer;
 } tx_bridge_pool_transfer_t;
 
   typedef struct {
-    bytes_t validator;
+    AddressAlt validator;
     bytes_t email;
     bytes_t description;
     bytes_t website;
@@ -415,7 +415,7 @@ typedef struct {
   } tx_metadata_change_t;
 
 typedef struct {
-    bytes_t address;
+    AddressAlt address;
     bytes_t amount;
     uint8_t denom;
     const char *symbol;
diff --git a/app/src/txn_delegation.c b/app/src/txn_delegation.c
index d3fc2265..15f625ef 100644
--- a/app/src/txn_delegation.c
+++ b/app/src/txn_delegation.c
@@ -26,8 +26,7 @@ parser_error_t readBondUnbond(const bytes_t *data, parser_tx_t *v) {
     parser_context_t ctx = {.buffer = data->ptr, .bufferLen = data->len, .offset = 0, .tx_obj = NULL};
 
     // Validator
-    v->bond.validator.len = ADDRESS_LEN_BYTES;
-    CHECK_ERROR(readBytes(&ctx, &v->bond.validator.ptr, v->bond.validator.len))
+    CHECK_ERROR(readAddressAlt(&ctx, &v->bond.validator))
 
     // Amount
     v->bond.amount.len = 32;
@@ -36,8 +35,7 @@ parser_error_t readBondUnbond(const bytes_t *data, parser_tx_t *v) {
     // Source
     readByte(&ctx, &v->bond.has_source);
     if (v->bond.has_source) {
-        v->bond.source.len = ADDRESS_LEN_BYTES;
-        CHECK_ERROR(readBytes(&ctx, &v->bond.source.ptr, v->bond.source.len))
+        CHECK_ERROR(readAddressAlt(&ctx, &v->bond.source))
         v->bond.has_source = 1;
     }
 
@@ -52,16 +50,13 @@ parser_error_t readRedelegate(const bytes_t *data, tx_redelegation_t *redelegati
     parser_context_t ctx = {.buffer = data->ptr, .bufferLen = data->len, .offset = 0, .tx_obj = NULL};
 
     // Source validator
-    redelegation->src_validator.len = ADDRESS_LEN_BYTES;
-    CHECK_ERROR(readBytes(&ctx, &redelegation->src_validator.ptr, redelegation->src_validator.len))
+    CHECK_ERROR(readAddressAlt(&ctx, &redelegation->src_validator))
 
     // Destination validator
-    redelegation->dest_validator.len = ADDRESS_LEN_BYTES;
-    CHECK_ERROR(readBytes(&ctx, &redelegation->dest_validator.ptr, redelegation->dest_validator.len))
+    CHECK_ERROR(readAddressAlt(&ctx, &redelegation->dest_validator))
 
     // Owner
-    redelegation->owner.len = ADDRESS_LEN_BYTES;
-    CHECK_ERROR(readBytes(&ctx, &redelegation->owner.ptr, redelegation->owner.len))
+    CHECK_ERROR(readAddressAlt(&ctx, &redelegation->owner))
 
     // Amount
     redelegation->amount.len = 32;
@@ -100,15 +95,15 @@ parser_error_t printRedelegate(const parser_context_t *ctx,
             break;
         case 1:
             snprintf(outKey, outKeyLen, "Source Validator");
-            CHECK_ERROR(printAddress(redelegation->src_validator, outVal, outValLen, pageIdx, pageCount))
+            CHECK_ERROR(printAddressAlt(&redelegation->src_validator, outVal, outValLen, pageIdx, pageCount))
             break;
         case 2:
             snprintf(outKey, outKeyLen, "Destination Validator");
-            CHECK_ERROR(printAddress(redelegation->dest_validator, outVal, outValLen, pageIdx, pageCount))
+            CHECK_ERROR(printAddressAlt(&redelegation->dest_validator, outVal, outValLen, pageIdx, pageCount))
             break;
         case 3:
             snprintf(outKey, outKeyLen, "Owner");
-            CHECK_ERROR(printAddress(redelegation->owner, outVal, outValLen, pageIdx, pageCount))
+            CHECK_ERROR(printAddressAlt(&redelegation->owner, outVal, outValLen, pageIdx, pageCount))
             break;
         case 4:
             snprintf(outKey, outKeyLen, "Amount");
diff --git a/app/src/txn_validator.c b/app/src/txn_validator.c
index db68ae41..9e1d6983 100644
--- a/app/src/txn_validator.c
+++ b/app/src/txn_validator.c
@@ -23,8 +23,7 @@ parser_error_t readBecomeValidator(const bytes_t *data, const section_t *extra_d
     }
     parser_context_t ctx = {.buffer = data->ptr, .bufferLen = data->len, .offset = 0, .tx_obj = NULL};
 
-    v->becomeValidator.address.len = ADDRESS_LEN_BYTES;
-    CHECK_ERROR(readBytes(&ctx, &v->becomeValidator.address.ptr, v->becomeValidator.address.len))
+    CHECK_ERROR(readAddressAlt(&ctx, &v->becomeValidator.address))
 
     CHECK_ERROR(readPubkey(&ctx, &v->becomeValidator.consensus_key))
 
@@ -123,11 +122,7 @@ parser_error_t readUnjailValidator(const bytes_t *data, parser_tx_t *v) {
     parser_context_t ctx = {.buffer = data->ptr, .bufferLen = data->len, .offset = 0, .tx_obj = NULL};
 
     // Address
-    if (ctx.bufferLen != ADDRESS_LEN_BYTES) {
-        return parser_unexpected_value;
-    }
-    v->revealPubkey.pubkey.len = ADDRESS_LEN_BYTES;
-    CHECK_ERROR(readBytes(&ctx, &v->unjailValidator.validator.ptr, v->unjailValidator.validator.len))
+    CHECK_ERROR(readAddressAlt(&ctx, &v->unjailValidator.validator))
 
     if (ctx.offset != ctx.bufferLen) {
         return parser_unexpected_characters;
@@ -143,12 +138,7 @@ parser_error_t readActivateValidator(const bytes_t *data, tx_activate_validator_
     parser_context_t ctx = {.buffer = data->ptr, .bufferLen = data->len, .offset = 0, .tx_obj = NULL};
 
     // Address
-    if (ctx.bufferLen != ADDRESS_LEN_BYTES) {
-        return parser_unexpected_value;
-    }
-
-    txObject->validator.len = ADDRESS_LEN_BYTES;
-    CHECK_ERROR(readBytes(&ctx, &txObject->validator.ptr, txObject->validator.len))
+    CHECK_ERROR(readAddressAlt(&ctx, &txObject->validator))
 
     if (ctx.offset != ctx.bufferLen) {
         return parser_unexpected_characters;