Rlp.encode

type Encodable =
  | Uint8Array
  | BrandedRlp
  | Array<Uint8Array | BrandedRlp | any>

const bytes = new Uint8Array([1, 2, 3])
const encoded = Rlp.encode(bytes)
// => Uint8Array([0x83, 1, 2, 3])

const data = Rlp(new Uint8Array([1, 2, 3]))
const encoded = Rlp.encode(data)

const list = [new Uint8Array([1]), new Uint8Array([2])]
const encoded = Rlp.encode(list)
// => Uint8Array([0xc4, 0x01, 0x02])

const nested = [
  new Uint8Array([1]),
  [
    new Uint8Array([2]),
    [new Uint8Array([3])]
  ]
]
const encoded = Rlp.encode(nested)

import { Rlp } from 'tevm'

// Legacy transaction: [nonce, gasPrice, gas, to, value, data, v, r, s]
const txData = [
  new Uint8Array([0x00]),                    // nonce
  new Uint8Array([0x04, 0xa8, 0x17, 0xc8]),  // gasPrice: 78000000
  new Uint8Array([0x52, 0x08]),               // gas: 21000
  new Uint8Array(20).fill(0x01),              // to (address)
  new Uint8Array([0x00]),                    // value: 0
  Bytes(),                         // data: empty
  new Uint8Array([0x1b]),                    // v: 27
  Bytes32().fill(0x02),              // r: signature r
  Bytes32().fill(0x03)               // s: signature s
]

const encoded = Rlp.encode(txData)
// Ready for broadcast or signature verification

import { Rlp } from 'tevm'

// Simplified block header
const header = [
  Bytes32().fill(0x01),  // parentHash
  Bytes32().fill(0x02),  // uncleHash
  new Uint8Array(20).fill(0x03),  // coinbase (miner address)
  Bytes32().fill(0x04),  // stateRoot
  Bytes32().fill(0x05),  // transactionsRoot
  Bytes32().fill(0x06),  // receiptsRoot
  new Uint8Array(256).fill(0x00), // logsBloom
  new Uint8Array([0x01]),         // difficulty
  new Uint8Array([0x01]),         // number
  new Uint8Array([0x5f, 0x5e, 0x100]), // gasLimit
  new Uint8Array([0x00]),         // gasUsed
  Bytes4(),              // timestamp
  Bytes()              // extraData
]

const encoded = Rlp.encode(header)
// Use for block hash calculation
const blockHash = keccak256(encoded)

import { Rlp } from 'tevm'

interface StorageProof {
  key: Uint8Array
  value: Uint8Array
  proof: Uint8Array[]
}

function encodeStorageProof(proof: StorageProof): Uint8Array {
  return Rlp.encode([
    proof.key,
    proof.value,
    proof.proof  // Nested list of proof nodes
  ])
}

const proof: StorageProof = {
  key: new Uint8Array([0x01, 0x02]),
  value: new Uint8Array([0x03, 0x04]),
  proof: [
    Bytes32().fill(0x05),
    Bytes32().fill(0x06)
  ]
}

const encoded = encodeStorageProof(proof)

const byte = new Uint8Array([0x7f])
const encoded = Rlp.encode(byte)
// => Uint8Array([0x7f])  (no prefix)

// Empty bytes
const empty = Bytes()
const encoded = Rlp.encode(empty)
// => Uint8Array([0x80])

// 3 bytes
const bytes = new Uint8Array([1, 2, 3])
const encoded = Rlp.encode(bytes)
// => Uint8Array([0x83, 1, 2, 3])
// 0x83 = 0x80 + 3

// 56 bytes (minimum for long form)
const long = new Uint8Array(56).fill(0x42)
const encoded = Rlp.encode(long)
// => Uint8Array([0xb8, 56, ...long])
// 0xb8 = 0xb7 + 1 (length needs 1 byte)

// 256 bytes (length needs 2 bytes)
const longer = new Uint8Array(256).fill(0x42)
const encoded = Rlp.encode(longer)
// => Uint8Array([0xb9, 0x01, 0x00, ...longer])
// 0xb9 = 0xb7 + 2 (length needs 2 bytes)
// [0x01, 0x00] = 256 in big-endian

// Empty list
const empty = []
const encoded = Rlp.encode(empty)
// => Uint8Array([0xc0])

// List with 2 single bytes
const list = [new Uint8Array([0x01]), new Uint8Array([0x02])]
const encoded = Rlp.encode(list)
// => Uint8Array([0xc2, 0x01, 0x02])
// 0xc2 = 0xc0 + 2

// Create list with 60 bytes total payload
const items = Array({ length: 30 }, () => new Uint8Array([0x01, 0x02]))
const encoded = Rlp.encode(items)
// First bytes: [0xf8, 60, ...]
// 0xf8 = 0xf7 + 1 (length needs 1 byte)

// These are equivalent
const manual = Rlp.encodeList([
  Rlp.encodeBytes(new Uint8Array([1])),
  Rlp.encodeBytes(new Uint8Array([2]))
])

const automatic = Rlp.encode([
  new Uint8Array([1]),
  new Uint8Array([2])
])

import { Rlp } from 'tevm'

const items = [
  new Uint8Array([1, 2, 3]),
  new Uint8Array([4, 5, 6])
]

// Calculate size without encoding
const size = Rlp.getEncodedLength(items)
console.log(`Will need ${size} bytes`)

// Then encode
const encoded = Rlp.encode(items)

import { encodeBytes, encodeList } from 'tevm/BrandedRlp'

// More efficient than generic encode()
const bytesEncoded = encodeBytes(new Uint8Array([1, 2, 3]))
const listEncoded = encodeList([bytes1, bytes2])

const data = new Uint8Array([1, 2, 3])
const encoded = Rlp.encode(data)

// Reuse cached result
for (let i = 0; i < 1000; i++) {
  processEncoded(encoded)  // No re-encoding
}