diff --git a/psf-memo-client/src/services/hex.js b/psf-memo-client/src/services/hex.js
index 5ef989a..604b42b 100644
--- a/psf-memo-client/src/services/hex.js
+++ b/psf-memo-client/src/services/hex.js
@@ -25,4 +25,15 @@ function hexToBytes (hex, byteLength = 32, label = 'Value') {
   return bytes
 }
 
-module.exports = { hexToBytes }
+// Build the raw OP_RETURN payload for a txid-referencing Memo action: the
+// given 32-byte txid followed by a UTF-8 encoded value.
+function buildTxidTextPayload (txid, text) {
+  const txidBytes = hexToBytes(txid, 32, 'Poll txid')
+  const textBytes = new TextEncoder().encode(text)
+  const raw = new Uint8Array(txidBytes.length + textBytes.length)
+  raw.set(txidBytes, 0)
+  raw.set(textBytes, txidBytes.length)
+  return raw
+}
+
+module.exports = { hexToBytes, buildTxidTextPayload }
diff --git a/psf-memo-client/src/services/memo-poll-option.js b/psf-memo-client/src/services/memo-poll-option.js
index 5b5ac8b..e947d43 100644
--- a/psf-memo-client/src/services/memo-poll-option.js
+++ b/psf-memo-client/src/services/memo-poll-option.js
@@ -6,25 +6,22 @@
   prefix followed by the poll's 32-byte txid and the option text. The option
   text is limited to 184 bytes.
 
-  The wallet and an injected poll store are used so this module stays testable
-  and free of UI/network concerns; environmentally unsuitable I/O lives behind
-  those small adapter boundaries.
+  It shares the txid-embedding broadcast flow with MemoTxidAction and builds
+  its wire payload from the shared txid+text helper.
 
   Constants
     MEMO_ADD_POLL_OPTION_PREFIX : hex prefix for the Memo add-poll-option action (0x6d13)
     MAX_OPTION_BYTES            : maximum option byte length (184)
-    POLL_TXID_BYTES             : poll txid byte length (32)
 */
 
-const MemoAction = require('./memo-action')
+const MemoTxidAction = require('./memo-txid-action')
 const { byteLength } = require('./utf8')
-const { hexToBytes } = require('./hex')
+const { buildTxidTextPayload } = require('./hex')
 
 const MEMO_ADD_POLL_OPTION_PREFIX = '6d13'
 const MAX_OPTION_BYTES = 184
-const POLL_TXID_BYTES = 32
 
-class MemoPollOption extends MemoAction {
+class MemoPollOption extends MemoTxidAction {
   static config = {
     prefix: MEMO_ADD_POLL_OPTION_PREFIX,
     walletRequiredMsg: 'Memo poll option requires a wallet.',
@@ -34,40 +31,14 @@ class MemoPollOption extends MemoAction {
     validationCode: 'poll_option_validation'
   }
 
-  constructor (deps = {}) {
-    super(deps)
-    this.pollTxid = deps.pollTxid || ''
-    this.polls = deps.polls || null
-  }
-
   // A poll option is over-length when its UTF-8 byte count exceeds the limit.
   isTooLong (option) {
     return byteLength(option) > MAX_OPTION_BYTES
   }
 
   // Compose and broadcast a Memo add-poll-option action.
-  async add (option) {
-    const check = this.validate(option)
-    this._throwIfInvalid(check)
-
-    if (!this.wallet) {
-      throw new Error(this.walletRequiredMsg)
-    }
-
-    if (!this.pollTxid) {
-      const err = new Error('Poll txid is required.')
-      err.code = 'poll_option_validation'
-      throw err
-    }
-
-    await this.wallet.getUtxos()
-
-    const raw = buildAddPollOptionPayload(this.pollTxid, option)
-    const txid = await this.wallet.sendOpReturn(raw, this.prefix)
-
-    this.reflect(txid, option)
-
-    return txid
+  add (option) {
+    return this.broadcastTxid(option, buildTxidTextPayload)
   }
 
   // Record the new option on the injected poll store when one is present.
@@ -83,17 +54,6 @@ class MemoPollOption extends MemoAction {
   }
 }
 
-// Build the raw OP_RETURN message payload for an add-poll-option action.
-// The protocol wire format is: <poll txid 32 bytes><option UTF-8 bytes>.
-function buildAddPollOptionPayload (pollTxid, option) {
-  const txidBytes = hexToBytes(pollTxid, POLL_TXID_BYTES, 'Poll txid')
-  const textBytes = new TextEncoder().encode(option)
-  const raw = new Uint8Array(txidBytes.length + textBytes.length)
-  raw.set(txidBytes, 0)
-  raw.set(textBytes, txidBytes.length)
-  return raw
-}
-
 MemoPollOption.MEMO_ADD_POLL_OPTION_PREFIX = MEMO_ADD_POLL_OPTION_PREFIX
 MemoPollOption.MAX_OPTION_BYTES = MAX_OPTION_BYTES
 
diff --git a/psf-memo-client/src/services/memo-poll-vote.js b/psf-memo-client/src/services/memo-poll-vote.js
index 4db8c3f..f95b6f1 100644
--- a/psf-memo-client/src/services/memo-poll-vote.js
+++ b/psf-memo-client/src/services/memo-poll-vote.js
@@ -6,25 +6,22 @@
   by the poll's 32-byte txid and a comment. The comment is limited to 184
   bytes.
 
-  The wallet and an injected poll store are used so this module stays testable
-  and free of UI/network concerns; environmentally unsuitable I/O lives behind
-  those small adapter boundaries.
+  It shares the txid-embedding broadcast flow with MemoTxidAction and builds
+  its wire payload from the shared txid+text helper.
 
   Constants
     MEMO_POLL_VOTE_PREFIX : hex prefix for the Memo poll-vote action (0x6d14)
     MAX_COMMENT_BYTES     : maximum comment byte length (184)
-    POLL_TXID_BYTES       : poll txid byte length (32)
 */
 
-const MemoAction = require('./memo-action')
+const MemoTxidAction = require('./memo-txid-action')
 const { byteLength } = require('./utf8')
-const { hexToBytes } = require('./hex')
+const { buildTxidTextPayload } = require('./hex')
 
 const MEMO_POLL_VOTE_PREFIX = '6d14'
 const MAX_COMMENT_BYTES = 184
-const POLL_TXID_BYTES = 32
 
-class MemoPollVote extends MemoAction {
+class MemoPollVote extends MemoTxidAction {
   static config = {
     prefix: MEMO_POLL_VOTE_PREFIX,
     walletRequiredMsg: 'Memo poll vote requires a wallet.',
@@ -34,40 +31,14 @@ class MemoPollVote extends MemoAction {
     validationCode: 'poll_vote_validation'
   }
 
-  constructor (deps = {}) {
-    super(deps)
-    this.pollTxid = deps.pollTxid || ''
-    this.polls = deps.polls || null
-  }
-
   // A poll vote comment is over-length when its UTF-8 byte count exceeds the limit.
   isTooLong (comment) {
     return byteLength(comment) > MAX_COMMENT_BYTES
   }
 
   // Compose and broadcast a Memo poll-vote action.
-  async vote (comment) {
-    const check = this.validate(comment)
-    this._throwIfInvalid(check)
-
-    if (!this.wallet) {
-      throw new Error(this.walletRequiredMsg)
-    }
-
-    if (!this.pollTxid) {
-      const err = new Error('Poll txid is required.')
-      err.code = 'poll_vote_validation'
-      throw err
-    }
-
-    await this.wallet.getUtxos()
-
-    const raw = buildPollVotePayload(this.pollTxid, comment)
-    const txid = await this.wallet.sendOpReturn(raw, this.prefix)
-
-    this.reflect(txid, comment)
-
-    return txid
+  vote (comment) {
+    return this.broadcastTxid(comment, buildTxidTextPayload)
   }
 
   // Record the new vote on the injected poll store when one is present.
@@ -83,17 +54,6 @@ class MemoPollVote extends MemoAction {
   }
 }
 
-// Build the raw OP_RETURN message payload for a poll-vote action.
-// The protocol wire format is: <poll txid 32 bytes><comment UTF-8 bytes>.
-function buildPollVotePayload (pollTxid, comment) {
-  const txidBytes = hexToBytes(pollTxid, POLL_TXID_BYTES, 'Poll txid')
-  const textBytes = new TextEncoder().encode(comment)
-  const raw = new Uint8Array(txidBytes.length + textBytes.length)
-  raw.set(txidBytes, 0)
-  raw.set(textBytes, txidBytes.length)
-  return raw
-}
-
 MemoPollVote.MEMO_POLL_VOTE_PREFIX = MEMO_POLL_VOTE_PREFIX
 MemoPollVote.MAX_COMMENT_BYTES = MAX_COMMENT_BYTES
 
diff --git a/psf-memo-client/src/services/memo-txid-action.js b/psf-memo-client/src/services/memo-txid-action.js
new file mode 100644
index 0000000..c82b35c
--- /dev/null
+++ b/psf-memo-client/src/services/memo-txid-action.js
@@ -0,0 +1,50 @@
+/*
+  Shared base for Memo actions that reference a parent poll by txid (e.g. an
+  add-poll-option or a poll-vote). Such actions broadcast an OP_RETURN payload
+  that embeds the parent poll's 32-byte txid followed by a short UTF-8 value.
+
+  Subclasses extend MemoAction's config with the poll-specific messages and
+  codes, and supply the wire payload via the injected buildPayload function.
+
+  The wallet and an injected poll store are used so this module stays testable
+  and free of UI/network concerns; environmentally unsuitable I/O lives behind
+  those small adapter boundaries.
+*/
+
+const MemoAction = require('./memo-action')
+
+class MemoTxidAction extends MemoAction {
+  constructor (deps = {}) {
+    super(deps)
+    this.pollTxid = deps.pollTxid || ''
+    this.polls = deps.polls || null
+  }
+
+  // Compose and broadcast an action that embeds this.pollTxid plus the given
+  // value through the supplied buildPayload(pollTxid, value) function.
+  async broadcastTxid (value, buildPayload) {
+    const check = this.validate(value)
+    this._throwIfInvalid(check)
+
+    if (!this.wallet) {
+      throw new Error(this.walletRequiredMsg)
+    }
+
+    if (!this.pollTxid) {
+      const err = new Error('Poll txid is required.')
+      err.code = this.validationCode
+      throw err
+    }
+
+    await this.wallet.getUtxos()
+
+    const raw = buildPayload(this.pollTxid, value)
+    const txid = await this.wallet.sendOpReturn(raw, this.prefix)
+
+    this.reflect(txid, value)
+
+    return txid
+  }
+}
+
+module.exports = MemoTxidAction
diff --git a/psf-memo-client/src/services/poll-action-page.js b/psf-memo-client/src/services/poll-action-page.js
new file mode 100644
index 0000000..848e721
--- /dev/null
+++ b/psf-memo-client/src/services/poll-action-page.js
@@ -0,0 +1,55 @@
+/*
+  Shared base for page controllers that submit a single-text Memo action
+  against a parent poll (e.g. add a poll option or cast a poll vote), with a
+  byte counter that counts down from the field's limit.
+
+  Such a page holds the current input, computes the remaining byte budget,
+  validates/broadcasts through an injected action handler, and surfaces the
+  result through the shared PageController flow (no navigation on success).
+
+  Subclasses supply a static config:
+    handlerKey       - deps key holding the action handler
+    busyKey          - instance key for the in-flight flag
+    actionMethod     - handler method to invoke for the current input
+    requiresMsg      - error message when no handler is injected
+    maxBytes         - the field's byte limit
+    validationCodes  - error codes for local validation failures
+
+  The handler and navigate concerns are injected so this module stays free of
+  UI/network concerns; environmentally unsuitable I/O lives behind those small
+  adapter boundaries.
+*/
+
+const PageController = require('./page-controller')
+const { byteLength } = require('./utf8')
+
+class PollActionPage extends PageController {
+  constructor (deps = {}) {
+    super(deps)
+    const cfg = this.constructor.config
+    this[cfg.handlerKey] = deps[cfg.handlerKey] || null
+    this[cfg.busyKey] = false
+    this.validationCodes = cfg.validationCodes
+  }
+
+  // Bytes remaining before the field's limit is reached.
+  remainingCount () {
+    return this.constructor.config.maxBytes - byteLength(this.input)
+  }
+
+  // Set the in-flight flag.
+  _setBusy (value) {
+    this[this.constructor.config.busyKey] = value
+  }
+
+  // Run the action handler for the current input.
+  async _perform (input) {
+    const cfg = this.constructor.config
+    if (!this[cfg.handlerKey]) {
+      throw new Error(cfg.requiresMsg)
+    }
+    return this[cfg.handlerKey][cfg.actionMethod](input)
+  }
+}
+
+module.exports = PollActionPage
diff --git a/psf-memo-client/src/services/poll-option-page.js b/psf-memo-client/src/services/poll-option-page.js
index d5bcc77..13cfad0 100644
--- a/psf-memo-client/src/services/poll-option-page.js
+++ b/psf-memo-client/src/services/poll-option-page.js
@@ -3,47 +3,25 @@
   action, with a byte counter that counts down from the option limit.
 
   This is the testable controller behind the React poll option composer. It
-  wraps the Memo poll-option behavior (src/services/memo-poll-option.js).
+  wraps the Memo poll-option behavior (src/services/memo-poll-option.js)
+  through the shared PollActionPage base.
 
   The memoPollOption and navigate concerns are injected so this module stays
   free of UI/network concerns; environmentally unsuitable I/O lives behind
   those small adapter boundaries.
 */
 
-const PageController = require('./page-controller')
+const PollActionPage = require('./poll-action-page')
 const MemoPollOption = require('./memo-poll-option')
 
-class PollOptionPage extends PageController {
-  constructor (deps = {}) {
-    super(deps)
-    this.memoPollOption = deps.memoPollOption || null
-    this.adding = false
-    this.validationCodes = ['poll_option_validation', 'poll_option_length']
-  }
-
-  // Bytes remaining for the option text.
-  remainingCount () {
-    if (!this.memoPollOption) {
-      throw new Error('Poll option page requires a memo poll option handler.')
-    }
-    return MemoPollOption.MAX_OPTION_BYTES - this._optionBytes()
-  }
-
-  _optionBytes () {
-    return new TextEncoder().encode(this.input).length
-  }
-
-  // Set the in-flight flag.
-  _setBusy (value) {
-    this.adding = value
-  }
-
-  // Run the memo poll option action for the current input.
-  async _perform (input) {
-    if (!this.memoPollOption) {
-      throw new Error('Poll option page requires a memo poll option handler.')
-    }
-    return this.memoPollOption.add(input)
+class PollOptionPage extends PollActionPage {
+  static config = {
+    handlerKey: 'memoPollOption',
+    busyKey: 'adding',
+    actionMethod: 'add',
+    requiresMsg: 'Poll option page requires a memo poll option handler.',
+    maxBytes: MemoPollOption.MAX_OPTION_BYTES,
+    validationCodes: ['poll_option_validation', 'poll_option_length']
   }
 }
 
diff --git a/psf-memo-client/src/services/poll-vote-page.js b/psf-memo-client/src/services/poll-vote-page.js
index 8c273a2..828ba4b 100644
--- a/psf-memo-client/src/services/poll-vote-page.js
+++ b/psf-memo-client/src/services/poll-vote-page.js
@@ -2,48 +2,26 @@
   Poll Vote Page behavior: compose and broadcast a Memo poll-vote action, with
   a byte counter that counts down from the comment limit.
 
-  This is the testable controller behind the React poll vote composer. It wraps
-  the Memo poll-vote behavior (src/services/memo-poll-vote.js).
+  This is the testable controller behind the React poll vote composer. It
+  wraps the Memo poll-vote behavior (src/services/memo-poll-vote.js) through
+  the shared PollActionPage base.
 
   The memoPollVote and navigate concerns are injected so this module stays
   free of UI/network concerns; environmentally unsuitable I/O lives behind
   those small adapter boundaries.
 */
 
-const PageController = require('./page-controller')
+const PollActionPage = require('./poll-action-page')
 const MemoPollVote = require('./memo-poll-vote')
 
-class PollVotePage extends PageController {
-  constructor (deps = {}) {
-    super(deps)
-    this.memoPollVote = deps.memoPollVote || null
-    this.voting = false
-    this.validationCodes = ['poll_vote_validation', 'poll_vote_length']
-  }
-
-  // Bytes remaining for the vote comment.
-  remainingCount () {
-    if (!this.memoPollVote) {
-      throw new Error('Poll vote page requires a memo poll vote handler.')
-    }
-    return MemoPollVote.MAX_COMMENT_BYTES - this._commentBytes()
-  }
-
-  _commentBytes () {
-    return new TextEncoder().encode(this.input).length
-  }
-
-  // Set the in-flight flag.
-  _setBusy (value) {
-    this.voting = value
-  }
-
-  // Run the memo poll vote action for the current input.
-  async _perform (input) {
-    if (!this.memoPollVote) {
-      throw new Error('Poll vote page requires a memo poll vote handler.')
-    }
-    return this.memoPollVote.vote(input)
+class PollVotePage extends PollActionPage {
+  static config = {
+    handlerKey: 'memoPollVote',
+    busyKey: 'voting',
+    actionMethod: 'vote',
+    requiresMsg: 'Poll vote page requires a memo poll vote handler.',
+    maxBytes: MemoPollVote.MAX_COMMENT_BYTES,
+    validationCodes: ['poll_vote_validation', 'poll_vote_length']
   }
 }
 
diff --git a/psf-memo-client/test/property/poll-services.property.test.js b/psf-memo-client/test/property/poll-services.property.test.js
new file mode 100644
index 0000000..fa7ac6d
--- /dev/null
+++ b/psf-memo-client/test/property/poll-services.property.test.js
@@ -0,0 +1,162 @@
+/*
+  Property tests for the Memo poll services and their page controllers.
+
+  These pin down invariants over broad random inputs that the unit tests only
+  probe at fixed fixtures:
+
+    - Round-trip: buildTxidTextPayload encodes a poll txid + text into the
+      canonical Memo wire payload, so the stored reverse-hex txid and the
+      UTF-8 text both decode back unchanged.
+    - hexToBytes length contract: only 64-character hex txids decode to
+      32 bytes; everything else throws.
+    - Page byte conservation: remainingCount is always maxBytes minus the
+      UTF-8 byte length of the current input.
+    - Rejection classification: empty inputs fail as validation and over-long
+      inputs fail as length, in both cases without broadcasting.
+*/
+
+'use strict'
+
+const test = require('node:test')
+const { seededRandom, forAll } = require('./harness')
+const { hexToBytes, buildTxidTextPayload } = require('../../src/services/hex')
+const { byteLength } = require('../../src/services/utf8')
+const MemoPollOption = require('../../src/services/memo-poll-option')
+const MemoPollVote = require('../../src/services/memo-poll-vote')
+const PollOptionPage = require('../../src/services/poll-option-page')
+const PollVotePage = require('../../src/services/poll-vote-page')
+
+const rng = seededRandom(20260828)
+
+function randomTxid () {
+  const hex = '0123456789abcdef'
+  let s = ''
+  for (let i = 0; i < 64; i++) {
+    s += hex[Math.floor(rng() * 16)]
+  }
+  return s
+}
+
+function randomText (maxBytes) {
+  const charset = ['a', 'b', 'c', 'd', ' ', 'é', '\u{1F600}']
+  let s = ''
+  let budget = maxBytes
+  while (budget > 0) {
+    const ch = charset[Math.floor(rng() * charset.length)]
+    s += ch
+    budget -= byteLength(ch)
+  }
+  return s
+}
+
+function makeWallet () {
+  return {
+    walletInfo: { cashAddress: 'bitcoincash:qtest' },
+    broadcasts: [],
+    async getUtxos () { return [] },
+    async sendOpReturn (msg, prefix) {
+      this.broadcasts.push({ msg, prefix })
+      return 'aa'.repeat(32)
+    }
+  }
+}
+
+test('buildTxidTextPayload round-trips the canonical Memo wire format', async () => {
+  await forAll(
+    () => ({ txid: randomTxid(), text: randomText(200) }),
+    ({ txid, text }) => {
+      const bytes = buildTxidTextPayload(txid, text)
+      if (bytes.length !== 32 + byteLength(text)) return false
+      // The payload carries the txid's literal 32 bytes in order, followed by
+      // the UTF-8 bytes of the value.
+      const expectedTxidBytes = hexToBytes(txid, 32, 'Poll txid')
+      for (let i = 0; i < 32; i++) {
+        if (bytes[i] !== expectedTxidBytes[i]) return false
+      }
+      const storedText = Buffer.from(bytes.slice(32)).toString('utf8')
+      return storedText === text
+    },
+    { label: 'poll txid+text wire round-trip' }
+  )
+})
+
+test('hexToBytes decodes only exactly 64 hex characters to 32 bytes', async () => {
+  await forAll(
+    () => {
+      const len = Math.floor(rng() * 80)
+      const hex = '0123456789abcdef'
+      let s = ''
+      for (let i = 0; i < len; i++) {
+        s += hex[Math.floor(rng() * 16)]
+      }
+      return s
+    },
+    (s) => {
+      if (s.length === 64) {
+        return hexToBytes(s, 32, 'Poll txid').length === 32
+      }
+      let threw = false
+      try {
+        hexToBytes(s, 32, 'Poll txid')
+      } catch (err) {
+        threw = true
+      }
+      return threw
+    },
+    { label: 'hexToBytes length contract' }
+  )
+})
+
+test('poll pages conserve the remaining byte count', async () => {
+  await forAll(
+    () => {
+      const mode = Math.floor(rng() * 2)
+      return { mode, text: randomText(400) }
+    },
+    ({ mode, text }) => {
+      const Page = mode === 0 ? PollOptionPage : PollVotePage
+      const handlerKey = mode === 0 ? 'memoPollOption' : 'memoPollVote'
+      const page = new Page({ [handlerKey]: {} })
+      page.setInput(text)
+      const limit = mode === 0
+        ? MemoPollOption.MAX_OPTION_BYTES
+        : MemoPollVote.MAX_COMMENT_BYTES
+      return page.remainingCount() === limit - byteLength(text)
+    },
+    { label: 'poll page remaining byte conservation' }
+  )
+})
+
+test('poll pages reject empty as validation and over-long as length without broadcasting', async () => {
+  await forAll(
+    () => {
+      const mode = Math.floor(rng() * 2)
+      const kind = Math.floor(rng() * 2) // 0 = empty, 1 = over-long
+      return { mode, kind }
+    },
+    async ({ mode, kind }) => {
+      const wallet = makeWallet()
+      const txid = randomTxid()
+      const Handler = mode === 0 ? MemoPollOption : MemoPollVote
+      const handler = new Handler({ wallet, pollTxid: txid })
+      const Page = mode === 0 ? PollOptionPage : PollVotePage
+      const page = new Page({
+        [mode === 0 ? 'memoPollOption' : 'memoPollVote']: handler
+      })
+      const limit = mode === 0
+        ? MemoPollOption.MAX_OPTION_BYTES
+        : MemoPollVote.MAX_COMMENT_BYTES
+      const input = kind === 0 ? '' : 'x'.repeat(limit + 100)
+      const validationCode = mode === 0 ? 'poll_option_validation' : 'poll_vote_validation'
+      const lengthCode = mode === 0 ? 'poll_option_length' : 'poll_vote_length'
+
+      page.setInput(input)
+      const result = await page.submit()
+
+      if (wallet.broadcasts.length !== 0) return false
+      if (result.ok !== false) return false
+      return page.submitError === (kind === 0 ? validationCode : lengthCode)
+    },
+    { label: 'poll page rejection classification' }
+  )
+})
diff --git a/psf-memo-db/src/adapters/poll-query.js b/psf-memo-db/src/adapters/poll-query.js
index a19c706..1ed54e7 100644
--- a/psf-memo-db/src/adapters/poll-query.js
+++ b/psf-memo-db/src/adapters/poll-query.js
@@ -52,23 +52,23 @@ class PollQuery {
   }
 
   async getPollOptions (txid) {
-    const options = []
-    for await (const [key, value] of this.pollOptionsDb.iterator()) {
-      if (value?.pollTxid === txid) {
-        options.push({ ...value, txid: key })
-      }
-    }
-    return options
+    return this._collectByPollTxid(this.pollOptionsDb, txid)
   }
 
   async getPollVotes (txid) {
-    const votes = []
-    for await (const [key, value] of this.pollVotesDb.iterator()) {
+    return this._collectByPollTxid(this.pollVotesDb, txid)
+  }
+
+  // Collect every record in `db` that references the given poll txid, keeping
+  // each stored record's `txid` key alongside its value.
+  async _collectByPollTxid (db, txid) {
+    const items = []
+    for await (const [key, value] of db.iterator()) {
       if (value?.pollTxid === txid) {
-        votes.push({ ...value, txid: key })
+        items.push({ ...value, txid: key })
       }
     }
-    return votes
+    return items
   }
 }
 
diff --git a/psf-memo-db/src/use-cases/get-poll-options.js b/psf-memo-db/src/use-cases/get-poll-options.js
index d6435e8..1cc75ef 100644
--- a/psf-memo-db/src/use-cases/get-poll-options.js
+++ b/psf-memo-db/src/use-cases/get-poll-options.js
@@ -2,26 +2,11 @@
   Use case: read the options for a single Memo poll.
 */
 
-class GetPollOptions {
+import { PollReadUseCase } from './lib/poll-read-use-case.js'
+
+class GetPollOptions extends PollReadUseCase {
   constructor (localConfig = {}) {
-    this.adapters = localConfig.adapters
-    if (!this.adapters) {
-      throw new Error('Adapters required when instantiating GetPollOptions use case.')
-    }
-    if (!this.adapters.pollQuery) {
-      throw new Error('pollQuery adapter required for GetPollOptions use case.')
-    }
-
-    this.execute = this.execute.bind(this)
-  }
-
-  parseTxid (txid) {
-    if (!txid || typeof txid !== 'string') {
-      const err = new Error('txid is required')
-      err.status = 400
-      throw err
-    }
-    return txid
+    super(localConfig, { useCaseName: 'GetPollOptions' })
   }
 
   async execute (inObj = {}) {
diff --git a/psf-memo-db/src/use-cases/get-poll-votes.js b/psf-memo-db/src/use-cases/get-poll-votes.js
index 4e21658..195c1f9 100644
--- a/psf-memo-db/src/use-cases/get-poll-votes.js
+++ b/psf-memo-db/src/use-cases/get-poll-votes.js
@@ -2,26 +2,11 @@
   Use case: read the votes for a single Memo poll.
 */
 
-class GetPollVotes {
+import { PollReadUseCase } from './lib/poll-read-use-case.js'
+
+class GetPollVotes extends PollReadUseCase {
   constructor (localConfig = {}) {
-    this.adapters = localConfig.adapters
-    if (!this.adapters) {
-      throw new Error('Adapters required when instantiating GetPollVotes use case.')
-    }
-    if (!this.adapters.pollQuery) {
-      throw new Error('pollQuery adapter required for GetPollVotes use case.')
-    }
-
-    this.execute = this.execute.bind(this)
-  }
-
-  parseTxid (txid) {
-    if (!txid || typeof txid !== 'string') {
-      const err = new Error('txid is required')
-      err.status = 400
-      throw err
-    }
-    return txid
+    super(localConfig, { useCaseName: 'GetPollVotes' })
   }
 
   async execute (inObj = {}) {
diff --git a/psf-memo-db/src/use-cases/get-poll.js b/psf-memo-db/src/use-cases/get-poll.js
index a7245e8..6d96e24 100644
--- a/psf-memo-db/src/use-cases/get-poll.js
+++ b/psf-memo-db/src/use-cases/get-poll.js
@@ -2,26 +2,11 @@
   Use case: read a single Memo poll, including its options and votes.
 */
 
-class GetPoll {
+import { PollReadUseCase } from './lib/poll-read-use-case.js'
+
+class GetPoll extends PollReadUseCase {
   constructor (localConfig = {}) {
-    this.adapters = localConfig.adapters
-    if (!this.adapters) {
-      throw new Error('Adapters required when instantiating GetPoll use case.')
-    }
-    if (!this.adapters.pollQuery) {
-      throw new Error('pollQuery adapter required for GetPoll use case.')
-    }
-
-    this.execute = this.execute.bind(this)
-  }
-
-  parseTxid (txid) {
-    if (!txid || typeof txid !== 'string') {
-      const err = new Error('txid is required')
-      err.status = 400
-      throw err
-    }
-    return txid
+    super(localConfig, { useCaseName: 'GetPoll' })
   }
 
   async execute (inObj = {}) {
diff --git a/psf-memo-db/src/use-cases/lib/poll-read-use-case.js b/psf-memo-db/src/use-cases/lib/poll-read-use-case.js
new file mode 100644
index 0000000..6522c4b
--- /dev/null
+++ b/psf-memo-db/src/use-cases/lib/poll-read-use-case.js
@@ -0,0 +1,32 @@
+/*
+  Shared construction and txid-validation contract for poll read use cases.
+
+  Each poll read use case validates that an adapters bundle with a pollQuery
+  adapter is supplied and binds its execute method, and shares the identical
+  `txid is required` input validation. Centralizing this removes per-class
+  constructor and parseTxid boilerplate.
+*/
+
+export class PollReadUseCase {
+  constructor (localConfig = {}, { useCaseName } = {}) {
+    this.adapters = localConfig.adapters
+    if (!this.adapters) {
+      throw new Error(`Adapters required when instantiating ${useCaseName} use case.`)
+    }
+    if (!this.adapters.pollQuery) {
+      throw new Error(`pollQuery adapter required for ${useCaseName} use case.`)
+    }
+    this.execute = this.execute.bind(this)
+  }
+
+  // A poll read always targets a single txid; reject empty or non-string ids
+  // with a 400 status so the REST layer maps it to a client error.
+  parseTxid (txid) {
+    if (!txid || typeof txid !== 'string') {
+      const err = new Error('txid is required')
+      err.status = 400
+      throw err
+    }
+    return txid
+  }
+}
diff --git a/psf-memo-db/test/property/poll-query.property.test.js b/psf-memo-db/test/property/poll-query.property.test.js
new file mode 100644
index 0000000..c0a4145
--- /dev/null
+++ b/psf-memo-db/test/property/poll-query.property.test.js
@@ -0,0 +1,149 @@
+/*
+  Property tests for the PollQuery adapter's option and vote filtering.
+
+  These pin down invariants the unit tests probe at fixed fixtures:
+
+    - Partition/conservation: getPollOptions(txid) returns exactly the
+      records that reference that poll, and the records are partitioned such
+      that every stored record is returned by exactly one poll.
+    - Value fidelity: each returned record keeps its own txid key and its
+      original option/comment text.
+*/
+
+import test from 'node:test'
+
+import { seededRandom, forAll, txidGen } from './harness.js'
+import PollQuery from '../../src/adapters/poll-query.js'
+
+const rng = seededRandom(20260828)
+
+function makeDb () {
+  const store = new Map()
+  return {
+    async get (key) {
+      if (!store.has(key)) {
+        const err = new Error('not found')
+        err.notFound = true
+        throw err
+      }
+      return store.get(key)
+    },
+    async put (key, value) {
+      store.set(key, value)
+    },
+    iterator () {
+      const entries = Array.from(store.entries())
+      let i = 0
+      return {
+        [Symbol.asyncIterator] () {
+          return this
+        },
+        async next () {
+          if (i >= entries.length) return { done: true }
+          const entry = entries[i++]
+          return { value: entry, done: false }
+        }
+      }
+    }
+  }
+}
+
+function randomText (prefix) {
+  return `${prefix}-${Math.floor(rng() * 1e6)}`
+}
+
+test('getPollOptions returns exactly the options for the requested poll', async () => {
+  await forAll(
+    () => {
+      const pollCount = 1 + Math.floor(rng() * 8)
+      const polls = []
+      for (let i = 0; i < pollCount; i++) {
+        polls.push({ txid: txidGen(rng), count: Math.floor(rng() * 6) })
+      }
+      return polls
+    },
+    async (polls) => {
+      const pollOptionsDb = makeDb()
+      const query = new PollQuery({ pollsDb: makeDb(), pollOptionsDb, pollVotesDb: makeDb() })
+      const byPoll = new Map()
+
+      for (const poll of polls) {
+        const records = []
+        for (let i = 0; i < poll.count; i++) {
+          const key = `${poll.txid}-opt-${i}`
+          const value = { pollTxid: poll.txid, option: randomText('opt') }
+          await pollOptionsDb.put(key, value)
+          records.push({ ...value, txid: key })
+        }
+        byPoll.set(poll.txid, records)
+      }
+
+      for (const poll of polls) {
+        const got = await query.getPollOptions(poll.txid)
+        const expected = byPoll.get(poll.txid)
+        if (got.length !== expected.length) return false
+        const gotMap = new Map(got.map((r) => [r.txid, r.option]))
+        for (const rec of expected) {
+          if (gotMap.get(rec.txid) !== rec.option) return false
+        }
+      }
+      return true
+    },
+    { label: 'getPollOptions per-poll fidelity', samples: 200 }
+  )
+})
+
+test('getPollOptions partitions all stored options without loss', async () => {
+  await forAll(
+    () => {
+      const n = Math.floor(rng() * 30)
+      const records = []
+      for (let i = 0; i < n; i++) {
+        records.push({ key: `opt-${i}`, pollTxid: txidGen(rng), option: randomText('opt') })
+      }
+      return records
+    },
+    async (records) => {
+      const pollOptionsDb = makeDb()
+      for (const rec of records) {
+        await pollOptionsDb.put(rec.key, { pollTxid: rec.pollTxid, option: rec.option })
+      }
+      const query = new PollQuery({ pollsDb: makeDb(), pollOptionsDb, pollVotesDb: makeDb() })
+
+      const distinctPolls = [...new Set(records.map((r) => r.pollTxid))]
+      let seen = 0
+      const seenKeys = new Set()
+      for (const pollTxid of distinctPolls) {
+        for (const rec of await query.getPollOptions(pollTxid)) {
+          seen++
+          seenKeys.add(rec.txid)
+        }
+      }
+      return seen === records.length && seenKeys.size === records.length
+    },
+    { label: 'getPollOptions partition conservation' }
+  )
+})
+
+test('getPollVotes returns votes that preserve their comment and key', async () => {
+  await forAll(
+    () => {
+      const pollTxid = txidGen(rng)
+      const n = Math.floor(rng() * 10)
+      return { pollTxid, n }
+    },
+    async ({ pollTxid, n }) => {
+      const pollVotesDb = makeDb()
+      const query = new PollQuery({ pollsDb: makeDb(), pollOptionsDb: makeDb(), pollVotesDb })
+      for (let i = 0; i < n; i++) {
+        await pollVotesDb.put(`vote-${i}`, { pollTxid, comment: randomText('vote') })
+      }
+      // Add an unrelated vote that must be excluded.
+      await pollVotesDb.put('other', { pollTxid: txidGen(rng), comment: 'x' })
+
+      const got = await query.getPollVotes(pollTxid)
+      return got.length === n && got.every((r) => r.pollTxid === pollTxid && r.comment.startsWith('vote-'))
+    },
+    { label: 'getPollVotes fidelity and exclusion' }
+  )
+})
diff --git a/psf-memo-indexer/src/use-cases/action-types/poll-child.js b/psf-memo-indexer/src/use-cases/action-types/poll-child.js
new file mode 100644
index 0000000..a08c4a3
--- /dev/null
+++ b/psf-memo-indexer/src/use-cases/action-types/poll-child.js
@@ -0,0 +1,60 @@
+/*
+  Shared record creation for Memo actions that reference a parent poll by
+  txid and carry a single UTF-8 value (an add-poll-option or a poll-vote).
+
+  Both payloads have the same shape: exactly three pushes, a 32-byte poll
+  txid, and a non-empty value. Each handler stores the parsed record on its
+  own store, differing only in the store, the value field name, and the error
+  label used in process-error messages.
+*/
+
+import { utf8FromPush, logProcessError, txHashFromPush } from './helpers.js'
+import { TX_HASH_LENGTH } from '../../lib/memo-codes.js'
+
+// Validate a poll-txid child action payload and store the resulting record.
+// Returns true when stored, false when an error was logged.
+//
+// `ctx`     - the handler context (adapters, txid, signerAddr, decoded, seen,
+//             blockHeight)
+// `db`      - the poll option or poll vote store
+// `valueField` - record field holding the parsed UTF-8 value
+// `label`      - action label used in process-error messages
+// `emptyMessage` - process-error message for an empty value
+export async function storePollChildRecord ({
+  ctx,
+  db,
+  valueField,
+  label,
+  emptyMessage
+}) {
+  const { adapters, txid, signerAddr, decoded, seen, blockHeight } = ctx
+  const { pushDatas } = decoded
+
+  if (pushDatas.length !== 3) {
+    await logProcessError(adapters, txid, `invalid ${label} push data count ${pushDatas.length}`, blockHeight)
+    return false
+  }
+
+  if (pushDatas[1].length !== TX_HASH_LENGTH) {
+    await logProcessError(adapters, txid, `${label} poll tx hash wrong size`, blockHeight)
+    return false
+  }
+
+  const pollTxid = txHashFromPush(pushDatas[1])
+  const value = utf8FromPush(pushDatas[2])
+
+  if (!value.length) {
+    await logProcessError(adapters, txid, emptyMessage, blockHeight)
+    return false
+  }
+
+  await db.create(txid, {
+    addr: signerAddr,
+    pollTxid,
+    [valueField]: value,
+    seen,
+    blockHeight
+  })
+
+  return true
+}
diff --git a/psf-memo-indexer/src/use-cases/action-types/poll-create.js b/psf-memo-indexer/src/use-cases/action-types/poll-create.js
index 8db953b..9eb7345 100644
--- a/psf-memo-indexer/src/use-cases/action-types/poll-create.js
+++ b/psf-memo-indexer/src/use-cases/action-types/poll-create.js
@@ -19,30 +19,42 @@ function normalizePollCreateDatas (pushDatas) {
     return { ok: false, error: `invalid create-poll push data count ${pushDatas?.length || 0}` }
   }
 
-  let payload
+  const { ok, payload, error } = buildCreatePollPayload(pushDatas)
+  if (!ok) {
+    return { ok: false, error }
+  }
+
+  return {
+    ok: true,
+    pollType: payload[0],
+    optionCount: payload[1],
+    question: utf8FromPush(payload.subarray(2))
+  }
+}
+
+// Resolve the poll payload buffer the create-poll action encodes, which Memo
+// wallets may write as either a single combined push (prefix + poll_type +
+// option_count + question) or as separate pushes. Returns
+// { ok: false, error } on malformed input, or { ok: true, payload }.
+function buildCreatePollPayload (pushDatas) {
   if (pushDatas.length === 2) {
     // Combined push: prefix(2) + poll_type(1) + option_count(1) + question.
     const combined = pushDatas[1]
     if (combined.length < 2) {
       return { ok: false, error: 'create-poll payload too short' }
     }
-    payload = combined
-  } else {
-    // Separate pushes for poll_type, option_count, and question.
-    if (pushDatas.length !== 4) {
-      return { ok: false, error: `invalid create-poll push data count ${pushDatas.length}` }
-    }
-    const typeBuf = pushDatas[1]
-    const countBuf = pushDatas[2]
-    const questionBuf = pushDatas[3]
-    payload = Buffer.concat([typeBuf, countBuf, questionBuf])
+    return { ok: true, payload: combined }
   }
 
-  const pollType = payload[0]
-  const optionCount = payload[1]
-  const question = utf8FromPush(payload.subarray(2))
+  // Separate pushes for poll_type, option_count, and question.
+  if (pushDatas.length !== 4) {
+    return { ok: false, error: `invalid create-poll push data count ${pushDatas.length}` }
+  }
 
-  return { ok: true, pollType, optionCount, question }
+  const typeBuf = pushDatas[1]
+  const countBuf = pushDatas[2]
+  const questionBuf = pushDatas[3]
+  return { ok: true, payload: Buffer.concat([typeBuf, countBuf, questionBuf]) }
 }
 
 export async function handleCreatePoll (ctx) {
diff --git a/psf-memo-indexer/src/use-cases/action-types/poll-option.js b/psf-memo-indexer/src/use-cases/action-types/poll-option.js
index a8628ef..e75ecdf 100644
--- a/psf-memo-indexer/src/use-cases/action-types/poll-option.js
+++ b/psf-memo-indexer/src/use-cases/action-types/poll-option.js
@@ -1,35 +1,11 @@
-import { utf8FromPush, logProcessError, txHashFromPush } from './helpers.js'
-import { TX_HASH_LENGTH } from '../../lib/memo-codes.js'
+import { storePollChildRecord } from './poll-child.js'
 
 export async function handleAddPollOption (ctx) {
-  const { adapters, txid, signerAddr, decoded, seen, blockHeight } = ctx
-  const { pushDatas } = decoded
-
-  if (pushDatas.length !== 3) {
-    await logProcessError(adapters, txid, `invalid add-poll-option push data count ${pushDatas.length}`, blockHeight)
-    return
-  }
-
-  if (pushDatas[1].length !== TX_HASH_LENGTH) {
-    await logProcessError(adapters, txid, 'add-poll-option poll tx hash wrong size', blockHeight)
-    return
-  }
-
-  const pollTxid = txHashFromPush(pushDatas[1])
-  const option = utf8FromPush(pushDatas[2])
-
-  if (!option.length) {
-    await logProcessError(adapters, txid, 'empty poll option', blockHeight)
-    return
-  }
-
-  const optionData = {
-    addr: signerAddr,
-    pollTxid,
-    option,
-    seen,
-    blockHeight
-  }
-
-  await adapters.pollOptionDb.create(txid, optionData)
+  return storePollChildRecord({
+    ctx,
+    db: ctx.adapters.pollOptionDb,
+    valueField: 'option',
+    label: 'add-poll-option',
+    emptyMessage: 'empty poll option'
+  })
 }
diff --git a/psf-memo-indexer/src/use-cases/action-types/poll-vote.js b/psf-memo-indexer/src/use-cases/action-types/poll-vote.js
index 98b7e99..536d19b 100644
--- a/psf-memo-indexer/src/use-cases/action-types/poll-vote.js
+++ b/psf-memo-indexer/src/use-cases/action-types/poll-vote.js
@@ -1,35 +1,11 @@
-import { utf8FromPush, logProcessError, txHashFromPush } from './helpers.js'
-import { TX_HASH_LENGTH } from '../../lib/memo-codes.js'
+import { storePollChildRecord } from './poll-child.js'
 
 export async function handlePollVote (ctx) {
-  const { adapters, txid, signerAddr, decoded, seen, blockHeight } = ctx
-  const { pushDatas } = decoded
-
-  if (pushDatas.length !== 3) {
-    await logProcessError(adapters, txid, `invalid poll-vote push data count ${pushDatas.length}`, blockHeight)
-    return
-  }
-
-  if (pushDatas[1].length !== TX_HASH_LENGTH) {
-    await logProcessError(adapters, txid, 'poll-vote poll tx hash wrong size', blockHeight)
-    return
-  }
-
-  const pollTxid = txHashFromPush(pushDatas[1])
-  const comment = utf8FromPush(pushDatas[2])
-
-  if (!comment.length) {
-    await logProcessError(adapters, txid, 'empty poll vote comment', blockHeight)
-    return
-  }
-
-  const voteData = {
-    addr: signerAddr,
-    pollTxid,
-    comment,
-    seen,
-    blockHeight
-  }
-
-  await adapters.pollVoteDb.create(txid, voteData)
+  return storePollChildRecord({
+    ctx,
+    db: ctx.adapters.pollVoteDb,
+    valueField: 'comment',
+    label: 'poll-vote',
+    emptyMessage: 'empty poll vote comment'
+  })
 }
diff --git a/psf-memo-indexer/test/property/poll-action.property.test.js b/psf-memo-indexer/test/property/poll-action.property.test.js
new file mode 100644
index 0000000..6b3e709
--- /dev/null
+++ b/psf-memo-indexer/test/property/poll-action.property.test.js
@@ -0,0 +1,192 @@
+/*
+  Property tests for the indexer's poll action handlers.
+
+  These pin down invariants the unit tests only probe at fixed fixtures:
+
+    - normalizePollCreateDatas round-trips a poll_type / option_count /
+      question triple through both the separate-push and the combined-push
+      encodings.
+    - storePollChildRecord (used by add-poll-option and poll-vote) stores the
+      reverse-hex poll txid and the exact UTF-8 value for any valid payload,
+      and rejects malformed payloads without storing.
+*/
+
+import test from 'node:test'
+
+import { seededRandom, forAll } from './harness.js'
+import { normalizePollCreateDatas } from '../../src/use-cases/action-types/poll-create.js'
+import { handleAddPollOption } from '../../src/use-cases/action-types/poll-option.js'
+import { handlePollVote } from '../../src/use-cases/action-types/poll-vote.js'
+
+const rng = seededRandom(20260828)
+
+function randomHex (len) {
+  const hex = '0123456789abcdef'
+  let out = ''
+  for (let i = 0; i < len; i++) {
+    out += hex[Math.floor(rng() * 16)]
+  }
+  return out
+}
+
+function randomText () {
+  const charset = ['a', 'b', ' ', 'é']
+  let s = ''
+  const n = Math.floor(rng() * 20)
+  for (let i = 0; i < n; i++) {
+    s += charset[Math.floor(rng() * charset.length)]
+  }
+  return s
+}
+
+function makeDb () {
+  const store = new Map()
+  return {
+    async get (key) {
+      if (!store.has(key)) {
+        const err = new Error('not found')
+        err.notFound = true
+        throw err
+      }
+      return store.get(key)
+    },
+    async create (key, data) {
+      store.set(key, data)
+      return { success: true }
+    },
+    entries () {
+      return Array.from(store.entries())
+    }
+  }
+}
+
+test('normalizePollCreateDatas round-trips separate pushes', async () => {
+  await forAll(
+    () => ({
+      pollType: Math.floor(rng() * 256),
+      optionCount: Math.floor(rng() * 256),
+      question: randomText()
+    }),
+    ({ pollType, optionCount, question }) => {
+      const prefix = Buffer.from('6d10', 'hex')
+      const pushDatas = [
+        prefix,
+        Buffer.from([pollType]),
+        Buffer.from([optionCount]),
+        Buffer.from(question, 'utf8')
+      ]
+      const result = normalizePollCreateDatas(pushDatas)
+      return result.ok &&
+        result.pollType === pollType &&
+        result.optionCount === optionCount &&
+        result.question === question
+    },
+    { label: 'normalizePollCreateDatas separate-push round-trip' }
+  )
+})
+
+test('normalizePollCreateDatas round-trips a combined push', async () => {
+  await forAll(
+    () => ({
+      pollType: Math.floor(rng() * 256),
+      optionCount: Math.floor(rng() * 256),
+      question: randomText()
+    }),
+    ({ pollType, optionCount, question }) => {
+      const prefix = Buffer.from('6d10', 'hex')
+      const combined = Buffer.concat([
+        Buffer.from([pollType]),
+        Buffer.from([optionCount]),
+        Buffer.from(question, 'utf8')
+      ])
+      const result = normalizePollCreateDatas([prefix, combined])
+      return result.ok &&
+        result.pollType === pollType &&
+        result.optionCount === optionCount &&
+        result.question === question
+    },
+    { label: 'normalizePollCreateDatas combined-push round-trip' }
+  )
+})
+
+test('add-option and poll-vote store the reverse txid and exact value', async () => {
+  await forAll(
+    () => ({
+      kind: Math.floor(rng() * 2),
+      txidHex: randomHex(64),
+      value: randomText()
+    }),
+    async ({ kind, txidHex, value }) => {
+      if (value.length === 0) return true
+      const adapters = {
+        pollOptionDb: makeDb(),
+        pollVoteDb: makeDb(),
+        processErrorDb: makeDb()
+      }
+      const txidBytes = Buffer.from(txidHex, 'hex').reverse()
+      const handler = kind === 0 ? handleAddPollOption : handlePollVote
+      const store = kind === 0 ? adapters.pollOptionDb : adapters.pollVoteDb
+      const field = kind === 0 ? 'option' : 'comment'
+
+      await handler({
+        adapters,
+        txid: 'txid-1',
+        signerAddr: 'bitcoincash:qaddr-a',
+        seen: 1,
+        blockHeight: 100,
+        decoded: {
+          action: kind === 0 ? 'addPollOption' : 'pollVote',
+          prefix: Buffer.from(kind === 0 ? '6d13' : '6d14', 'hex'),
+          pushDatas: [Buffer.from('6d', 'hex'), txidBytes, Buffer.from(value, 'utf8')]
+        }
+      })
+
+      const record = await store.get('txid-1')
+      return record.pollTxid === txidHex && record[field] === value &&
+        adapters.processErrorDb.entries().length === 0
+    },
+    { label: 'add-option and poll-vote record invariants' }
+  )
+})
+
+test('add-option and poll-vote reject a wrong-size txid without storing', async () => {
+  await forAll(
+    () => ({
+      kind: Math.floor(rng() * 2),
+      badLen: 1 + Math.floor(rng() * 40)
+    }),
+    async ({ kind, badLen }) => {
+      if (badLen === 32) return true
+      const adapters = {
+        pollOptionDb: makeDb(),
+        pollVoteDb: makeDb(),
+        processErrorDb: makeDb()
+      }
+      const handler = kind === 0 ? handleAddPollOption : handlePollVote
+      const store = kind === 0 ? adapters.pollOptionDb : adapters.pollVoteDb
+
+      await handler({
+        adapters,
+        txid: 'txid-1',
+        signerAddr: 'bitcoincash:qaddr-a',
+        seen: 1,
+        blockHeight: 100,
+        decoded: {
+          action: kind === 0 ? 'addPollOption' : 'pollVote',
+          prefix: Buffer.from(kind === 0 ? '6d13' : '6d14', 'hex'),
+          pushDatas: [Buffer.from('6d', 'hex'), Buffer.alloc(badLen, 1), Buffer.from('yes', 'utf8')]
+        }
+      })
+
+      let stored = false
+      try {
+        await store.get('txid-1')
+        stored = true
+      } catch (err) {
+        // expected: not stored
+      }
+      return !stored && adapters.processErrorDb.entries().length > 0
+    },
+    { label: 'wrong-size txid rejection' }
+  )
+})