What changed, and why it matters
This commit adds support for a new Solana transaction format (version 1) to the Trezor hardware wallet firmware. It is a feature addition, not a security fix. The code parses the new transaction layout, extracts a priority fee from a config field, and adds unit tests. There is no indication in the commit or supplied references that this resolves a known security vulnerability.
No security action required. Review as normal feature code; ensure v1 parsing bounds checks and config mask validation are covered by tests, which they appear to be.
Security signals we found
No strong security signals were identified.
Evidence from the diff
The change extends core/src/apps/solana/transaction/__init__.py to recognize and parse Solana SIMD-0385 v1 transactions. It introduces a config mask parser, fixed-size instruction headers, and a separate fee calculation path that uses config_priority_fee for v1 while ignoring ComputeBudget instructions. Legacy/v0 parsing is refactored into separate helper methods. Unit tests are expanded to cover v1 serialization, config validation, and fee behavior. No security-relevant bug fixes, bounds-check corrections, or disclosure references are present.
Changed components
core/src/apps/solana/transaction/__init__.pycore/tests/test_apps.solana.transaction.pycore/src/apps/solana/README.mdInspect captured patch +392 / −40
### core/.changelog.d/8055.added
@@ -0,0 +1 @@
+Solana: Add support for v1 transactions.
### core/src/apps/solana/README.md
@@ -138,6 +138,43 @@ The new transaction format must be distinguished from the legacy transaction for
+---------------+---------------------------+-----------------+---------------------------+-----------------+
```
+### v1 transaction format
+
+Version 1 transactions ([SIMD-0385](https://github.com/solana-foundation/solana-improvement-documents/blob/main/proposals/0385-transaction-v1.md)) have a layout of their own. There are no lookup tables, the counts have a fixed size, and all the instruction headers precede the instruction payloads. The signatures come last instead of first.
+
+```
++----------------------------------------------------------------+
+| v1 transaction format |
++-----------------------------+----------------------------------+
+| version (1B) | 0x81 |
+| header (3B) | same as in legacy transactions |
+| config mask (4B) | u32 LE |
+| blockhash (32B) | |
+| # of instructions (1B) | |
+| # of account addresses (1B) | |
+| account addresses | 32B each |
+| config values | selected by the config mask |
+| instruction headers | 4B each |
+| instruction payloads | account address indexes and data |
++-----------------------------+----------------------------------+
+```
+
+```
++----------------------------------------------------------------------------------+
+| v1 instruction header |
++-----------------------+-----------------------------------+----------------------+
+| Program id index (1B) | # of account address indexes (1B) | Data length (2B, LE) |
++-----------------------+-----------------------------------+----------------------+
+```
+
+The config replaces the ComputeBudget instructions, which don't configure v1 transactions. Its mask selects the values that follow, in this order:
+- bits 0 and 1 (both or none): priority fee, u64 LE, in lamports (not per compute unit)
+- bit 2: compute unit limit, u32 LE
+- bit 3: loaded accounts data size limit, u32 LE
+- bit 4: heap size, u32 LE
+
+Masks with other bits set are rejected. Only the priority fee is shown, the other values are resource limits which affect neither the fee nor the accounts.
+
## Solana app basic concept and software architecture
The software architecture designed for signing Solana messages utilizes a system of parser functions to construct objects from various classes. At its core is the `Transaction` class, serving as the higher-level entity responsible for encapsulating all transaction-related information. This includes a list of instructions derived from the `Instruction` class. This structure can seamlessly handle both legacy and versioned transactions.
### core/src/apps/solana/transaction/__init__.py
@@ -1,9 +1,12 @@
+from micropython import const
from typing import TYPE_CHECKING
from trezor.crypto import base58
from trezor.utils import BufferReader
from trezor.wire import DataError
+from apps.common.readers import read_uint16_le, read_uint32_le, read_uint64_le
+
from ..constants import (
MICROLAMPORTS_PER_LAMPORT,
SOLANA_BASE_FEE_LAMPORTS,
@@ -26,6 +29,23 @@
from ..types import Account, Address, AddressReference, RawInstruction
+# Config mask bits of v1 transactions, the config values follow in this order:
+# https://github.com/anza-xyz/solana-sdk/blob/891412dceb0a7d3d4116ac295eef519882138090/message/src/versions/v1/config.rs
+_CONFIG_PRIORITY_FEE = const(0b0_0011) # u64, both bits must be set
+_CONFIG_COMPUTE_UNIT_LIMIT = const(0b0_0100) # u32
+_CONFIG_LOADED_ACCOUNTS_DATA_SIZE_LIMIT = const(0b0_1000) # u32
+_CONFIG_HEAP_SIZE = const(0b1_0000) # u32
+_CONFIG_KNOWN_BITS = const(
+ _CONFIG_PRIORITY_FEE
+ | _CONFIG_COMPUTE_UNIT_LIMIT
+ | _CONFIG_LOADED_ACCOUNTS_DATA_SIZE_LIMIT
+ | _CONFIG_HEAP_SIZE
+)
+
+# Program id index (u8), number of account indexes (u8), and data length (u16).
+_V1_INSTRUCTION_HEADER_SIZE = const(4)
+
+
class Fee:
def __init__(
self,
@@ -55,6 +75,9 @@ class Transaction:
address_lookup_tables_rw_addresses: list[AddressReference]
address_lookup_tables_ro_addresses: list[AddressReference]
+ # Priority fee in lamports set in the config of v1 transactions.
+ config_priority_fee: int
+
def __init__(self, serialized_tx: AnyBytes) -> None:
self._parse_transaction(serialized_tx)
self._create_instructions()
@@ -64,31 +87,56 @@ def _parse_transaction(self, serialized_tx: AnyBytes) -> None:
serialized_tx_reader = BufferReader(serialized_tx)
self._parse_header(serialized_tx_reader)
- self._parse_addresses(serialized_tx_reader)
-
- self.blockhash = parse_block_hash(serialized_tx_reader)
-
- self._parse_instructions(serialized_tx_reader)
-
- self._parse_address_lookup_tables(serialized_tx_reader)
+ if self.version == 1:
+ self._parse_body_v1(serialized_tx_reader)
+ else:
+ self._parse_body_legacy_v0(serialized_tx_reader)
if serialized_tx_reader.remaining_count() != 0:
raise DataError("Invalid transaction")
def _parse_header(self, serialized_tx_reader: BufferReader) -> None:
if serialized_tx_reader.peek() & 0b10000000:
self.version = serialized_tx_reader.get() & 0b01111111
- # only version 0 is supported
- if self.version > 0:
+ # only versions 0 and 1 are supported
+ if self.version > 1:
raise DataError("Unsupported transaction version")
self.required_signers_count: int = serialized_tx_reader.get()
self.num_signature_read_only_addresses: int = serialized_tx_reader.get()
self.num_read_only_addresses: int = serialized_tx_reader.get()
- def _parse_addresses(self, serialized_tx_reader: BufferReader) -> None:
+ def _parse_body_legacy_v0(self, serialized_tx_reader: BufferReader) -> None:
+ """Parses the rest of legacy and v0 transactions."""
num_of_addresses = parse_var_int(serialized_tx_reader)
+ self._parse_addresses(serialized_tx_reader, num_of_addresses)
+
+ self.blockhash = parse_block_hash(serialized_tx_reader)
+
+ self._parse_instructions_legacy_v0(serialized_tx_reader)
+ self._parse_address_lookup_tables(serialized_tx_reader)
+
+ def _parse_body_v1(self, serialized_tx_reader: BufferReader) -> None:
+ config_mask = read_uint32_le(serialized_tx_reader)
+
+ self.blockhash = parse_block_hash(serialized_tx_reader)
+
+ num_of_instructions = serialized_tx_reader.get()
+ num_of_addresses = serialized_tx_reader.get()
+ self._parse_addresses(serialized_tx_reader, num_of_addresses)
+
+ self._parse_config(serialized_tx_reader, config_mask)
+
+ self._parse_instructions_v1(serialized_tx_reader, num_of_instructions)
+
+ # v1 has no address lookup tables.
+ self.address_lookup_tables_rw_addresses = []
+ self.address_lookup_tables_ro_addresses = []
+
+ def _parse_addresses(
+ self, serialized_tx_reader: BufferReader, num_of_addresses: int
+ ) -> None:
if self.num_signature_read_only_addresses >= self.required_signers_count:
raise DataError("At least one writable signer required")
if (
@@ -114,7 +162,32 @@ def _parse_addresses(self, serialized_tx_reader: BufferReader) -> None:
self.addresses = addresses
- def _parse_instructions(self, serialized_tx_reader: BufferReader) -> None:
+ def _parse_config(
+ self, serialized_tx_reader: BufferReader, config_mask: int
+ ) -> None:
+ # Masks rejected by solana-sdk.
+ if config_mask | _CONFIG_KNOWN_BITS != _CONFIG_KNOWN_BITS:
+ raise DataError("Unsupported transaction config")
+
+ priority_fee_bits = config_mask & _CONFIG_PRIORITY_FEE
+ if priority_fee_bits not in (0, _CONFIG_PRIORITY_FEE):
+ raise DataError("Invalid transaction config")
+ if priority_fee_bits:
+ self.config_priority_fee = read_uint64_le(serialized_tx_reader)
+ else:
+ self.config_priority_fee = 0
+
+ # The remaining values are resource limits that affect neither the fee
+ # nor the accounts, so they are not shown.
+ for bit in (
+ _CONFIG_COMPUTE_UNIT_LIMIT,
+ _CONFIG_LOADED_ACCOUNTS_DATA_SIZE_LIMIT,
+ _CONFIG_HEAP_SIZE,
+ ):
+ if config_mask & bit:
+ read_uint32_le(serialized_tx_reader)
+
+ def _parse_instructions_legacy_v0(self, serialized_tx_reader: BufferReader) -> None:
num_of_instructions = parse_var_int(serialized_tx_reader)
self.raw_instructions = []
@@ -130,6 +203,28 @@ def _parse_instructions(self, serialized_tx_reader: BufferReader) -> None:
self.raw_instructions.append((program_index, list(accounts), data))
+ def _parse_instructions_v1(
+ self, serialized_tx_reader: BufferReader, num_of_instructions: int
+ ) -> None:
+ # All instruction headers come first, followed by all the payloads.
+ headers_reader = BufferReader(
+ serialized_tx_reader.read_memoryview(
+ _V1_INSTRUCTION_HEADER_SIZE * num_of_instructions
+ )
+ )
+
+ self.raw_instructions = []
+
+ for _ in range(num_of_instructions):
+ program_index = headers_reader.get()
+ num_of_accounts = headers_reader.get()
+ data_length = read_uint16_le(headers_reader)
+
+ accounts = serialized_tx_reader.read_memoryview(num_of_accounts)
+ data = serialized_tx_reader.read_memoryview(data_length)
+
+ self.raw_instructions.append((program_index, list(accounts), data))
+
def _parse_address_lookup_tables(self, serialized_tx: BufferReader) -> None:
self.address_lookup_tables_rw_addresses = []
self.address_lookup_tables_ro_addresses = []
@@ -215,6 +310,22 @@ def calculate_fee(self) -> Fee | None:
base_fee = SOLANA_BASE_FEE_LAMPORTS * number_of_signers
+ priority_fee = self._calculate_priority_fee()
+ rent = self.calculate_rent()
+ if rent is None:
+ return None
+ return Fee(
+ base=base_fee,
+ priority=priority_fee,
+ rent=rent,
+ )
+
+ def _calculate_priority_fee(self) -> int:
+ """Returns the priority fee in lamports."""
+ if self.version == 1:
+ # v1 ignores ComputeBudget instructions in favor of the config.
+ return self.config_priority_fee
+
unit_price = 0
is_unit_price_set = False
unit_limit = SOLANA_COMPUTE_UNIT_LIMIT
@@ -238,15 +349,9 @@ def calculate_fee(self) -> Fee | None:
is_unit_price_set = True
priority_fee = unit_price * unit_limit # in microlamports
- rent = self.calculate_rent()
- if rent is None:
- return None
- return Fee(
- base=base_fee,
- priority=(priority_fee + MICROLAMPORTS_PER_LAMPORT - 1)
- // MICROLAMPORTS_PER_LAMPORT,
- rent=rent,
- )
+ return (
+ priority_fee + MICROLAMPORTS_PER_LAMPORT - 1
+ ) // MICROLAMPORTS_PER_LAMPORT
def get_account_address(self, account: Account) -> bytes | None:
if not is_address_reference(account):
### core/tests/test_apps.solana.transaction.py
@@ -1,12 +1,21 @@
from typing import TYPE_CHECKING
+from trezor.crypto import base58
from trezor.utils import BufferReader
from trezor.wire import DataError
-from apps.common.writers import write_bytes_unchecked, write_uint8, write_uvarint
+from apps.common.writers import (
+ write_bytes_unchecked,
+ write_uint8,
+ write_uint16_le,
+ write_uint32_le,
+ write_uint64_le,
+ write_uvarint,
+)
from common import unittest, utils
if not utils.BITCOIN_ONLY:
+ from apps.solana.constants import SOLANA_BASE_FEE_LAMPORTS
from apps.solana.transaction import Transaction
from apps.solana.transaction.parse import parse_var_int
from apps.solana.types import AddressType
@@ -27,12 +36,24 @@
RawInstruction = tuple[int, Sequence[int], AnyBytes]
# Address lookup table (ALT): account, read-write and read-only indexes.
Alt = tuple[AnyBytes, Sequence[int], Sequence[int]]
+ # Priority fee, compute unit limit, loaded accounts data size limit, and
+ # heap size of a v1 transaction, each None if not set.
+ TxConfig = tuple[int | None, int | None, int | None, int | None]
BLOCKHASH = b"h" * 32
+NO_CONFIG: TxConfig = (None, None, None, None)
+# Mask bits and serialization of the TxConfig values, in the same order.
+CONFIG_FIELDS = (
+ (0b00011, write_uint64_le),
+ (0b00100, write_uint32_le),
+ (0b01000, write_uint32_le),
+ (0b10000, write_uint32_le),
+)
+
-# Serialization of the legacy and v0 transaction formats,
+# Serialization of the legacy, v0, and v1 transaction formats,
# as described in core/src/apps/solana/README.md.
@@ -80,27 +101,84 @@ def write_alt(w: Writer, alt: Alt) -> None:
write_compact_array(w, ro_indexes, write_uint8)
+def write_tx_body_legacy_v0(
+ w: Writer,
+ accounts: Sequence[AnyBytes],
+ instructions: Sequence[RawInstruction],
+ blockhash: AnyBytes,
+ version: int | None,
+ alts: Sequence[Alt],
+) -> None:
+ write_compact_array(w, accounts, write_bytes_unchecked)
+ write_bytes_unchecked(w, blockhash)
+ write_compact_array(w, instructions, write_instruction)
+ if version is not None:
+ write_compact_array(w, alts, write_alt)
+
+
+def get_config_mask(config: TxConfig) -> int:
+ config_mask = 0
+ for (bits, _), value in zip(CONFIG_FIELDS, config):
+ if value is not None:
+ config_mask |= bits
+ return config_mask
+
+
+def write_tx_body_v1(
+ w: Writer,
+ accounts: Sequence[AnyBytes],
+ instructions: Sequence[RawInstruction],
+ blockhash: AnyBytes,
+ config: TxConfig,
+ config_mask: int | None,
+) -> None:
+ """If `config_mask` is None, it is computed from `config`."""
+ if config_mask is None:
+ config_mask = get_config_mask(config)
+ write_uint32_le(w, config_mask)
+ write_bytes_unchecked(w, blockhash)
+ write_uint8(w, len(instructions))
+ write_uint8(w, len(accounts))
+
+ for account in accounts:
+ write_bytes_unchecked(w, account)
+
+ for (_, write_value), value in zip(CONFIG_FIELDS, config):
+ if value is not None:
+ write_value(w, value)
+
+ for program_index, account_indexes, data in instructions:
+ write_uint8(w, program_index)
+ write_uint8(w, len(account_indexes))
+ write_uint16_le(w, len(data))
+ for _, account_indexes, data in instructions:
+ write_bytes_unchecked(w, bytes(account_indexes))
+ write_bytes_unchecked(w, data)
+
+
def build_tx(
header: Header,
accounts: Sequence[AnyBytes],
instructions: Sequence[RawInstruction] = (),
blockhash: AnyBytes = BLOCKHASH,
version: int | None = None,
alts: Sequence[Alt] = (),
+ config: TxConfig = NO_CONFIG,
+ config_mask: int | None = None,
) -> bytes:
w = bytearray()
if version is not None:
write_uint8(w, 0x80 | version)
write_tx_header(w, *header)
- write_compact_array(w, accounts, write_bytes_unchecked)
- write_bytes_unchecked(w, blockhash)
- write_compact_array(w, instructions, write_instruction)
- if version is not None:
- write_compact_array(w, alts, write_alt)
+ if version == 1:
+ write_tx_body_v1(w, accounts, instructions, blockhash, config, config_mask)
+ else:
+ write_tx_body_legacy_v0(w, accounts, instructions, blockhash, version, alts)
return bytes(w)
SYSTEM_PROGRAM = bytes(32) # base58 "11111111111111111111111111111111"
+COMPUTE_BUDGET_PROGRAM = base58.decode("ComputeBudget111111111111111111111111111111")
SIGNER = b"s" * 32
RECIPIENT = b"r" * 32
TRANSFER_ACCOUNTS = (SIGNER, RECIPIENT, SYSTEM_PROGRAM)
@@ -184,14 +262,20 @@ def test_valid(self):
),
),
)
- for header, expected_types in vectors:
- transaction = Transaction(
- build_tx(header, TRANSFER_ACCOUNTS, [TRANSFER_INSTRUCTION])
- )
- self.assertEqual(
- [address[1] for address in transaction.addresses],
- list(expected_types),
- )
+ for version in (None, 0, 1):
+ for header, expected_types in vectors:
+ transaction = Transaction(
+ build_tx(
+ header,
+ TRANSFER_ACCOUNTS,
+ [TRANSFER_INSTRUCTION],
+ version=version,
+ )
+ )
+ self.assertEqual(
+ [address[1] for address in transaction.addresses],
+ list(expected_types),
+ )
def test_invalid(self):
# Headers rejected by Message::sanitize(), see:
@@ -202,9 +286,25 @@ def test_invalid(self):
(0, 0, 1), # no signers at all
(2, 0, 2), # signing and read-only non-signing areas overlap
)
- for header in vectors:
- with self.assertRaises(DataError):
- Transaction(build_tx(header, TRANSFER_ACCOUNTS, [TRANSFER_INSTRUCTION]))
+ for version in (None, 0, 1):
+ for header in vectors:
+ with self.assertRaises(DataError):
+ Transaction(
+ build_tx(
+ header,
+ TRANSFER_ACCOUNTS,
+ [TRANSFER_INSTRUCTION],
+ version=version,
+ )
+ )
+
+ def test_unsupported_version(self):
+ # A valid v0 transaction, so that nothing but the version is wrong.
+ v0_tx = build_tx(
+ (1, 0, 1), TRANSFER_ACCOUNTS, [TRANSFER_INSTRUCTION], version=0
+ )
+ with self.assertRaises(DataError):
+ Transaction(b"\x82" + v0_tx[1:])
@unittest.skipUnless(not utils.BITCOIN_ONLY, "altcoin")
@@ -251,7 +351,7 @@ def test_data_shorter_than_instruction_id(self):
@unittest.skipUnless(not utils.BITCOIN_ONLY, "altcoin")
class TestSolanaTransactionAlts(unittest.TestCase):
def test_without_alts(self):
- for version in (None, 0):
+ for version in (None, 0, 1):
transaction = Transaction(
build_tx(
(1, 0, 1),
@@ -268,7 +368,7 @@ def test_unexpected_alts(self):
# Only v0 transactions end with an ALT list.
alts = bytearray()
write_compact_array(alts, [(b"t" * 32, (5,), (7,))], write_alt)
- for version in (None,):
+ for version in (None, 1):
serialized_tx = build_tx(
(1, 0, 1),
TRANSFER_ACCOUNTS,
@@ -310,5 +410,114 @@ def test_v0_missing_alts(self):
Transaction(b"\x80" + legacy_tx)
+def raw_instructions(transaction: Transaction) -> list[tuple]:
+ # Instruction data are memoryviews, which can't be compared directly.
+ return [
+ (program_index, accounts, bytes(data))
+ for program_index, accounts, data in transaction.raw_instructions
+ ]
+
+
+@unittest.skipUnless(not utils.BITCOIN_ONLY, "altcoin")
+class TestSolanaTransactionV1(unittest.TestCase):
+ def test_known_answer(self):
+ # The serialized transaction from solana-sdk's
+ # byte_layout_with_config() test, prefixed with the version:
+ # https://github.com/anza-xyz/solana-sdk/blob/891412dceb0a7d3d4116ac295eef519882138090/message/src/versions/v1/message.rs#L1155-L1193
+ serialized_tx = (
+ b"\x81"
+ + bytes((1, 0, 0)) # header
+ + (0b111).to_bytes(4, "little") # config mask
+ + b"\xbb" * 32 # blockhash
+ + bytes((1, 2)) # number of instructions and addresses
+ + b"\x01" * 32
+ + b"\x02" * 32
+ + (0x0102030405060708).to_bytes(8, "little") # priority fee
+ + (0x11223344).to_bytes(4, "little") # compute unit limit
+ + bytes((1, 0))
+ + (0).to_bytes(2, "little") # instruction header
+ )
+ transaction = Transaction(serialized_tx)
+
+ self.assertEqual(transaction.version, 1)
+ self.assertEqual(transaction.blockhash, b"\xbb" * 32)
+ self.assertEqual(
+ [address for address, _ in transaction.addresses],
+ [b"\x01" * 32, b"\x02" * 32],
+ )
+ self.assertEqual(raw_instructions(transaction), [(1, [], b"")])
+ fee = transaction.calculate_fee()
+ assert fee is not None
+ self.assertEqual(fee.priority, 0x0102030405060708)
+
+ def test_same_as_legacy(self):
+ instructions = (
+ TRANSFER_INSTRUCTION,
+ (2, (1, 0, 1), b"\xff" * 300),
+ )
+ legacy = Transaction(build_tx((1, 0, 1), TRANSFER_ACCOUNTS, instructions))
+ v1 = Transaction(
+ build_tx(
+ (1, 0, 1),
+ TRANSFER_ACCOUNTS,
+ instructions,
+ version=1,
+ config=(12_345, 200_000, 64 * 1024, 64 * 1024),
+ )
+ )
+
+ self.assertEqual(v1.version, 1)
+ self.assertEqual(v1.addresses, legacy.addresses)
+ self.assertEqual(v1.blockhash, legacy.blockhash)
+ self.assertEqual(raw_instructions(v1), raw_instructions(legacy))
+
+ def test_invalid_config(self):
+ vectors = (
+ # mask, config
+ (0b10_0000, NO_CONFIG), # unknown bit
+ # Only one of the two priority fee bits set.
+ (0b01, (777, None, None, None)),
+ (0b10, (777, None, None, None)),
+ )
+ for mask, config in vectors:
+ with self.assertRaises(DataError):
+ Transaction(
+ build_tx(
+ (1, 0, 1),
+ TRANSFER_ACCOUNTS,
+ [TRANSFER_INSTRUCTION],
+ version=1,
+ config=config,
+ config_mask=mask,
+ )
+ )
+
+ def test_fee(self):
+ header = (1, 0, 2)
+ accounts = (SIGNER, RECIPIENT, SYSTEM_PROGRAM, COMPUTE_BUDGET_PROGRAM)
+ instructions = (
+ # Set Compute Unit Limit
+ (3, (), b"\x02" + (300_000).to_bytes(4, "little")),
+ # Set Compute Unit Price (microlamports)
+ (3, (), b"\x03" + (2_000_000).to_bytes(8, "little")),
+ TRANSFER_INSTRUCTION,
+ )
+ legacy_fee = Transaction(
+ build_tx(header, accounts, instructions)
+ ).calculate_fee()
+ assert legacy_fee is not None
+ self.assertEqual(legacy_fee.base, SOLANA_BASE_FEE_LAMPORTS)
+ self.assertEqual(legacy_fee.priority, 600_000) # limit * price in lamports
+
+ # v1 ignores ComputeBudget instructions, the fee comes from the config.
+ for config, priority_fee in ((NO_CONFIG, 0), ((777, None, None, None), 777)):
+ fee = Transaction(
+ build_tx(header, accounts, instructions, version=1, config=config)
+ ).calculate_fee()
+ assert fee is not None
+ self.assertEqual(fee.base, SOLANA_BASE_FEE_LAMPORTS)
+ self.assertEqual(fee.priority, priority_fee)
+
+
if __name__ == "__main__":
unittest.main()Why this scored 12/100
Community notes
Notes can correct, qualify, or add evidence to the AI analysis. Every note shown here has been validated by a human moderator.
The AI analysis stands alone for now. Submit a note if you can add evidence or important context.