diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 0493fafd11..4a3a153c38 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -81,9 +81,6 @@ discuss your intended approach for solving the problem in the comments for an ex
 
 - **Add documentation.** Document your changes with code doc comments or in existing guides.
 
-- **Update the CHANGELOG** for all enhancements and bug fixes. Include the corresponding date, issue
-  number if one exists and current version if any. Check the format of the [CHANGELOG](.docs/CHANGELOG.md).
-
 - **Target the `development` branch.** The repo's default branch is still `main`, but do **not**
   open pull requests against `main`. Branch from and
   [submit your pull request](https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/creating-a-pull-request-from-a-fork)
diff --git a/cmd/rpc/server.go b/cmd/rpc/server.go
index 95b3090400..f1d4e9ec6c 100644
--- a/cmd/rpc/server.go
+++ b/cmd/rpc/server.go
@@ -33,7 +33,7 @@ const (
 
 	// uses golang's semver naming convention
 	// https://pkg.go.dev/golang.org/x/mod/semver
-	SoftwareVersion = "v0.1.27+beta"
+	SoftwareVersion = "v0.1.28+beta"
 	ContentType     = "Content-MessageType"
 	ApplicationJSON = "application/json; charset=utf-8"
 
diff --git a/cmd/rpc/web/explorer/package.json b/cmd/rpc/web/explorer/package.json
index 242af38ac6..5157131760 100644
--- a/cmd/rpc/web/explorer/package.json
+++ b/cmd/rpc/web/explorer/package.json
@@ -7,6 +7,7 @@
     "dev": "vite",
     "build": "tsc -b && vite build",
     "lint": "eslint .",
+    "test:clipboard": "node --test tests/clipboard.test.cjs",
     "preview": "vite preview",
     "type-check": "tsc --noEmit"
   },
diff --git a/cmd/rpc/web/explorer/src/components/account/AccountDetailHeader.tsx b/cmd/rpc/web/explorer/src/components/account/AccountDetailHeader.tsx
index 7fdb8fe73b..4627ccda88 100644
--- a/cmd/rpc/web/explorer/src/components/account/AccountDetailHeader.tsx
+++ b/cmd/rpc/web/explorer/src/components/account/AccountDetailHeader.tsx
@@ -1,6 +1,8 @@
 import React, { useState } from 'react'
 import { motion } from 'framer-motion'
 import { Check, Copy } from 'lucide-react'
+import toast from 'react-hot-toast'
+import { copyText } from '../../lib/clipboard'
 import AnimatedNumber from '../AnimatedNumber'
 import accountDetailTexts from '../../data/accountDetail.json'
 import { cnpyDetailFormat, toCNPY } from '../../lib/utils'
@@ -37,11 +39,11 @@ const AccountDetailHeader: React.FC<AccountDetailHeaderProps> = ({ account }) =>
 
     const copyToClipboard = async () => {
         try {
-            await navigator.clipboard.writeText(account.address)
+            await copyText(account.address)
             setCopied(true)
             setTimeout(() => setCopied(false), 2000)
-        } catch (err) {
-            console.error('Failed to copy address:', err)
+        } catch {
+            toast.error('Unable to copy address')
         }
     }
 
diff --git a/cmd/rpc/web/explorer/src/components/block/BlockDetailInfo.tsx b/cmd/rpc/web/explorer/src/components/block/BlockDetailInfo.tsx
index 25154133b1..1cbc3d8acf 100644
--- a/cmd/rpc/web/explorer/src/components/block/BlockDetailInfo.tsx
+++ b/cmd/rpc/web/explorer/src/components/block/BlockDetailInfo.tsx
@@ -2,6 +2,7 @@ import React, { useState } from 'react'
 import { motion } from 'framer-motion'
 import { Copy } from 'lucide-react'
 import toast from 'react-hot-toast'
+import { copyText } from '../../lib/clipboard'
 import blockDetailTexts from '../../data/blockDetail.json'
 import { GREEN_BADGE_CLASS } from '../ui/badgeStyles'
 import { formatCNPY } from '../../lib/utils'
@@ -26,16 +27,20 @@ const CopySymbol = () => <Copy aria-hidden="true" className="h-3.5 w-3.5" stroke
 
 const BlockDetailInfo: React.FC<BlockDetailInfoProps> = ({ block, blockData }) => {
     const [viewMode, setViewMode] = useState<'decoded' | 'raw'>('decoded')
-    const copyToClipboard = (text: string) => {
-        navigator.clipboard.writeText(text)
-        toast.success('Copied to clipboard!', {
-            icon: '📋',
-            style: {
-                background: '#1a1a1a',
-                color: '#fafafa',
-                border: '1px solid #45ca46',
-            },
-        })
+    const copyToClipboard = async (text: string) => {
+        try {
+            await copyText(text)
+            toast.success('Copied to clipboard!', {
+                icon: '📋',
+                style: {
+                    background: '#1a1a1a',
+                    color: '#fafafa',
+                    border: '1px solid #45ca46',
+                },
+            })
+        } catch {
+            toast.error('Unable to copy to clipboard')
+        }
     }
 
     const formatTimestamp = (timestamp: string) => {
diff --git a/cmd/rpc/web/explorer/src/components/block/BlockSidebar.tsx b/cmd/rpc/web/explorer/src/components/block/BlockSidebar.tsx
index fa22278908..f1279b14b9 100644
--- a/cmd/rpc/web/explorer/src/components/block/BlockSidebar.tsx
+++ b/cmd/rpc/web/explorer/src/components/block/BlockSidebar.tsx
@@ -2,6 +2,7 @@ import React from 'react'
 import { motion } from 'framer-motion'
 import { Copy } from 'lucide-react'
 import toast from 'react-hot-toast'
+import { copyText } from '../../lib/clipboard'
 import blockDetailTexts from '../../data/blockDetail.json'
 
 interface BlockSidebarProps {
@@ -31,10 +32,14 @@ const BlockSidebar: React.FC<BlockSidebarProps> = ({
         return `${address.slice(0, startLength)}...${address.slice(-endLength)}`
     }
 
-    const copyToClipboard = (text: string, label: string = 'Address') => {
+    const copyToClipboard = async (text: string, label: string = 'Address') => {
         if (text && text !== 'N/A') {
-            navigator.clipboard.writeText(text)
-            toast.success(`${label} copied to clipboard`)
+            try {
+                await copyText(text)
+                toast.success(`${label} copied to clipboard`)
+            } catch {
+                toast.error('Unable to copy to clipboard')
+            }
         }
     }
 
diff --git a/cmd/rpc/web/explorer/src/components/search/SearchResults.tsx b/cmd/rpc/web/explorer/src/components/search/SearchResults.tsx
index 7773d11a0b..384b3101aa 100644
--- a/cmd/rpc/web/explorer/src/components/search/SearchResults.tsx
+++ b/cmd/rpc/web/explorer/src/components/search/SearchResults.tsx
@@ -1,6 +1,7 @@
 import React, { useState, useEffect } from 'react'
 import { motion, AnimatePresence } from 'framer-motion'
 import { Link } from 'react-router-dom'
+import { copyText } from '../../lib/clipboard'
 import AnimatedNumber from '../AnimatedNumber'
 import toast from 'react-hot-toast'
 import { Account, TransactionsBySender, TransactionsByRec } from '../../lib/api'
@@ -30,10 +31,14 @@ const formatAccountBalance = (amount: number | undefined) =>
         maximumFractionDigits: 2,
     })
 
-const copyToClipboard = (text: string) => {
+const copyToClipboard = async (text: string) => {
     if (text && text !== 'N/A') {
-        navigator.clipboard.writeText(text)
-        toast.success('Copied to clipboard')
+        try {
+            await copyText(text)
+            toast.success('Copied to clipboard')
+        } catch {
+            toast.error('Unable to copy to clipboard')
+        }
     }
 }
 
diff --git a/cmd/rpc/web/explorer/src/components/token-swaps/OrderDetailPage.tsx b/cmd/rpc/web/explorer/src/components/token-swaps/OrderDetailPage.tsx
index c21b1788c0..43ad5d9943 100644
--- a/cmd/rpc/web/explorer/src/components/token-swaps/OrderDetailPage.tsx
+++ b/cmd/rpc/web/explorer/src/components/token-swaps/OrderDetailPage.tsx
@@ -2,6 +2,7 @@ import React from 'react'
 import { useParams, useNavigate } from 'react-router-dom'
 import { motion } from 'framer-motion'
 import { Copy } from 'lucide-react'
+import { copyText } from '../../lib/clipboard'
 import { useOrder } from '../../hooks/useApi'
 import toast from 'react-hot-toast'
 
@@ -32,16 +33,20 @@ const OrderDetailPage: React.FC = () => {
     const numericCommittee = Number(committeeParam)
     const { data: orderData, isLoading, error } = useOrder(numericCommittee, orderId || '')
 
-    const copyToClipboard = (text: string) => {
-        navigator.clipboard.writeText(text)
-        toast.success('Copied to clipboard!', {
-            icon: '📋',
-            style: {
-                background: '#1a1a1a',
-                color: '#fafafa',
-                border: '1px solid #45ca46',
-            },
-        })
+    const copyToClipboard = async (text: string) => {
+        try {
+            await copyText(text)
+            toast.success('Copied to clipboard!', {
+                icon: '📋',
+                style: {
+                    background: '#1a1a1a',
+                    color: '#fafafa',
+                    border: '1px solid #45ca46',
+                },
+            })
+        } catch {
+            toast.error('Unable to copy to clipboard')
+        }
     }
 
     const truncate = (str: string, n: number = 12) => {
diff --git a/cmd/rpc/web/explorer/src/components/transaction/TransactionDetailPage.tsx b/cmd/rpc/web/explorer/src/components/transaction/TransactionDetailPage.tsx
index f388751b8e..b3b07813fa 100644
--- a/cmd/rpc/web/explorer/src/components/transaction/TransactionDetailPage.tsx
+++ b/cmd/rpc/web/explorer/src/components/transaction/TransactionDetailPage.tsx
@@ -2,6 +2,7 @@ import React, { useState, useEffect } from 'react'
 import { useParams, useNavigate } from 'react-router-dom'
 import { motion } from 'framer-motion'
 import { Copy } from 'lucide-react'
+import { copyText } from '../../lib/clipboard'
 import { useTxByHash, useBlockByHeight, useLatestBlock } from '../../hooks/useApi'
 import toast from 'react-hot-toast'
 import { format, formatDistanceToNow, parseISO, isValid } from 'date-fns'
@@ -132,16 +133,20 @@ const TransactionDetailPage: React.FC = () => {
         return str.length > n * 2 ? `${str.slice(0, n)}…${str.slice(-8)}` : str
     }
 
-    const copyToClipboard = (text: string) => {
-        navigator.clipboard.writeText(text)
-        toast.success('Copied to clipboard!', {
-            icon: '📋',
-            style: {
-                background: '#1a1a1a',
-                color: '#fafafa',
-                border: '1px solid #45ca46',
-            },
-        })
+    const copyToClipboard = async (text: string) => {
+        try {
+            await copyText(text)
+            toast.success('Copied to clipboard!', {
+                icon: '📋',
+                style: {
+                    background: '#1a1a1a',
+                    color: '#fafafa',
+                    border: '1px solid #45ca46',
+                },
+            })
+        } catch {
+            toast.error('Unable to copy to clipboard')
+        }
     }
 
     const formatTimestamp = (timestamp: string | number) => {
diff --git a/cmd/rpc/web/explorer/src/components/ui/CopyableIdentifier.tsx b/cmd/rpc/web/explorer/src/components/ui/CopyableIdentifier.tsx
index b56b02cf1b..2f51d8595e 100644
--- a/cmd/rpc/web/explorer/src/components/ui/CopyableIdentifier.tsx
+++ b/cmd/rpc/web/explorer/src/components/ui/CopyableIdentifier.tsx
@@ -2,6 +2,7 @@ import React from 'react'
 import { Copy } from 'lucide-react'
 import { Link } from 'react-router-dom'
 import toast from 'react-hot-toast'
+import { copyText } from '../../lib/clipboard'
 
 interface CopyableIdentifierProps {
     value: string
@@ -12,25 +13,9 @@ interface CopyableIdentifierProps {
     iconClassName?: string
 }
 
-const fallbackCopy = (value: string) => {
-    const textarea = document.createElement('textarea')
-    textarea.value = value
-    textarea.setAttribute('readonly', '')
-    textarea.style.position = 'fixed'
-    textarea.style.opacity = '0'
-    document.body.appendChild(textarea)
-    textarea.select()
-    document.execCommand('copy')
-    document.body.removeChild(textarea)
-}
-
 const copyValue = async (value: string, label: string) => {
     try {
-        if (navigator.clipboard && window.isSecureContext) {
-            await navigator.clipboard.writeText(value)
-        } else {
-            fallbackCopy(value)
-        }
+        await copyText(value)
         toast.success(`${label} copied`)
     } catch {
         toast.error(`Unable to copy ${label.toLowerCase()}`)
diff --git a/cmd/rpc/web/explorer/src/components/validator/ValidatorDetailHeader.tsx b/cmd/rpc/web/explorer/src/components/validator/ValidatorDetailHeader.tsx
index 353eae2380..a4cb30e5bb 100644
--- a/cmd/rpc/web/explorer/src/components/validator/ValidatorDetailHeader.tsx
+++ b/cmd/rpc/web/explorer/src/components/validator/ValidatorDetailHeader.tsx
@@ -1,4 +1,5 @@
 import React from 'react'
+import { copyText } from '../../lib/clipboard'
 import validatorDetailTexts from '../../data/validatorDetail.json'
 import toast from 'react-hot-toast'
 import { Copy } from 'lucide-react'
@@ -61,16 +62,20 @@ const ValidatorDetailHeader: React.FC<ValidatorDetailHeaderProps> = ({ validator
         }
     }
 
-    const copyToClipboard = (text: string, label: string = 'Address') => {
-        navigator.clipboard.writeText(text)
-        toast.success(`${label} copied to clipboard`, {
-            duration: 2000,
-            position: 'top-right',
-            style: {
-                background: '#171717',
-                color: '#35cd48',
-            },
-        })
+    const copyToClipboard = async (text: string, label: string = 'Address') => {
+        try {
+            await copyText(text)
+            toast.success(`${label} copied to clipboard`, {
+                duration: 2000,
+                position: 'top-right',
+                style: {
+                    background: '#171717',
+                    color: '#35cd48',
+                },
+            })
+        } catch {
+            toast.error('Unable to copy to clipboard')
+        }
     }
 
     // Determine button label and icon based on validator type
diff --git a/cmd/rpc/web/explorer/src/lib/clipboard.ts b/cmd/rpc/web/explorer/src/lib/clipboard.ts
new file mode 100644
index 0000000000..e3a6a95ecf
--- /dev/null
+++ b/cmd/rpc/web/explorer/src/lib/clipboard.ts
@@ -0,0 +1,37 @@
+export async function copyText(text: string): Promise<void> {
+    if (window.isSecureContext && navigator.clipboard) {
+        try {
+            await navigator.clipboard.writeText(text)
+            return
+        } catch {
+            // Try the fallback when clipboard permissions are denied.
+        }
+    }
+
+    // The Clipboard API is unavailable on HTTP LAN addresses.
+    const textarea = document.createElement('textarea')
+    const activeElement = document.activeElement
+    textarea.value = text
+    textarea.contentEditable = 'true'
+    textarea.style.position = 'fixed'
+    textarea.style.opacity = '0'
+    document.body.appendChild(textarea)
+    try {
+        textarea.select()
+        // iOS needs an editable element and an explicit selection range.
+        const range = document.createRange()
+        range.selectNodeContents(textarea)
+        const selection = window.getSelection()
+        selection?.removeAllRanges()
+        selection?.addRange(range)
+        textarea.setSelectionRange(0, text.length)
+        if (!document.execCommand('copy')) {
+            throw new Error('Unable to copy text')
+        }
+    } finally {
+        textarea.remove()
+        if (activeElement instanceof HTMLElement) {
+            activeElement.focus({ preventScroll: true })
+        }
+    }
+}
diff --git a/cmd/rpc/web/explorer/src/lib/utils.ts b/cmd/rpc/web/explorer/src/lib/utils.ts
index 9ad3248e7d..db02d8e6f7 100644
--- a/cmd/rpc/web/explorer/src/lib/utils.ts
+++ b/cmd/rpc/web/explorer/src/lib/utils.ts
@@ -1,3 +1,5 @@
+import { copyText } from './clipboard'
+
 export const rowNavigationIgnoreSelector =
     'a, button, input, select, textarea, summary, [role="button"], [data-row-click-ignore="true"]'
 
@@ -130,32 +132,9 @@ export function isEmpty(obj: object): boolean {
 
 // copy() copies text to clipboard and triggers a toast notification
 export function copy(state: any, setState: (state: any) => void, detail: string, toastText: string = "Copied!"): void {
-    if (navigator.clipboard && window.isSecureContext) {
-        // if HTTPS - use Clipboard API
-        navigator.clipboard
-            .writeText(detail)
-            .then(() => setState({ ...state, toast: toastText }))
-            .catch(() => fallbackCopy(state, setState, detail, toastText));
-    } else {
-        fallbackCopy(state, setState, detail, toastText);
-    }
-}
-
-// fallbackCopy() copies text to clipboard if clipboard API is unavailable
-export function fallbackCopy(state: any, setState: (state: any) => void, detail: string, toastText: string = "Copied!"): void {
-    // if http - use textarea
-    const textArea = document.createElement("textarea");
-    textArea.value = detail;
-    document.body.appendChild(textArea);
-    textArea.select();
-    try {
-        document.execCommand("copy");
-        setState({ ...state, toast: toastText });
-    } catch (err) {
-        console.error("Fallback copy failed", err);
-        setState({ ...state, toast: "Clipboard access denied" });
-    }
-    document.body.removeChild(textArea);
+    void copyText(detail)
+        .then(() => setState({ ...state, toast: toastText }))
+        .catch(() => setState({ ...state, toast: "Clipboard access denied" }));
 }
 
 // convertTx() sanitizes and simplifies a transaction object
diff --git a/cmd/rpc/web/explorer/tests/clipboard.test.cjs b/cmd/rpc/web/explorer/tests/clipboard.test.cjs
new file mode 100644
index 0000000000..dba94e7443
--- /dev/null
+++ b/cmd/rpc/web/explorer/tests/clipboard.test.cjs
@@ -0,0 +1,131 @@
+const assert = require('node:assert/strict')
+const { readFileSync } = require('node:fs')
+const { test } = require('node:test')
+const { runInNewContext } = require('node:vm')
+const ts = require('typescript')
+
+const source = ts.transpileModule(
+    readFileSync(`${__dirname}/../src/lib/clipboard.ts`, 'utf8'),
+    { compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 } },
+).outputText
+
+function setup({ secure = false, writeText, copyResult = true, copyError, hasSelection = true } = {}) {
+    const calls = []
+    class HTMLElement {
+        focus() { calls.push('focus') }
+    }
+    const textarea = {
+        style: {},
+        readOnly: false,
+        selectionStart: 0,
+        selectionEnd: 0,
+        select() { calls.push(['select', this.value]) },
+        setSelectionRange(start, end) {
+            this.selectionStart = start
+            this.selectionEnd = end
+        },
+        remove() { calls.push('remove') },
+    }
+    const range = { selectNodeContents(element) { this.element = element } }
+    const selection = {
+        removeAllRanges() { this.range = null },
+        addRange(range) { this.range = range },
+    }
+    const context = {
+        exports: {},
+        HTMLElement,
+        window: {
+            isSecureContext: secure,
+            getSelection: () => hasSelection ? selection : null,
+        },
+        navigator: { clipboard: writeText ? { writeText } : undefined },
+        document: {
+            activeElement: new HTMLElement(),
+            createElement(tag) {
+                assert.equal(tag, 'textarea')
+                return textarea
+            },
+            body: { appendChild() { calls.push('append') } },
+            createRange: () => range,
+            execCommand(command) {
+                assert.equal(command, 'copy')
+                // Model iOS: select() alone does not select the textarea value.
+                assert.equal(textarea.readOnly, false)
+                assert.equal(textarea.contentEditable, 'true')
+                assert.equal(textarea.selectionStart, 0)
+                assert.equal(textarea.selectionEnd, textarea.value.length)
+                if (hasSelection) assert.equal(selection.range.element, textarea)
+                calls.push('copy')
+                if (copyError) throw copyError
+                return copyResult
+            },
+        },
+    }
+    runInNewContext(source, context)
+    return { copyText: context.exports.copyText, calls }
+}
+
+const text = 'full identifier\nwith multiple lines'
+const fallbackCalls = ['append', ['select', text], 'copy', 'remove', 'focus']
+
+test('awaits the Clipboard API on secure origins without using a textarea', async () => {
+    let finish
+    const written = []
+    const { copyText, calls } = setup({
+        secure: true,
+        writeText: value => {
+            written.push(value)
+            return new Promise(resolve => { finish = resolve })
+        },
+    })
+    let complete = false
+    const pending = copyText(text).then(() => { complete = true })
+    await Promise.resolve()
+    assert.equal(complete, false)
+    finish()
+    await pending
+    assert.deepEqual(written, [text])
+    assert.deepEqual(calls, [])
+})
+
+test('copies the full text on HTTP without navigator.clipboard', async () => {
+    const { copyText, calls } = setup()
+    await copyText(text)
+    assert.deepEqual(calls, fallbackCalls)
+})
+
+test('explicitly selects the complete value for iOS, including Unicode', async () => {
+    const { copyText, calls } = setup()
+    const value = 'Address \u{1F4CB}\nsecond line'
+    await copyText(value)
+    assert.deepEqual(calls, ['append', ['select', value], 'copy', 'remove', 'focus'])
+})
+
+test('still copies when the window selection is unavailable', async () => {
+    const { copyText, calls } = setup({ hasSelection: false })
+    await copyText(text)
+    assert.deepEqual(calls, fallbackCalls)
+})
+
+test('falls back when a secure origin has no Clipboard API', async () => {
+    const { copyText, calls } = setup({ secure: true })
+    await copyText(text)
+    assert.deepEqual(calls, fallbackCalls)
+})
+
+test('falls back when the Clipboard API rejects', async () => {
+    const { copyText, calls } = setup({
+        secure: true,
+        writeText: async () => { throw new Error('Permission denied') },
+    })
+    await copyText(text)
+    assert.deepEqual(calls, fallbackCalls)
+})
+
+for (const failure of [{ copyResult: false }, { copyError: new Error('Copy blocked') }]) {
+    test(`rejects and cleans up when fallback ${failure.copyError ? 'throws' : 'returns false'}`, async () => {
+        const { copyText, calls } = setup(failure)
+        await assert.rejects(copyText(text), /Unable to copy text|Copy blocked/)
+        assert.deepEqual(calls, fallbackCalls)
+    })
+}
diff --git a/controller/block.go b/controller/block.go
index a8ef183b97..558aa621d9 100644
--- a/controller/block.go
+++ b/controller/block.go
@@ -780,8 +780,12 @@ func (c *Controller) UpdateTelemetry(qc *lib.QuorumCertificate, block *lib.Block
 		c.Metrics.UpdateValidator(address.String(), v.StakedAmount, v.UnstakingHeight != 0, v.MaxPausedHeight != 0, v.Delegate, v.Compound, isProducer, nonSigners, doubleSigners)
 	}
 	// update account metrics
-	if a, _ := c.FSM.GetAccount(address); a.Amount != 0 {
-		c.Metrics.UpdateAccount(address.String(), a.Amount)
+	if a, err := c.FSM.GetAccount(address); a != nil {
+		if a.Amount != 0 {
+			c.Metrics.UpdateAccount(address.String(), a.Amount)
+		}
+	} else {
+		c.log.Errorf("unable to update account metrics: no account found for %s: %v", address.String(), err)
 	}
 }
 
diff --git a/controller/block_test.go b/controller/block_test.go
new file mode 100644
index 0000000000..21f62054a2
--- /dev/null
+++ b/controller/block_test.go
@@ -0,0 +1,69 @@
+package controller
+
+import (
+	"bytes"
+	"reflect"
+	"sync/atomic"
+	"testing"
+	"unsafe"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/canopy-network/canopy/fsm"
+	"github.com/canopy-network/canopy/lib"
+	"github.com/canopy-network/canopy/lib/crypto"
+)
+
+// failGetStore is a store whose Get() always fails, used to force GetAccount() and
+// GetValidator() to return a nil result alongside an error, mirroring a store read failure.
+type failGetStore struct {
+	lib.RWStoreI
+}
+
+// Get() always returns an error so callers exercise their error handling paths.
+func (failGetStore) Get([]byte) ([]byte, lib.ErrorI) {
+	// return a store 'get' error to stand in for a database read failure
+	return nil, lib.NewError(lib.CodeStoreGet, lib.StorageModule, "forced get failure")
+}
+
+// TestUpdateTelemetryHandlesGetAccountError ensures UpdateTelemetry() does not panic when
+// GetAccount() returns a nil account together with an error (for example a store read failure).
+func TestUpdateTelemetryHandlesGetAccountError(t *testing.T) {
+	// build a state machine backed by a store whose Get() always fails
+	sm := newFailGetStateMachine(t)
+	// build a minimal controller wired to the failing state machine (nil Metrics is safe)
+	c := &Controller{
+		Address:   bytes.Repeat([]byte{1}, crypto.AddressSize),
+		FSM:       sm,
+		isSyncing: &atomic.Bool{},
+		log:       lib.NewNullLogger(),
+	}
+	// build a minimal block and quorum certificate for the telemetry update
+	block := &lib.Block{BlockHeader: &lib.BlockHeader{}}
+	qc := &lib.QuorumCertificate{}
+	// the telemetry update must tolerate a failing account lookup without panicking
+	require.NotPanics(t, func() {
+		c.UpdateTelemetry(qc, block, 0)
+	})
+}
+
+// newFailGetStateMachine builds a minimal StateMachine backed by a store whose Get() always fails.
+func newFailGetStateMachine(t *testing.T) *fsm.StateMachine {
+	t.Helper()
+	// create an empty state machine
+	sm := &fsm.StateMachine{}
+	// wire in the failing store through the exported setter
+	sm.SetStore(failGetStore{})
+	// the cache is an unexported field with no setter; allocate it via reflection so that
+	// GetAccount()'s cache lookup does not nil-panic before it reaches the failing store
+	field := reflect.ValueOf(sm).Elem().FieldByName("cache")
+	require.True(t, field.IsValid())
+	// allocate a fresh cache value
+	cacheValue := reflect.New(field.Type().Elem())
+	// initialize the 'accounts' map so the cache lookup is a clean miss
+	accounts := cacheValue.Elem().FieldByName("accounts")
+	reflect.NewAt(accounts.Type(), unsafe.Pointer(accounts.UnsafeAddr())).Elem().Set(reflect.MakeMap(accounts.Type()))
+	// set the cache field on the state machine
+	reflect.NewAt(field.Type(), unsafe.Pointer(field.UnsafeAddr())).Elem().Set(cacheValue)
+	return sm
+}
diff --git a/fsm/message_test.go b/fsm/message_test.go
index 41da15702d..20856dd8c8 100644
--- a/fsm/message_test.go
+++ b/fsm/message_test.go
@@ -1,10 +1,13 @@
 package fsm
 
 import (
+	"encoding/json"
+	"testing"
+
 	"github.com/canopy-network/canopy/lib"
 	"github.com/canopy-network/canopy/lib/crypto"
 	"github.com/stretchr/testify/require"
-	"testing"
+	"google.golang.org/protobuf/proto"
 )
 
 func TestHandleMessage(t *testing.T) {
@@ -380,6 +383,59 @@ func TestHandleMessage(t *testing.T) {
 	}
 }
 
+func TestGlobalHexPreservesNativeTransactionJSON(t *testing.T) {
+	t.Run("stake field names", func(t *testing.T) {
+		message := &MessageStake{
+			PublicKey:     []byte{0x01, 0x02},
+			Amount:        10,
+			Committees:    []uint64{1},
+			NetAddress:    "tcp://example.com",
+			OutputAddress: []byte{0x03, 0x04},
+		}
+		anyMessage, err := lib.NewAny(message)
+		require.NoError(t, err)
+
+		encoded, marshalErr := json.Marshal(&lib.Transaction{MessageType: MessageStakeName, Msg: anyMessage})
+		require.NoError(t, marshalErr)
+		require.Contains(t, string(encoded), `"publickey":"0102"`)
+		require.NotContains(t, string(encoded), `"publicKey"`)
+
+		decoded := new(lib.Transaction)
+		require.NoError(t, json.Unmarshal(encoded, decoded))
+		decodedMessage := new(MessageStake)
+		require.NoError(t, decoded.Msg.UnmarshalTo(decodedMessage))
+		require.True(t, proto.Equal(message, decodedMessage))
+	})
+
+	t.Run("change parameter value", func(t *testing.T) {
+		parameterValue, err := lib.NewAny(&lib.StringWrapper{Value: "v3.2"})
+		require.NoError(t, err)
+		message := &MessageChangeParameter{
+			ParameterSpace: "cons",
+			ParameterKey:   ParamProtocolVersion,
+			ParameterValue: parameterValue,
+			StartHeight:    100,
+			EndHeight:      200,
+			Signer:         []byte{0x05, 0x06},
+		}
+		anyMessage, err := lib.NewAny(message)
+		require.NoError(t, err)
+
+		encoded, marshalErr := json.Marshal(&lib.Transaction{MessageType: MessageChangeParameterName, Msg: anyMessage})
+		require.NoError(t, marshalErr)
+		require.Contains(t, string(encoded), `"parameterValue":"v3.2"`)
+		require.Contains(t, string(encoded), `"signer":"0506"`)
+
+		decoded := new(lib.Transaction)
+		require.NoError(t, json.Unmarshal(encoded, decoded))
+		decodedMessage := new(MessageChangeParameter)
+		require.NoError(t, decoded.Msg.UnmarshalTo(decodedMessage))
+		decodedValue := new(lib.StringWrapper)
+		require.NoError(t, decodedMessage.ParameterValue.UnmarshalTo(decodedValue))
+		require.Equal(t, "v3.2", decodedValue.Value)
+	})
+}
+
 func TestGetFeeForMessage(t *testing.T) {
 	tests := []struct {
 		name   string
diff --git a/lib/certificate.go b/lib/certificate.go
index b963aa8513..9162f312c8 100644
--- a/lib/certificate.go
+++ b/lib/certificate.go
@@ -747,6 +747,57 @@ func (x *Orders) Equals(y *Orders) bool {
 	return true
 }
 
+type ordersJSON struct {
+	LockOrders  []*LockOrder `json:"lockOrders"`
+	ResetOrders []HexBytes   `json:"resetOrders"`
+	CloseOrders []HexBytes   `json:"closeOrders"`
+}
+
+// MarshalJSON() represents every order ID as hex.
+func (x Orders) MarshalJSON() ([]byte, error) {
+	return json.Marshal(ordersJSON{
+		LockOrders:  x.LockOrders,
+		ResetOrders: byteSlicesToHex(x.ResetOrders),
+		CloseOrders: byteSlicesToHex(x.CloseOrders),
+	})
+}
+
+// UnmarshalJSON() accepts order IDs as hex.
+func (x *Orders) UnmarshalJSON(jsonBytes []byte) error {
+	j := new(ordersJSON)
+	if err := json.Unmarshal(jsonBytes, j); err != nil {
+		return err
+	}
+	*x = Orders{
+		LockOrders:  j.LockOrders,
+		ResetOrders: hexToByteSlices(j.ResetOrders),
+		CloseOrders: hexToByteSlices(j.CloseOrders),
+	}
+	return nil
+}
+
+func byteSlicesToHex(values [][]byte) []HexBytes {
+	if values == nil {
+		return nil
+	}
+	result := make([]HexBytes, len(values))
+	for i, value := range values {
+		result[i] = value
+	}
+	return result
+}
+
+func hexToByteSlices(values []HexBytes) [][]byte {
+	if values == nil {
+		return nil
+	}
+	result := make([][]byte, len(values))
+	for i, value := range values {
+		result[i] = value
+	}
+	return result
+}
+
 // Equals() compares two LockOrders for equality
 func (x *LockOrder) Equals(y *LockOrder) bool {
 	// if both the lock orders are empty
diff --git a/lib/certificate_test.go b/lib/certificate_test.go
index ad4687db6f..fdf8fa497c 100644
--- a/lib/certificate_test.go
+++ b/lib/certificate_test.go
@@ -518,6 +518,26 @@ func TestCheckpointJSONHexEncoding(t *testing.T) {
 	require.Equal(t, original.BlockHash, decoded.BlockHash)
 }
 
+func TestOrdersJSONHexEncoding(t *testing.T) {
+	original := &Orders{
+		ResetOrders: [][]byte{{0x00, 0x11, 0xaa, 0xff}},
+		CloseOrders: [][]byte{{0xde, 0xad, 0xbe, 0xef}},
+	}
+	encoded, err := json.Marshal(original)
+	require.NoError(t, err)
+	require.JSONEq(t, `{
+		"lockOrders": null,
+		"resetOrders": ["0011aaff"],
+		"closeOrders": ["deadbeef"]
+	}`, string(encoded))
+
+	decoded := new(Orders)
+	require.NoError(t, json.Unmarshal(encoded, decoded))
+	require.True(t, original.Equals(decoded))
+
+	require.Error(t, json.Unmarshal([]byte(`{"resetOrders":["ABGq/w=="]}`), new(Orders)))
+}
+
 func TestRewardRecipientsCheckBasicRejectsOverflowBypass(t *testing.T) {
 	recipients := &RewardRecipients{
 		PaymentPercents: []*PaymentPercents{
diff --git a/lib/codec.go b/lib/codec.go
index 0416bcff58..f8d17cc5c2 100644
--- a/lib/codec.go
+++ b/lib/codec.go
@@ -1,8 +1,11 @@
 package lib
 
 import (
+	"bytes"
+	"encoding/base64"
 	"encoding/json"
 	"fmt"
+	"io"
 	"strings"
 	"sync"
 
@@ -10,34 +13,39 @@ import (
 	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/reflect/protodesc"
 	"google.golang.org/protobuf/reflect/protoreflect"
+	"google.golang.org/protobuf/reflect/protoregistry"
 	"google.golang.org/protobuf/types/descriptorpb"
 	"google.golang.org/protobuf/types/dynamicpb"
 	"google.golang.org/protobuf/types/known/anypb"
 )
 
-// MarshalAnypbJSON() marshals an anypb to JSON using the globalPluginSchemaRegistry
+// MarshalAnypbJSON() marshals an anypb to JSON with protobuf bytes fields represented as hex.
 func MarshalAnypbJSON(any *anypb.Any) (json.RawMessage, error) {
 	if any == nil {
 		return nil, nil
 	}
-	// try with the globalPluginSchemaRegistry first
-	desc := globalPluginSchemaRegistry.FindMessageDescriptorForTypeURL(any.TypeUrl)
+	// Native transaction codecs already implement the global hex contract and
+	// also retain message-specific representations for non-bytes fields.
+	payload, payloadErr := FromAny(any)
+	if payloadErr == nil {
+		if msgI, ok := payload.(MessageI); ok {
+			msg, err := MarshalJSON(msgI)
+			return msg, err
+		}
+		jsonBytes, err := protojson.MarshalOptions{}.Marshal(payload)
+		if err == nil {
+			return transformProtoJSONBytes(jsonBytes, payload.ProtoReflect().Descriptor(), base64ToHex)
+		}
+	}
+	// Dynamically registered plugin messages are not available through the
+	// process-wide protobuf type registry, so resolve their descriptors here.
+	desc := messageDescriptorForTypeURL(any.TypeUrl)
 	if desc != nil && len(any.Value) > 0 {
 		dynamic := dynamicpb.NewMessage(desc)
 		if err := proto.Unmarshal(any.Value, dynamic); err == nil {
 			jsonBytes, e := protojson.MarshalOptions{}.Marshal(dynamic)
 			if e == nil {
-				return jsonBytes, nil
-			}
-		}
-	}
-	// fallback to standard anypb.UnmarshalNew()
-	payload, payloadErr := FromAny(any)
-	if payloadErr == nil {
-		if msgI, ok := payload.(MessageI); ok {
-			msg, err := MarshalJSON(msgI)
-			if err == nil {
-				return msg, nil
+				return transformProtoJSONBytes(jsonBytes, desc, base64ToHex)
 			}
 		}
 	}
@@ -77,7 +85,7 @@ func AnyFromJSONForMessageType(messageType string, msg json.RawMessage) (*anypb.
 	desc := globalPluginSchemaRegistry.FindMessageDescriptorForMessageType(messageType)
 	typeURL := messageType
 	if strings.Contains(messageType, "/") {
-		desc = globalPluginSchemaRegistry.FindMessageDescriptorForTypeURL(messageType)
+		desc = messageDescriptorForTypeURL(messageType)
 	} else if desc != nil {
 		typeURL = "type.googleapis.com/" + string(desc.FullName())
 	}
@@ -85,7 +93,11 @@ func AnyFromJSONForMessageType(messageType string, msg json.RawMessage) (*anypb.
 		return nil, ErrUnknownMessageName(messageType)
 	}
 	dynamic := dynamicpb.NewMessage(desc)
-	if err := protojson.Unmarshal(msg, dynamic); err != nil {
+	protoJSON, err := transformProtoJSONBytes(msg, desc, hexToBase64)
+	if err != nil {
+		return nil, ErrJSONUnmarshal(err)
+	}
+	if err = protojson.Unmarshal(protoJSON, dynamic); err != nil {
 		return nil, ErrJSONUnmarshal(err)
 	}
 	bz, err := proto.MarshalOptions{Deterministic: true}.Marshal(dynamic)
@@ -95,6 +107,125 @@ func AnyFromJSONForMessageType(messageType string, msg json.RawMessage) (*anypb.
 	return &anypb.Any{TypeUrl: typeURL, Value: bz}, nil
 }
 
+func messageDescriptorForTypeURL(typeURL string) protoreflect.MessageDescriptor {
+	if desc := globalPluginSchemaRegistry.FindMessageDescriptorForTypeURL(typeURL); desc != nil {
+		return desc
+	}
+	messageType, err := protoregistry.GlobalTypes.FindMessageByURL(typeURL)
+	if err != nil {
+		return nil
+	}
+	return messageType.Descriptor()
+}
+
+// transformProtoJSONBytes changes the JSON representation of every protobuf bytes field.
+func transformProtoJSONBytes(jsonBytes []byte, desc protoreflect.MessageDescriptor, transform func(string) (string, error)) ([]byte, error) {
+	decoder := json.NewDecoder(bytes.NewReader(jsonBytes))
+	decoder.UseNumber()
+	var value any
+	if err := decoder.Decode(&value); err != nil {
+		return nil, err
+	}
+	if err := decoder.Decode(new(any)); err != io.EOF {
+		return nil, fmt.Errorf("invalid JSON after plugin message")
+	}
+	object, ok := value.(map[string]any)
+	if !ok {
+		return nil, fmt.Errorf("protobuf message JSON must be an object")
+	}
+	if err := transformProtoJSONMessage(object, desc, transform); err != nil {
+		return nil, err
+	}
+	return json.Marshal(object)
+}
+
+func transformProtoJSONMessage(object map[string]any, desc protoreflect.MessageDescriptor, transform func(string) (string, error)) error {
+	fields := desc.Fields()
+	for i := 0; i < fields.Len(); i++ {
+		field := fields.Get(i)
+		name := field.JSONName()
+		value, found := object[name]
+		if !found {
+			name = string(field.Name())
+			value, found = object[name]
+		}
+		if !found {
+			continue
+		}
+		transformed, err := transformProtoJSONField(value, field, transform)
+		if err != nil {
+			return fmt.Errorf("field %s: %w", field.FullName(), err)
+		}
+		object[name] = transformed
+	}
+	return nil
+}
+
+func transformProtoJSONField(value any, field protoreflect.FieldDescriptor, transform func(string) (string, error)) (any, error) {
+	if field.IsMap() {
+		object, ok := value.(map[string]any)
+		if !ok {
+			return value, nil
+		}
+		for key, entry := range object {
+			transformed, err := transformProtoJSONScalar(entry, field.MapValue(), transform)
+			if err != nil {
+				return nil, err
+			}
+			object[key] = transformed
+		}
+		return object, nil
+	}
+	if field.IsList() {
+		list, ok := value.([]any)
+		if !ok {
+			return value, nil
+		}
+		for i, entry := range list {
+			transformed, err := transformProtoJSONScalar(entry, field, transform)
+			if err != nil {
+				return nil, err
+			}
+			list[i] = transformed
+		}
+		return list, nil
+	}
+	return transformProtoJSONScalar(value, field, transform)
+}
+
+func transformProtoJSONScalar(value any, field protoreflect.FieldDescriptor, transform func(string) (string, error)) (any, error) {
+	if field.Kind() == protoreflect.BytesKind {
+		text, ok := value.(string)
+		if !ok {
+			return value, nil
+		}
+		return transform(text)
+	}
+	if field.Kind() == protoreflect.MessageKind || field.Kind() == protoreflect.GroupKind {
+		object, ok := value.(map[string]any)
+		if ok {
+			return object, transformProtoJSONMessage(object, field.Message(), transform)
+		}
+	}
+	return value, nil
+}
+
+func hexToBase64(value string) (string, error) {
+	bz, err := StringToBytes(value)
+	if err != nil {
+		return "", err
+	}
+	return base64.StdEncoding.EncodeToString(bz), nil
+}
+
+func base64ToHex(value string) (string, error) {
+	bz, err := base64.StdEncoding.DecodeString(value)
+	if err != nil {
+		return "", err
+	}
+	return BytesToString(bz), nil
+}
+
 var globalPluginSchemaRegistry = NewPluginSchemaRegistry()
 
 // PluginSchemaRegistry() acts as a global registry for plugin proto schemas to implement the json.Marshal interface
diff --git a/lib/codec_test.go b/lib/codec_test.go
new file mode 100644
index 0000000000..d98179b831
--- /dev/null
+++ b/lib/codec_test.go
@@ -0,0 +1,115 @@
+package lib
+
+import (
+	"bytes"
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"google.golang.org/protobuf/proto"
+)
+
+func TestPluginJSONBytesUseHex(t *testing.T) {
+	originalRegistry := globalPluginSchemaRegistry
+	globalPluginSchemaRegistry = NewPluginSchemaRegistry()
+	defer func() { globalPluginSchemaRegistry = originalRegistry }()
+
+	desc := (&PluginConfig{}).ProtoReflect().Descriptor()
+	typeURL := "type.googleapis.com/" + string(desc.FullName())
+	globalPluginSchemaRegistry.byCommonMessageName["plugin-config"] = desc
+	globalPluginSchemaRegistry.byTypeURL[typeURL] = desc
+
+	expected := []byte{0x00, 0x11, 0xaa, 0xff}
+	input := json.RawMessage(`{"name":"test","fileDescriptorProtos":["0011aaff"]}`)
+	message, err := AnyFromJSONForMessageType("plugin-config", input)
+	require.NoError(t, err)
+
+	decoded := new(PluginConfig)
+	require.NoError(t, message.UnmarshalTo(decoded))
+	require.Equal(t, [][]byte{expected}, decoded.FileDescriptorProtos)
+	expectedBytes, marshalProtoErr := proto.MarshalOptions{Deterministic: true}.Marshal(&PluginConfig{
+		Name:                 "test",
+		FileDescriptorProtos: [][]byte{expected},
+	})
+	require.NoError(t, marshalProtoErr)
+	require.Equal(t, expectedBytes, message.Value)
+
+	output, marshalErr := MarshalAnypbJSON(message)
+	require.NoError(t, marshalErr)
+	require.JSONEq(t, string(input), string(output))
+}
+
+func TestGlobalHexPreservesNativeJSONContract(t *testing.T) {
+	originalRegistry := globalPluginSchemaRegistry
+	globalPluginSchemaRegistry = NewPluginSchemaRegistry()
+	defer func() { globalPluginSchemaRegistry = originalRegistry }()
+
+	desc := (&Signature{}).ProtoReflect().Descriptor()
+	typeURL := "type.googleapis.com/" + string(desc.FullName())
+	globalPluginSchemaRegistry.byCommonMessageName[testMessageName] = desc
+	globalPluginSchemaRegistry.byTypeURL[typeURL] = desc
+
+	expected := bytes.Repeat([]byte{0xab}, 20)
+	input := json.RawMessage(`{"publicKey":"` + BytesToString(expected) + `"}`)
+	message, err := NewAny(&Signature{PublicKey: expected})
+	require.NoError(t, err)
+
+	output, marshalErr := MarshalAnypbJSON(message)
+	require.NoError(t, marshalErr)
+	require.JSONEq(t, string(input), string(output))
+
+	transactionJSON := []byte(`{"type":"` + testMessageName + `","msg":` + string(input) + `}`)
+	transaction := new(Transaction)
+	require.NoError(t, json.Unmarshal(transactionJSON, transaction))
+	decoded := new(Signature)
+	require.NoError(t, transaction.Msg.UnmarshalTo(decoded))
+	require.Equal(t, expected, decoded.PublicKey)
+}
+
+func TestGlobalProtobufJSONBytesUseHex(t *testing.T) {
+	expected := []byte{0x00, 0x11, 0xaa, 0xff}
+	message, err := NewAny(&PluginConfig{
+		Name:                 "test",
+		FileDescriptorProtos: [][]byte{expected},
+	})
+	require.NoError(t, err)
+
+	output, marshalErr := MarshalAnypbJSON(message)
+	require.NoError(t, marshalErr)
+	require.JSONEq(t, `{"name":"test","fileDescriptorProtos":["0011aaff"]}`, string(output))
+
+	decoded, unmarshalErr := AnyFromJSONForMessageType(message.TypeUrl, output)
+	require.NoError(t, unmarshalErr)
+	require.Equal(t, message.Value, decoded.Value)
+}
+
+func TestTransactionJSONUsesHexForPluginBytes(t *testing.T) {
+	originalRegistry := globalPluginSchemaRegistry
+	globalPluginSchemaRegistry = NewPluginSchemaRegistry()
+	defer func() { globalPluginSchemaRegistry = originalRegistry }()
+
+	const pluginMessageType = "plugin-signature"
+	desc := (&Signature{}).ProtoReflect().Descriptor()
+	globalPluginSchemaRegistry.byCommonMessageName[pluginMessageType] = desc
+
+	expected := bytes.Repeat([]byte{0xab}, 20)
+	jsonBytes := []byte(`{"type":"` + pluginMessageType + `","msg":{"publicKey":"` + BytesToString(expected) + `"}}`)
+	transaction := new(Transaction)
+	require.NoError(t, json.Unmarshal(jsonBytes, transaction))
+
+	message := new(Signature)
+	require.NoError(t, transaction.Msg.UnmarshalTo(message))
+	require.Equal(t, expected, message.PublicKey)
+}
+
+func TestProtobufJSONBytesRejectInvalidHex(t *testing.T) {
+	desc := (&Signature{}).ProtoReflect().Descriptor()
+	_, err := transformProtoJSONBytes([]byte(`{"publicKey":"not-hex"}`), desc, hexToBase64)
+	require.Error(t, err)
+}
+
+func TestProtobufJSONBytesRejectBase64(t *testing.T) {
+	desc := (&Signature{}).ProtoReflect().Descriptor()
+	_, err := transformProtoJSONBytes([]byte(`{"publicKey":"q6urq6urq6urq6urq6urq6urq6s="}`), desc, hexToBase64)
+	require.Error(t, err)
+}
diff --git a/lib/tx.go b/lib/tx.go
index e5acfd9611..2f0cea002b 100644
--- a/lib/tx.go
+++ b/lib/tx.go
@@ -272,7 +272,33 @@ func (x *Transaction) UnmarshalJSON(jsonBytes []byte) (err error) {
 	if err = json.Unmarshal(jsonBytes, j); err != nil {
 		return err
 	}
-	// first try unmarshalling using the global plugin registration
+	// Native transaction codecs already implement the global hex contract and
+	// retain message-specific representations for non-bytes fields.
+	m, found := RegisteredMessages[j.Type]
+	if found {
+		msg := m.New()
+		if err = json.Unmarshal(j.Msg, msg); err != nil {
+			return
+		}
+		a, e := NewAny(msg)
+		if e != nil {
+			return e
+		}
+		*x = Transaction{
+			MessageType:   j.Type,
+			Msg:           a,
+			Signature:     j.Signature,
+			CreatedHeight: j.CreatedHeight,
+			Time:          j.Time,
+			Fee:           j.Fee,
+			Memo:          j.Memo,
+			NetworkId:     j.NetworkId,
+			ChainId:       j.ChainId,
+			Nonce:         j.Nonce,
+		}
+		return nil
+	}
+	// Otherwise try unmarshalling through a protobuf descriptor.
 	if len(j.Msg) > 0 {
 		anyMsg, e := AnyFromJSONForMessageType(j.Type, j.Msg)
 		if e == nil {
@@ -293,54 +319,20 @@ func (x *Transaction) UnmarshalJSON(jsonBytes []byte) (err error) {
 			return e
 		}
 	}
-	// get the type of the message payload based on the 'message types' that were globally registered upon app start
-	m, found := RegisteredMessages[j.Type]
-	// if the message type is not found among the registered messages
-	if !found {
-		if j.MsgTypeURL == "" && j.MsgBytes == "" {
-			// exit with error
-			return ErrUnknownMessageName(j.Type)
-		}
-		var msgValue []byte
-		if j.MsgBytes != "" {
-			msgValue, err = StringToBytes(j.MsgBytes)
-			if err != nil {
-				return err
-			}
-		}
-		// populate the underlying transaction object using raw any bytes
-		*x = Transaction{
-			MessageType:   j.Type,
-			Msg:           &anypb.Any{TypeUrl: j.MsgTypeURL, Value: msgValue},
-			Signature:     j.Signature,
-			CreatedHeight: j.CreatedHeight,
-			Time:          j.Time,
-			Fee:           j.Fee,
-			Memo:          j.Memo,
-			NetworkId:     j.NetworkId,
-			ChainId:       j.ChainId,
-			Nonce:         j.Nonce,
-		}
-		return nil
-	}
-	// create a new instance of the message
-	msg := m.New()
-	// populate the new message using the json bytes in the json object
-	if err = json.Unmarshal(j.Msg, msg); err != nil {
-		// exit with error
-		return
+	if j.MsgTypeURL == "" && j.MsgBytes == "" {
+		return ErrUnknownMessageName(j.Type)
 	}
-	// convert the message to a proto.Any
-	a, err := NewAny(msg)
-	// if an error occurred during the conversion
-	if err != nil {
-		// exit with error
-		return
+	var msgValue []byte
+	if j.MsgBytes != "" {
+		msgValue, err = StringToBytes(j.MsgBytes)
+		if err != nil {
+			return err
+		}
 	}
-	// populate the underlying transaction object
+	// Populate the underlying transaction object using raw Any bytes.
 	*x = Transaction{
 		MessageType:   j.Type,
-		Msg:           a,
+		Msg:           &anypb.Any{TypeUrl: j.MsgTypeURL, Value: msgValue},
 		Signature:     j.Signature,
 		CreatedHeight: j.CreatedHeight,
 		Time:          j.Time,
@@ -350,8 +342,7 @@ func (x *Transaction) UnmarshalJSON(jsonBytes []byte) (err error) {
 		ChainId:       j.ChainId,
 		Nonce:         j.Nonce,
 	}
-	// exit
-	return
+	return nil
 }
 
 // TRANSACTION RESULT CODE BELOW
diff --git a/plugin/csharp/TUTORIAL.md b/plugin/csharp/TUTORIAL.md
index 5ab48cbdc2..1a01b6f4fb 100644
--- a/plugin/csharp/TUTORIAL.md
+++ b/plugin/csharp/TUTORIAL.md
@@ -525,6 +525,8 @@ Each handler calls the detached, read-only `QueryStateAsync`:
 - Without `?address`, it does a **range read** over the record prefix (`FaucetPrefix()` / `RewardPrefix()`) and returns every record.
 - With `?address=<hex>`, it does a **single-key read** (`KeyForFaucet(addr)` / `KeyForReward(addr)`) and returns just that recipient's record.
 
+> **Important — the range prefix must be length-prefixed.** Stored keys are length-prefixed (`KeyForFaucet(addr)` = `JoinLenPrefix(FaucetPrefixBytes, addr)`), so the prefix you pass to a **range read** must be length-prefixed too — that's exactly what `FaucetPrefix()` returns (`JoinLenPrefix(FaucetPrefixBytes)`, i.e. `[0x01, 0x64]`), **not** the raw byte `[0x64]`. Passing the raw prefix byte misaligns Canopy's length-prefixed iterator and crashes the node with `panic: corrupt or incomplete key`. (Single-key reads via `KeyForFaucet(addr)` are already length-prefixed, so they're unaffected.)
+
 Because the skeleton already starts the server from `Program.cs`, no change to `Program.cs` is needed — your new routes are served as soon as you rebuild.
 
 ### Query the endpoints
@@ -715,8 +717,10 @@ When submitting signed transactions to the RPC endpoint (`/v1/tx`), the signatur
 
 Key points:
 - Canopy uses BLS12-381 signatures (not Ed25519)
+- Encode every protobuf `bytes` field as a hexadecimal string in the message JSON
 - Sign the deterministically marshaled protobuf bytes of the Transaction (without signature field)
-- For plugin-only message types (faucet, reward), use `msgTypeUrl` and `msgBytes` fields for exact byte control
+- Submit native and plugin-only message types as structured `msg` JSON through `/v1/tx`
+- The JSON hex encoding does not change the raw bytes stored in the protobuf message
 
 See `RpcTest.cs` in `plugin/csharp/tutorial` for the complete signing implementation.
 
diff --git a/plugin/csharp/tutorial/RpcTest.cs b/plugin/csharp/tutorial/RpcTest.cs
index 41d191877e..aed6192f0e 100644
--- a/plugin/csharp/tutorial/RpcTest.cs
+++ b/plugin/csharp/tutorial/RpcTest.cs
@@ -406,15 +406,6 @@ private static string RandomAddressHex()
             return BLSCrypto.BytesToHex(bytes);
         }
 
-        /// <summary>
-        /// Convert hex string to base64 (for protojson bytes encoding).
-        /// </summary>
-        private static string HexToBase64(string hexStr)
-        {
-            var bytes = BLSCrypto.HexToBytes(hexStr);
-            return Convert.ToBase64String(bytes);
-        }
-
         /// <summary>
         /// HTTP POST helper that sends JSON and returns response body.
         /// </summary>
@@ -567,8 +558,8 @@ private static async Task<string> SendFaucetTxAsync(
         {
             var faucetMsg = new Dictionary<string, object>
             {
-                ["signerAddress"] = HexToBase64(signerKey.Address),
-                ["recipientAddress"] = HexToBase64(recipientAddr),
+                ["signerAddress"] = signerKey.Address,
+                ["recipientAddress"] = recipientAddr,
                 ["amount"] = amount
             };
 
@@ -591,8 +582,8 @@ private static async Task<string> SendSendTxAsync(
         {
             var sendMsg = new Dictionary<string, object>
             {
-                ["fromAddress"] = HexToBase64(fromAddr),
-                ["toAddress"] = HexToBase64(toAddr),
+                ["fromAddress"] = fromAddr,
+                ["toAddress"] = toAddr,
                 ["amount"] = amount
             };
 
@@ -615,8 +606,8 @@ private static async Task<string> SendRewardTxAsync(
         {
             var rewardMsg = new Dictionary<string, object>
             {
-                ["adminAddress"] = HexToBase64(adminAddr),
-                ["recipientAddress"] = HexToBase64(recipientAddr),
+                ["adminAddress"] = adminAddr,
+                ["recipientAddress"] = recipientAddr,
                 ["amount"] = amount
             };
 
@@ -647,25 +638,25 @@ private static async Task<string> BuildSignAndSendTxAsync(
                 _ => throw new ArgumentException($"Unknown message type: {msgType}")
             };
 
-            // Create protobuf message for signing
+            // Create protobuf message for signing (addresses are hex in msgJson)
             byte[] msgProtoBytes = msgType switch
             {
                 "send" => new MessageSend
                 {
-                    FromAddress = ByteString.CopyFrom(Convert.FromBase64String((string)msgJson["fromAddress"])),
-                    ToAddress = ByteString.CopyFrom(Convert.FromBase64String((string)msgJson["toAddress"])),
+                    FromAddress = ByteString.CopyFrom(BLSCrypto.HexToBytes((string)msgJson["fromAddress"])),
+                    ToAddress = ByteString.CopyFrom(BLSCrypto.HexToBytes((string)msgJson["toAddress"])),
                     Amount = (ulong)msgJson["amount"]
                 }.ToByteArray(),
                 "reward" => new MessageReward
                 {
-                    AdminAddress = ByteString.CopyFrom(Convert.FromBase64String((string)msgJson["adminAddress"])),
-                    RecipientAddress = ByteString.CopyFrom(Convert.FromBase64String((string)msgJson["recipientAddress"])),
+                    AdminAddress = ByteString.CopyFrom(BLSCrypto.HexToBytes((string)msgJson["adminAddress"])),
+                    RecipientAddress = ByteString.CopyFrom(BLSCrypto.HexToBytes((string)msgJson["recipientAddress"])),
                     Amount = (ulong)msgJson["amount"]
                 }.ToByteArray(),
                 "faucet" => new MessageFaucet
                 {
-                    SignerAddress = ByteString.CopyFrom(Convert.FromBase64String((string)msgJson["signerAddress"])),
-                    RecipientAddress = ByteString.CopyFrom(Convert.FromBase64String((string)msgJson["recipientAddress"])),
+                    SignerAddress = ByteString.CopyFrom(BLSCrypto.HexToBytes((string)msgJson["signerAddress"])),
+                    RecipientAddress = ByteString.CopyFrom(BLSCrypto.HexToBytes((string)msgJson["recipientAddress"])),
                     Amount = (ulong)msgJson["amount"]
                 }.ToByteArray(),
                 _ => throw new ArgumentException($"Unknown message type: {msgType}")
@@ -697,49 +688,23 @@ private static async Task<string> BuildSignAndSendTxAsync(
             // Get public key bytes
             var pubKeyBytes = BLSCrypto.HexToBytes(signerKey.PublicKey);
 
-            // Build the transaction JSON
-            object txJsonObject;
-            if (msgType == "send")
-            {
-                // "send" is in RegisteredMessages, must use msg field
-                txJsonObject = new Dictionary<string, object>
-                {
-                    ["type"] = msgType,
-                    ["msg"] = msgJson,
-                    ["signature"] = new Dictionary<string, string>
-                    {
-                        ["publicKey"] = BLSCrypto.BytesToHex(pubKeyBytes),
-                        ["signature"] = BLSCrypto.BytesToHex(signature)
-                    },
-                    ["time"] = txTime,
-                    ["createdHeight"] = height,
-                    ["fee"] = fee,
-                    ["memo"] = "",
-                    ["networkID"] = networkId,
-                    ["chainID"] = chainId
-                };
-            }
-            else
+            // Build the transaction using structured JSON for every plugin message.
+            object txJsonObject = new Dictionary<string, object>
             {
-                // Plugin-only types: use msgTypeUrl/msgBytes for exact byte control
-                txJsonObject = new Dictionary<string, object>
+                ["type"] = msgType,
+                ["msg"] = msgJson,
+                ["signature"] = new Dictionary<string, string>
                 {
-                    ["type"] = msgType,
-                    ["msgTypeUrl"] = typeUrl,
-                    ["msgBytes"] = BLSCrypto.BytesToHex(msgProtoBytes),
-                    ["signature"] = new Dictionary<string, string>
-                    {
-                        ["publicKey"] = BLSCrypto.BytesToHex(pubKeyBytes),
-                        ["signature"] = BLSCrypto.BytesToHex(signature)
-                    },
-                    ["time"] = txTime,
-                    ["createdHeight"] = height,
-                    ["fee"] = fee,
-                    ["memo"] = "",
-                    ["networkID"] = networkId,
-                    ["chainID"] = chainId
-                };
-            }
+                    ["publicKey"] = BLSCrypto.BytesToHex(pubKeyBytes),
+                    ["signature"] = BLSCrypto.BytesToHex(signature)
+                },
+                ["time"] = txTime,
+                ["createdHeight"] = height,
+                ["fee"] = fee,
+                ["memo"] = "",
+                ["networkID"] = networkId,
+                ["chainID"] = chainId
+            };
 
             // Send the transaction
             var txJson = JsonSerializer.Serialize(txJsonObject);
diff --git a/plugin/go/TUTORIAL.md b/plugin/go/TUTORIAL.md
index 7ff8c1c1a9..c4fa102f76 100644
--- a/plugin/go/TUTORIAL.md
+++ b/plugin/go/TUTORIAL.md
@@ -657,9 +657,10 @@ When submitting signed transactions to the RPC endpoint (`/v1/tx`), the signatur
 
 Key points:
 - Canopy uses BLS12-381 signatures (not Ed25519)
-- Use `protojson.Marshal` for the message JSON (produces base64-encoded bytes)
+- Encode every protobuf `bytes` field as a hexadecimal string in the message JSON
 - Sign the deterministically marshaled protobuf bytes of the Transaction (without signature field)
-- For plugin-only message types (faucet, reward), use `msgTypeUrl` and `msgBytes` fields for exact byte control
+- Submit native and plugin-only message types as structured `msg` JSON through `/v1/tx`
+- The JSON hex encoding does not change the raw bytes stored in the protobuf message
 
 See `rpc_test.go` in `plugin/go/tutorial` for the complete signing implementation.
 
diff --git a/plugin/go/tutorial/rpc_test.go b/plugin/go/tutorial/rpc_test.go
index c78116a476..9f4e4a4b3b 100644
--- a/plugin/go/tutorial/rpc_test.go
+++ b/plugin/go/tutorial/rpc_test.go
@@ -3,7 +3,6 @@ package main
 import (
 	"bytes"
 	cryptorand "crypto/rand"
-	"encoding/base64"
 	"encoding/hex"
 	"encoding/json"
 	"fmt"
@@ -597,19 +596,12 @@ func checkTxNotFailed(rpcURL, senderAddr string) (int, error) {
 	return result.TotalCount, nil
 }
 
-// hexToBase64 converts a hex string to base64 (for protojson bytes encoding)
-func hexToBase64(hexStr string) string {
-	bytes, _ := hex.DecodeString(hexStr)
-	return base64.StdEncoding.EncodeToString(bytes)
-}
-
 // sendFaucetTx sends a faucet transaction using raw JSON
 func sendFaucetTx(rpcURL string, signerKey *keyGroup, recipientAddr string, amount, fee, networkID, chainID, height uint64) (string, error) {
 	// Create the faucet message as JSON map
-	// protojson expects base64 for bytes fields
 	faucetMsg := map[string]interface{}{
-		"signerAddress":    hexToBase64(signerKey.Address),
-		"recipientAddress": hexToBase64(recipientAddr),
+		"signerAddress":    signerKey.Address,
+		"recipientAddress": recipientAddr,
 		"amount":           float64(amount),
 	}
 
@@ -619,10 +611,9 @@ func sendFaucetTx(rpcURL string, signerKey *keyGroup, recipientAddr string, amou
 // sendSendTx sends a send transaction using raw JSON
 func sendSendTx(rpcURL string, senderKey *keyGroup, fromAddr, toAddr string, amount, fee, networkID, chainID, height uint64) (string, error) {
 	// Create the send message as JSON map
-	// protojson expects base64 for bytes fields
 	sendMsg := map[string]interface{}{
-		"fromAddress": hexToBase64(fromAddr),
-		"toAddress":   hexToBase64(toAddr),
+		"fromAddress": fromAddr,
+		"toAddress":   toAddr,
 		"amount":      float64(amount),
 	}
 
@@ -632,10 +623,9 @@ func sendSendTx(rpcURL string, senderKey *keyGroup, fromAddr, toAddr string, amo
 // sendRewardTx sends a reward transaction using raw JSON
 func sendRewardTx(rpcURL string, adminKey *keyGroup, adminAddr, recipientAddr string, amount, fee, networkID, chainID, height uint64) (string, error) {
 	// Create the reward message as JSON map
-	// protojson expects base64 for bytes fields
 	rewardMsg := map[string]interface{}{
-		"adminAddress":     hexToBase64(adminAddr),
-		"recipientAddress": hexToBase64(recipientAddr),
+		"adminAddress":     adminAddr,
+		"recipientAddress": recipientAddr,
 		"amount":           float64(amount),
 	}
 
@@ -668,28 +658,27 @@ func buildSignAndSendTx(rpcURL string, signerKey *keyGroup, msgType string, msgJ
 
 	// Marshal the message to proto bytes for signing
 	// We need to create the actual proto message
-	// Addresses in msgJSON are base64-encoded (for protojson compatibility)
 	var msgProto proto.Message
 	switch msgType {
 	case "send":
-		fromAddr, _ := base64.StdEncoding.DecodeString(msgJSON["fromAddress"].(string))
-		toAddr, _ := base64.StdEncoding.DecodeString(msgJSON["toAddress"].(string))
+		fromAddr, _ := hex.DecodeString(msgJSON["fromAddress"].(string))
+		toAddr, _ := hex.DecodeString(msgJSON["toAddress"].(string))
 		msgProto = &contract.MessageSend{
 			FromAddress: fromAddr,
 			ToAddress:   toAddr,
 			Amount:      uint64(msgJSON["amount"].(float64)),
 		}
 	case "reward":
-		adminAddr, _ := base64.StdEncoding.DecodeString(msgJSON["adminAddress"].(string))
-		recipientAddr, _ := base64.StdEncoding.DecodeString(msgJSON["recipientAddress"].(string))
+		adminAddr, _ := hex.DecodeString(msgJSON["adminAddress"].(string))
+		recipientAddr, _ := hex.DecodeString(msgJSON["recipientAddress"].(string))
 		msgProto = &contract.MessageReward{
 			AdminAddress:     adminAddr,
 			RecipientAddress: recipientAddr,
 			Amount:           uint64(msgJSON["amount"].(float64)),
 		}
 	case "faucet":
-		signerAddr, _ := base64.StdEncoding.DecodeString(msgJSON["signerAddress"].(string))
-		recipientAddr, _ := base64.StdEncoding.DecodeString(msgJSON["recipientAddress"].(string))
+		signerAddr, _ := hex.DecodeString(msgJSON["signerAddress"].(string))
+		recipientAddr, _ := hex.DecodeString(msgJSON["recipientAddress"].(string))
 		msgProto = &contract.MessageFaucet{
 			SignerAddress:    signerAddr,
 			RecipientAddress: recipientAddr,
@@ -729,49 +718,20 @@ func buildSignAndSendTx(rpcURL string, signerKey *keyGroup, msgType string, msgJ
 		return "", fmt.Errorf("failed to decode public key: %v", err)
 	}
 
-	// Marshal the message to get the exact bytes for the Any.Value
-	msgProtoBytes, err := proto.Marshal(msgProto)
-	if err != nil {
-		return "", fmt.Errorf("failed to marshal message proto: %v", err)
-	}
-
-	// Build the transaction
-	// For "send" (which is in RegisteredMessages), we must use "msg" field
-	// For plugin-only types (faucet, reward), we use msgTypeUrl/msgBytes for exact byte control
-	var tx map[string]interface{}
-	if msgType == "send" {
-		// "send" is in RegisteredMessages, must use msg field
-		tx = map[string]interface{}{
-			"type": msgType,
-			"msg":  msgJSON,
-			"signature": map[string]string{
-				"publicKey": hex.EncodeToString(pubKeyBytes),
-				"signature": hex.EncodeToString(signature),
-			},
-			"time":          txTime,
-			"createdHeight": height,
-			"fee":           fee,
-			"memo":          "",
-			"networkID":     networkID,
-			"chainID":       chainID,
-		}
-	} else {
-		// Plugin-only types: use msgTypeUrl/msgBytes for exact byte control
-		tx = map[string]interface{}{
-			"type":       msgType,
-			"msgTypeUrl": typeURL,
-			"msgBytes":   hex.EncodeToString(msgProtoBytes),
-			"signature": map[string]string{
-				"publicKey": hex.EncodeToString(pubKeyBytes),
-				"signature": hex.EncodeToString(signature),
-			},
-			"time":          txTime,
-			"createdHeight": height,
-			"fee":           fee,
-			"memo":          "",
-			"networkID":     networkID,
-			"chainID":       chainID,
-		}
+	// Build the transaction using structured JSON for every plugin message.
+	tx := map[string]interface{}{
+		"type": msgType,
+		"msg":  msgJSON,
+		"signature": map[string]string{
+			"publicKey": hex.EncodeToString(pubKeyBytes),
+			"signature": hex.EncodeToString(signature),
+		},
+		"time":          txTime,
+		"createdHeight": height,
+		"fee":           fee,
+		"memo":          "",
+		"networkID":     networkID,
+		"chainID":       chainID,
 	}
 
 	txJSONBytes, err := json.MarshalIndent(tx, "", "  ")
diff --git a/plugin/kotlin/TUTORIAL.md b/plugin/kotlin/TUTORIAL.md
index bf89875ff8..939a4de1c3 100644
--- a/plugin/kotlin/TUTORIAL.md
+++ b/plugin/kotlin/TUTORIAL.md
@@ -495,6 +495,8 @@ Then add the `handleQueryFaucets` / `handleQueryRewards` handlers (and the JSON/
 - Without `?address`, it does a **range read** over the record prefix (`faucetPrefix()` / `rewardPrefix()`) and returns every record.
 - With `?address=<hex>`, it does a **single-key read** (`keyForFaucet(addr)` / `keyForReward(addr)`) and returns just that recipient's record.
 
+> **Important — the range prefix must be length-prefixed.** Stored keys are length-prefixed (`keyForFaucet(addr)` = `joinLenPrefix(FAUCET_PREFIX, addr)`), so the prefix you pass to a **range read** must be length-prefixed too — that's exactly what `faucetPrefix()` returns (`joinLenPrefix(FAUCET_PREFIX)`, i.e. `byteArrayOf(0x01, 0x64)`), **not** the raw `byteArrayOf(0x64)`. Passing the raw prefix byte misaligns Canopy's length-prefixed iterator and crashes the node with `panic: corrupt or incomplete key`. (Single-key reads via `keyForFaucet(addr)` are already length-prefixed, so they're unaffected.)
+
 The listen address comes from the `rpcAddress` config field (default `0.0.0.0:50010`). The RPC server is optional and non-fatal: set `rpcAddress` to empty to disable it, and a bind failure (e.g. port already in use) is logged without crashing the plugin.
 
 ### Query the endpoints
@@ -693,8 +695,10 @@ When submitting signed transactions to the RPC endpoint (`/v1/tx`), the signatur
 Key points:
 - Canopy uses BLS12-381 signatures with the drand/kyber DST: `"BLS_SIG_BLS12381G2_XMD:SHA-256_SSWU_RO_NUL_"`
 - The tutorial project includes a `BLSCrypto` utility class that handles signing with the correct DST
+- Encode every protobuf `bytes` field as a hexadecimal string in the message JSON
 - Sign the deterministically marshaled protobuf bytes of the Transaction (without signature field)
-- For plugin-only message types (faucet, reward), use `msgTypeUrl` and `msgBytes` fields for exact byte control
+- Submit native and plugin-only message types as structured `msg` JSON through `/v1/tx`
+- The JSON hex encoding does not change the raw bytes stored in the protobuf message
 
 See `RpcTest.kt` in `plugin/kotlin/tutorial` for the complete signing implementation.
 
diff --git a/plugin/kotlin/tutorial/src/test/kotlin/com/canopy/tutorial/RpcTest.kt b/plugin/kotlin/tutorial/src/test/kotlin/com/canopy/tutorial/RpcTest.kt
index 2513fb3190..61d9209473 100644
--- a/plugin/kotlin/tutorial/src/test/kotlin/com/canopy/tutorial/RpcTest.kt
+++ b/plugin/kotlin/tutorial/src/test/kotlin/com/canopy/tutorial/RpcTest.kt
@@ -22,7 +22,6 @@ import java.net.http.HttpClient
 import java.net.http.HttpRequest
 import java.net.http.HttpResponse
 import java.time.Duration
-import java.util.Base64
 import kotlin.random.Random
 import kotlin.test.assertTrue
 import kotlin.test.fail
@@ -451,14 +450,6 @@ class RpcTest {
         return bytes.toHexString()
     }
     
-    /**
-     * Convert hex string to base64 (for protojson bytes encoding).
-     */
-    private fun hexToBase64(hexStr: String): String {
-        val bytes = hexStr.hexToBytes()
-        return Base64.getEncoder().encodeToString(bytes)
-    }
-    
     /**
      * HTTP POST helper that sends JSON and returns response body.
      */
@@ -600,8 +591,8 @@ class RpcTest {
         height: Long
     ): String {
         val faucetMsg = mapOf(
-            "signerAddress" to hexToBase64(signerKey.address),
-            "recipientAddress" to hexToBase64(recipientAddr),
+            "signerAddress" to signerKey.address,
+            "recipientAddress" to recipientAddr,
             "amount" to amount
         )
         
@@ -623,8 +614,8 @@ class RpcTest {
         height: Long
     ): String {
         val sendMsg = mapOf(
-            "fromAddress" to hexToBase64(fromAddr),
-            "toAddress" to hexToBase64(toAddr),
+            "fromAddress" to fromAddr,
+            "toAddress" to toAddr,
             "amount" to amount
         )
         
@@ -646,8 +637,8 @@ class RpcTest {
         height: Long
     ): String {
         val rewardMsg = mapOf(
-            "adminAddress" to hexToBase64(adminAddr),
-            "recipientAddress" to hexToBase64(recipientAddr),
+            "adminAddress" to adminAddr,
+            "recipientAddress" to recipientAddr,
             "amount" to amount
         )
         
@@ -677,11 +668,11 @@ class RpcTest {
             else -> throw IllegalArgumentException("Unknown message type: $msgType")
         }
         
-        // Create protobuf message for signing
+        // Create protobuf message for signing (addresses are hex in msgJson)
         val msgProtoBytes = when (msgType) {
             "send" -> {
-                val fromAddr = Base64.getDecoder().decode(msgJson["fromAddress"] as String)
-                val toAddr = Base64.getDecoder().decode(msgJson["toAddress"] as String)
+                val fromAddr = (msgJson["fromAddress"] as String).hexToBytes()
+                val toAddr = (msgJson["toAddress"] as String).hexToBytes()
                 MessageSend.newBuilder()
                     .setFromAddress(ByteString.copyFrom(fromAddr))
                     .setToAddress(ByteString.copyFrom(toAddr))
@@ -690,8 +681,8 @@ class RpcTest {
                     .toByteArray()
             }
             "reward" -> {
-                val adminAddr = Base64.getDecoder().decode(msgJson["adminAddress"] as String)
-                val recipientAddr = Base64.getDecoder().decode(msgJson["recipientAddress"] as String)
+                val adminAddr = (msgJson["adminAddress"] as String).hexToBytes()
+                val recipientAddr = (msgJson["recipientAddress"] as String).hexToBytes()
                 MessageReward.newBuilder()
                     .setAdminAddress(ByteString.copyFrom(adminAddr))
                     .setRecipientAddress(ByteString.copyFrom(recipientAddr))
@@ -700,8 +691,8 @@ class RpcTest {
                     .toByteArray()
             }
             "faucet" -> {
-                val signerAddr = Base64.getDecoder().decode(msgJson["signerAddress"] as String)
-                val recipientAddr = Base64.getDecoder().decode(msgJson["recipientAddress"] as String)
+                val signerAddr = (msgJson["signerAddress"] as String).hexToBytes()
+                val recipientAddr = (msgJson["recipientAddress"] as String).hexToBytes()
                 MessageFaucet.newBuilder()
                     .setSignerAddress(ByteString.copyFrom(signerAddr))
                     .setRecipientAddress(ByteString.copyFrom(recipientAddr))
@@ -737,49 +728,29 @@ class RpcTest {
         // Get public key bytes
         val pubKeyBytes = signerKey.publicKey.hexToBytes()
         
-        // Build the transaction JSON
-        val txJsonObject = if (msgType == "send") {
-            // "send" is in RegisteredMessages, must use msg field
-            buildJsonObject {
-                put("type", JsonPrimitive(msgType))
-                put("msg", buildJsonObject {
-                    for ((k, v) in msgJson) {
-                        when (v) {
-                            is String -> put(k, JsonPrimitive(v))
-                            is Long -> put(k, JsonPrimitive(v))
-                            is Number -> put(k, JsonPrimitive(v.toLong()))
-                            else -> put(k, JsonPrimitive(v.toString()))
-                        }
+        // Build the transaction using structured JSON for every plugin message.
+        val txJsonObject = buildJsonObject {
+            put("type", JsonPrimitive(msgType))
+            put("msg", buildJsonObject {
+                for ((k, v) in msgJson) {
+                    when (v) {
+                        is String -> put(k, JsonPrimitive(v))
+                        is Long -> put(k, JsonPrimitive(v))
+                        is Number -> put(k, JsonPrimitive(v.toLong()))
+                        else -> put(k, JsonPrimitive(v.toString()))
                     }
-                })
-                put("signature", buildJsonObject {
-                    put("publicKey", JsonPrimitive(pubKeyBytes.toHexString()))
-                    put("signature", JsonPrimitive(signature.toHexString()))
-                })
-                put("time", JsonPrimitive(txTime))
-                put("createdHeight", JsonPrimitive(height))
-                put("fee", JsonPrimitive(fee))
-                put("memo", JsonPrimitive(""))
-                put("networkID", JsonPrimitive(networkId))
-                put("chainID", JsonPrimitive(chainId))
-            }
-        } else {
-            // Plugin-only types: use msgTypeUrl/msgBytes for exact byte control
-            buildJsonObject {
-                put("type", JsonPrimitive(msgType))
-                put("msgTypeUrl", JsonPrimitive(typeUrl))
-                put("msgBytes", JsonPrimitive(msgProtoBytes.toHexString()))
-                put("signature", buildJsonObject {
-                    put("publicKey", JsonPrimitive(pubKeyBytes.toHexString()))
-                    put("signature", JsonPrimitive(signature.toHexString()))
-                })
-                put("time", JsonPrimitive(txTime))
-                put("createdHeight", JsonPrimitive(height))
-                put("fee", JsonPrimitive(fee))
-                put("memo", JsonPrimitive(""))
-                put("networkID", JsonPrimitive(networkId))
-                put("chainID", JsonPrimitive(chainId))
-            }
+                }
+            })
+            put("signature", buildJsonObject {
+                put("publicKey", JsonPrimitive(pubKeyBytes.toHexString()))
+                put("signature", JsonPrimitive(signature.toHexString()))
+            })
+            put("time", JsonPrimitive(txTime))
+            put("createdHeight", JsonPrimitive(height))
+            put("fee", JsonPrimitive(fee))
+            put("memo", JsonPrimitive(""))
+            put("networkID", JsonPrimitive(networkId))
+            put("chainID", JsonPrimitive(chainId))
         }
         
         // Send the transaction
diff --git a/plugin/python/TUTORIAL.md b/plugin/python/TUTORIAL.md
index b3a4c845ad..f750dd2334 100644
--- a/plugin/python/TUTORIAL.md
+++ b/plugin/python/TUTORIAL.md
@@ -542,6 +542,8 @@ Each handler then decodes the raw bytes into the plugin's own `Faucet`/`Reward`
 - Without `?address`, it does a **range read** over the record prefix (`faucet_prefix()` / `reward_prefix()`) and returns every record.
 - With `?address=<hex>`, it does a **single-key read** (`key_for_faucet(addr)` / `key_for_reward(addr)`) and returns just that recipient's record.
 
+> **Important — the range prefix must be length-prefixed.** Stored keys are length-prefixed (`key_for_faucet(addr)` = `join_len_prefix(FAUCET_PREFIX, addr)`), so the prefix you pass to a **range read** must be length-prefixed too — that's exactly what `faucet_prefix()` returns (`join_len_prefix(FAUCET_PREFIX)`, i.e. `b"\x01\x64"`), **not** the raw byte `b"\x64"`. Passing the raw prefix byte misaligns Canopy's length-prefixed iterator and crashes the node with `panic: corrupt or incomplete key`. (Single-key reads via `key_for_faucet(addr)` are already length-prefixed, so they're unaffected.)
+
 The server is already started from `main.py` (no change needed):
 
 ```python
@@ -728,8 +730,10 @@ When submitting signed transactions to the RPC endpoint (`/v1/tx`), the signatur
 Key points:
 - Canopy uses BLS12-381 signatures (96-byte G2 signatures)
 - Use the `blspy` library with `BasicSchemeMPL` for signing
+- Encode every protobuf `bytes` field as a hexadecimal string in the message JSON
 - Sign the deterministically marshaled protobuf bytes of the Transaction (without signature field)
-- For plugin-only message types (faucet, reward), use `msgTypeUrl` and `msgBytes` fields for exact byte control
+- Submit native and plugin-only message types as structured `msg` JSON through `/v1/tx`
+- The JSON hex encoding does not change the raw bytes stored in the protobuf message
 
 See `rpc_test.py` in `plugin/python/tutorial` for the complete signing implementation.
 
diff --git a/plugin/python/tutorial/rpc_test.py b/plugin/python/tutorial/rpc_test.py
index 813aa9e126..beffb92875 100644
--- a/plugin/python/tutorial/rpc_test.py
+++ b/plugin/python/tutorial/rpc_test.py
@@ -15,7 +15,6 @@
 import time
 import json
 import secrets
-import base64
 from dataclasses import dataclass
 import urllib.request
 import urllib.error
@@ -55,11 +54,6 @@ def random_address_hex() -> str:
     return os.urandom(20).hex()
 
 
-def hex_to_base64(hex_str: str) -> str:
-    """Convert hex string to base64 (for protojson bytes encoding)."""
-    return base64.b64encode(bytes.fromhex(hex_str)).decode('utf-8')
-
-
 def hex_to_bytes(hex_str: str) -> bytes:
     """Convert hex string to bytes."""
     return bytes.fromhex(hex_str)
@@ -227,23 +221,23 @@ def build_sign_and_send_tx(
     if not type_url:
         raise ValueError(f"Unknown message type: {msg_type}")
     
-    # Create protobuf message for signing
+    # Create protobuf message for signing (addresses are hex in msg_json)
     if msg_type == 'send':
         msg = tx_pb2.MessageSend()
-        msg.from_address = base64.b64decode(msg_json['fromAddress'])
-        msg.to_address = base64.b64decode(msg_json['toAddress'])
+        msg.from_address = hex_to_bytes(msg_json['fromAddress'])
+        msg.to_address = hex_to_bytes(msg_json['toAddress'])
         msg.amount = msg_json['amount']
         msg_proto = msg.SerializeToString()
     elif msg_type == 'reward':
         msg = tx_pb2.MessageReward()
-        msg.admin_address = base64.b64decode(msg_json['adminAddress'])
-        msg.recipient_address = base64.b64decode(msg_json['recipientAddress'])
+        msg.admin_address = hex_to_bytes(msg_json['adminAddress'])
+        msg.recipient_address = hex_to_bytes(msg_json['recipientAddress'])
         msg.amount = msg_json['amount']
         msg_proto = msg.SerializeToString()
     elif msg_type == 'faucet':
         msg = tx_pb2.MessageFaucet()
-        msg.signer_address = base64.b64decode(msg_json['signerAddress'])
-        msg.recipient_address = base64.b64decode(msg_json['recipientAddress'])
+        msg.signer_address = hex_to_bytes(msg_json['signerAddress'])
+        msg.recipient_address = hex_to_bytes(msg_json['recipientAddress'])
         msg.amount = msg_json['amount']
         msg_proto = msg.SerializeToString()
     else:
@@ -268,40 +262,21 @@ def build_sign_and_send_tx(
     # Get public key bytes
     pub_key_bytes = hex_to_bytes(signer_key.public_key)
     
-    # Build the transaction JSON
-    # For "send" (which is in RegisteredMessages), we must use "msg" field
-    # For plugin-only types (faucet, reward), we use msgTypeUrl/msgBytes for exact byte control
-    if msg_type == 'send':
-        tx = {
-            'type': msg_type,
-            'msg': msg_json,
-            'signature': {
-                'publicKey': bytes_to_hex(pub_key_bytes),
-                'signature': bytes_to_hex(signature),
-            },
-            'time': tx_time,
-            'createdHeight': height,
-            'fee': fee,
-            'memo': '',
-            'networkID': network_id,
-            'chainID': chain_id,
-        }
-    else:
-        tx = {
-            'type': msg_type,
-            'msgTypeUrl': type_url,
-            'msgBytes': bytes_to_hex(msg_proto),
-            'signature': {
-                'publicKey': bytes_to_hex(pub_key_bytes),
-                'signature': bytes_to_hex(signature),
-            },
-            'time': tx_time,
-            'createdHeight': height,
-            'fee': fee,
-            'memo': '',
-            'networkID': network_id,
-            'chainID': chain_id,
-        }
+    # Build the transaction using structured JSON for every plugin message.
+    tx = {
+        'type': msg_type,
+        'msg': msg_json,
+        'signature': {
+            'publicKey': bytes_to_hex(pub_key_bytes),
+            'signature': bytes_to_hex(signature),
+        },
+        'time': tx_time,
+        'createdHeight': height,
+        'fee': fee,
+        'memo': '',
+        'networkID': network_id,
+        'chainID': chain_id,
+    }
     
     # Send the transaction
     resp_body = post_raw_json(f"{rpc_url}/v1/tx", json.dumps(tx, indent=2))
@@ -320,8 +295,8 @@ def send_faucet_tx(
 ) -> str:
     """Send a faucet transaction."""
     faucet_msg = {
-        'signerAddress': hex_to_base64(signer_key.address),
-        'recipientAddress': hex_to_base64(recipient_addr),
+        'signerAddress': signer_key.address,
+        'recipientAddress': recipient_addr,
         'amount': amount,
     }
     
@@ -341,8 +316,8 @@ def send_send_tx(
 ) -> str:
     """Send a send transaction."""
     send_msg = {
-        'fromAddress': hex_to_base64(from_addr),
-        'toAddress': hex_to_base64(to_addr),
+        'fromAddress': from_addr,
+        'toAddress': to_addr,
         'amount': amount,
     }
     
@@ -362,8 +337,8 @@ def send_reward_tx(
 ) -> str:
     """Send a reward transaction."""
     reward_msg = {
-        'adminAddress': hex_to_base64(admin_addr),
-        'recipientAddress': hex_to_base64(recipient_addr),
+        'adminAddress': admin_addr,
+        'recipientAddress': recipient_addr,
         'amount': amount,
     }
     
diff --git a/plugin/typescript/TUTORIAL.md b/plugin/typescript/TUTORIAL.md
index 5189ce3311..76da2bc0ae 100644
--- a/plugin/typescript/TUTORIAL.md
+++ b/plugin/typescript/TUTORIAL.md
@@ -617,6 +617,8 @@ Each handler calls the detached, read-only `queryState`:
 - Without `?address`, it does a **range read** over the record prefix (`FaucetPrefix()` / `RewardPrefix()`) and returns every record.
 - With `?address=<hex>`, it does a **single-key read** (`KeyForFaucet(addr)` / `KeyForReward(addr)`) and returns just that recipient's record.
 
+> **Important — the range prefix must be length-prefixed.** Stored keys are length-prefixed (`KeyForFaucet(addr)` = `JoinLenPrefix(faucetPrefix, addr)`), so the prefix you pass to a **range read** must be length-prefixed too — that's exactly what `FaucetPrefix()` returns (`JoinLenPrefix(faucetPrefix)`, i.e. `[0x01, 0x64]`), **not** the raw buffer `[0x64]`. Passing the raw prefix byte misaligns Canopy's length-prefixed iterator and crashes the node with `panic: corrupt or incomplete key`. (Single-key reads via `KeyForFaucet(addr)` are already length-prefixed, so they're unaffected.)
+
 ### Query the endpoints
 
 After faucet/reward transactions have been included in blocks:
@@ -806,8 +808,10 @@ When submitting signed transactions to the RPC endpoint (`/v1/tx`), the signatur
 Key points:
 - Canopy uses BLS12-381 signatures (not Ed25519)
 - The tutorial test uses `@noble/curves` library for BLS signing
+- Encode every protobuf `bytes` field as a hexadecimal string in the message JSON
 - Sign the deterministically marshaled protobuf bytes of the Transaction (without signature field)
-- For plugin-only message types (faucet, reward), use `msgTypeUrl` and `msgBytes` fields for exact byte control
+- Submit native and plugin-only message types as structured `msg` JSON through `/v1/tx`
+- The JSON hex encoding does not change the raw bytes stored in the protobuf message
 
 See `src/rpc_test.ts` in `plugin/typescript/tutorial` for the complete signing implementation.
 
diff --git a/plugin/typescript/tutorial/src/rpc_test.ts b/plugin/typescript/tutorial/src/rpc_test.ts
index e9966c3020..cc379a2e8e 100644
--- a/plugin/typescript/tutorial/src/rpc_test.ts
+++ b/plugin/typescript/tutorial/src/rpc_test.ts
@@ -44,11 +44,6 @@ function randomAddressHex(): string {
     return randomBytes(20).toString('hex');
 }
 
-// Convert hex string to base64 (for protojson bytes encoding)
-function hexToBase64(hexStr: string): string {
-    return Buffer.from(hexStr, 'hex').toString('base64');
-}
-
 // Convert hex string to Uint8Array
 function hexToBytes(hexStr: string): Uint8Array {
     return new Uint8Array(Buffer.from(hexStr, 'hex'));
@@ -242,13 +237,13 @@ async function buildSignAndSendTx(
             throw new Error(`Unknown message type: ${msgType}`);
     }
 
-    // Create protobuf message for signing
+    // Create protobuf message for signing (addresses are hex in msgJSON)
     // Note: protobufjs uses camelCase field names in JavaScript
     let msgProto: Uint8Array;
     switch (msgType) {
         case 'send': {
-            const fromAddr = Buffer.from(msgJSON['fromAddress'] as string, 'base64');
-            const toAddr = Buffer.from(msgJSON['toAddress'] as string, 'base64');
+            const fromAddr = hexToBytes(msgJSON['fromAddress'] as string);
+            const toAddr = hexToBytes(msgJSON['toAddress'] as string);
             const msg = types.MessageSend.create({
                 fromAddress: fromAddr,
                 toAddress: toAddr,
@@ -258,8 +253,8 @@ async function buildSignAndSendTx(
             break;
         }
         case 'reward': {
-            const adminAddr = Buffer.from(msgJSON['adminAddress'] as string, 'base64');
-            const recipientAddr = Buffer.from(msgJSON['recipientAddress'] as string, 'base64');
+            const adminAddr = hexToBytes(msgJSON['adminAddress'] as string);
+            const recipientAddr = hexToBytes(msgJSON['recipientAddress'] as string);
             const msg = types.MessageReward.create({
                 adminAddress: adminAddr,
                 recipientAddress: recipientAddr,
@@ -269,8 +264,8 @@ async function buildSignAndSendTx(
             break;
         }
         case 'faucet': {
-            const signerAddr = Buffer.from(msgJSON['signerAddress'] as string, 'base64');
-            const recipientAddr = Buffer.from(msgJSON['recipientAddress'] as string, 'base64');
+            const signerAddr = hexToBytes(msgJSON['signerAddress'] as string);
+            const recipientAddr = hexToBytes(msgJSON['recipientAddress'] as string);
             const msg = types.MessageFaucet.create({
                 signerAddress: signerAddr,
                 recipientAddress: recipientAddr,
@@ -302,42 +297,21 @@ async function buildSignAndSendTx(
     // Get public key bytes
     const pubKeyBytes = hexToBytes(signerKey.publicKey);
 
-    // Build the transaction JSON
-    // For "send" (which is in RegisteredMessages), we must use "msg" field
-    // For plugin-only types (faucet, reward), we use msgTypeUrl/msgBytes for exact byte control
-    let tx: Record<string, unknown>;
-    if (msgType === 'send') {
-        tx = {
-            type: msgType,
-            msg: msgJSON,
-            signature: {
-                publicKey: bytesToHex(pubKeyBytes),
-                signature: bytesToHex(signature)
-            },
-            time: Number(txTime),
-            createdHeight: Number(height),
-            fee: Number(fee),
-            memo: '',
-            networkID: Number(networkId),
-            chainID: Number(chainId)
-        };
-    } else {
-        tx = {
-            type: msgType,
-            msgTypeUrl: typeURL,
-            msgBytes: bytesToHex(msgProto),
-            signature: {
-                publicKey: bytesToHex(pubKeyBytes),
-                signature: bytesToHex(signature)
-            },
-            time: Number(txTime),
-            createdHeight: Number(height),
-            fee: Number(fee),
-            memo: '',
-            networkID: Number(networkId),
-            chainID: Number(chainId)
-        };
-    }
+    // Build the transaction using structured JSON for every plugin message.
+    const tx: Record<string, unknown> = {
+        type: msgType,
+        msg: msgJSON,
+        signature: {
+            publicKey: bytesToHex(pubKeyBytes),
+            signature: bytesToHex(signature)
+        },
+        time: Number(txTime),
+        createdHeight: Number(height),
+        fee: Number(fee),
+        memo: '',
+        networkID: Number(networkId),
+        chainID: Number(chainId)
+    };
 
     // Send the transaction
     const respBody = await postRawJSON(`${rpcURL}/v1/tx`, JSON.stringify(tx, null, 2));
@@ -356,8 +330,8 @@ async function sendFaucetTx(
     height: bigint
 ): Promise<string> {
     const faucetMsg = {
-        signerAddress: hexToBase64(signerKey.address),
-        recipientAddress: hexToBase64(recipientAddr),
+        signerAddress: signerKey.address,
+        recipientAddress: recipientAddr,
         amount: Number(amount)
     };
 
@@ -386,8 +360,8 @@ async function sendSendTx(
     height: bigint
 ): Promise<string> {
     const sendMsg = {
-        fromAddress: hexToBase64(fromAddr),
-        toAddress: hexToBase64(toAddr),
+        fromAddress: fromAddr,
+        toAddress: toAddr,
         amount: Number(amount)
     };
 
@@ -407,8 +381,8 @@ async function sendRewardTx(
     height: bigint
 ): Promise<string> {
     const rewardMsg = {
-        adminAddress: hexToBase64(adminAddr),
-        recipientAddress: hexToBase64(recipientAddr),
+        adminAddress: adminAddr,
+        recipientAddress: recipientAddr,
         amount: Number(amount)
     };
 
@@ -473,11 +447,14 @@ async function testPluginTransactions(): Promise<void> {
 
     // Wait for faucet transaction to be included in a block
     console.log('Waiting for faucet transaction to be confirmed...');
+    // Generous timeout: a dev node can take many blocks to finalize/index a tx (especially right
+    // after a restart while consensus warms up), so don't fail on transient finalization lag.
+    const txTimeout = 120000; // 120s
     const faucetIncluded = await waitForTxInclusion(
         QUERY_RPC_URL,
         account1Addr,
         faucetTxHash,
-        30000
+        txTimeout
     );
     if (!faucetIncluded) {
         throw new Error('Faucet transaction not included within timeout');
@@ -521,7 +498,7 @@ async function testPluginTransactions(): Promise<void> {
 
     // Wait for send transaction to be included
     console.log('Waiting for send transaction to be confirmed...');
-    const sendIncluded = await waitForTxInclusion(QUERY_RPC_URL, account1Addr, sendTxHash, 30000);
+    const sendIncluded = await waitForTxInclusion(QUERY_RPC_URL, account1Addr, sendTxHash, txTimeout);
     if (!sendIncluded) {
         throw new Error('Send transaction not included within timeout');
     }
@@ -569,7 +546,7 @@ async function testPluginTransactions(): Promise<void> {
         QUERY_RPC_URL,
         account2Addr,
         rewardTxHash,
-        30000
+        txTimeout
     );
     if (!rewardIncluded) {
         throw new Error('Reward transaction not included within timeout');