@btc-vision/btc-runtime 1.10.11 → 1.11.0-alpha

package/docs/examples/nft-with-reservations.md

@@ -906,249 +906,19 @@ public reserve(calldata: Calldata): BytesWriter { }
 public getSaleInfo(_calldata: Calldata): BytesWriter { }
 ```
 
-## Solidity Equivalent
-
-For developers familiar with Solidity, here is an equivalent ERC721 implementation with reservations and reveal mechanics:
-
-```solidity
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.20;
-
-import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
-import "@openzeppelin/contracts/access/Ownable.sol";
-import "@openzeppelin/contracts/utils/Strings.sol";
-
-contract NFTWithReservations is ERC721, Ownable {
-    using Strings for uint256;
-
-    enum SalePhase { INACTIVE, WHITELIST, PUBLIC }
-
-    // Configuration
-    uint256 public maxSupply;
-    uint256 public price;
-    uint256 public maxPerWallet;
-    string private baseURI_;
-    string private hiddenURI;
-    bool public revealed;
-    SalePhase public salePhase;
-    uint256 private nextTokenId = 1;
-
-    // Reservation system
-    uint256 public reservationEnd;
-    mapping(address => uint256) public reservations;
-
-    // Whitelist
-    mapping(address => bool) public whitelist;
-    mapping(address => uint256) public mintedCount;
-
-    event Reserved(address indexed user, uint256 quantity);
-    event ReservationClaimed(address indexed user, uint256 quantity);
-    event ReservationCancelled(address indexed user, uint256 quantity);
-
-    constructor(
-        string memory name,
-        string memory symbol,
-        uint256 _maxSupply,
-        uint256 _price,
-        uint256 _maxPerWallet,
-        string memory _hiddenURI
-    ) ERC721(name, symbol) Ownable(msg.sender) {
-        maxSupply = _maxSupply;
-        price = _price;
-        maxPerWallet = _maxPerWallet;
-        hiddenURI = _hiddenURI;
-    }
-
-    // ============ RESERVATION SYSTEM ============
-
-    function reserve(uint256 quantity) external payable {
-        require(block.timestamp < reservationEnd, "Reservation period ended");
-        require(reservations[msg.sender] + quantity <= maxPerWallet, "Exceeds max per wallet");
-        require(msg.value >= price * quantity, "Insufficient payment");
-
-        reservations[msg.sender] += quantity;
-        emit Reserved(msg.sender, quantity);
-    }
-
-    function claimReserved() external {
-        require(block.timestamp >= reservationEnd, "Reservation period not ended");
-        uint256 quantity = reservations[msg.sender];
-        require(quantity > 0, "No reservations");
-
-        reservations[msg.sender] = 0;
-
-        for (uint256 i = 0; i < quantity; i++) {
-            _safeMint(msg.sender, nextTokenId++);
-        }
-
-        emit ReservationClaimed(msg.sender, quantity);
-    }
-
-    function cancelReservation() external {
-        require(block.timestamp < reservationEnd, "Reservation period ended");
-        uint256 quantity = reservations[msg.sender];
-        require(quantity > 0, "No reservations");
-
-        reservations[msg.sender] = 0;
-
-        // Refund
-        uint256 refundAmount = price * quantity;
-        (bool success, ) = msg.sender.call{value: refundAmount}("");
-        require(success, "Refund failed");
-
-        emit ReservationCancelled(msg.sender, quantity);
-    }
-
-    // ============ MINTING ============
-
-    function whitelistMint(uint256 quantity) external payable {
-        require(salePhase == SalePhase.WHITELIST, "Whitelist sale not active");
-        require(whitelist[msg.sender], "Not whitelisted");
-        require(msg.value >= price * quantity, "Insufficient payment");
-
-        _mintInternal(msg.sender, quantity);
-    }
-
-    function publicMint(uint256 quantity) external payable {
-        require(salePhase == SalePhase.PUBLIC, "Public sale not active");
-        require(msg.value >= price * quantity, "Insufficient payment");
-
-        _mintInternal(msg.sender, quantity);
-    }
-
-    function _mintInternal(address to, uint256 quantity) internal {
-        require(nextTokenId + quantity - 1 <= maxSupply, "Exceeds max supply");
-        require(mintedCount[to] + quantity <= maxPerWallet, "Exceeds max per wallet");
-
-        mintedCount[to] += quantity;
-
-        for (uint256 i = 0; i < quantity; i++) {
-            _safeMint(to, nextTokenId++);
-        }
-    }
-
-    // ============ REVEAL ============
-
-    function tokenURI(uint256 tokenId) public view override returns (string memory) {
-        require(_ownerOf(tokenId) != address(0), "Token does not exist");
-
-        if (!revealed) {
-            return hiddenURI;
-        }
-
-        return string(abi.encodePacked(baseURI_, tokenId.toString(), ".json"));
-    }
-
-    // ============ ADMIN FUNCTIONS ============
-
-    function startReservation(uint256 duration) external onlyOwner {
-        reservationEnd = block.timestamp + duration;
-    }
-
-    function setSalePhase(SalePhase phase) external onlyOwner {
-        salePhase = phase;
-    }
-
-    function setWhitelist(address[] calldata addresses, bool status) external onlyOwner {
-        for (uint256 i = 0; i < addresses.length; i++) {
-            whitelist[addresses[i]] = status;
-        }
-    }
-
-    function reveal(string calldata _baseURI) external onlyOwner {
-        baseURI_ = _baseURI;
-        revealed = true;
-    }
-
-    function setPrice(uint256 _price) external onlyOwner {
-        price = _price;
-    }
-
-    function withdraw() external onlyOwner {
-        (bool success, ) = owner().call{value: address(this).balance}("");
-        require(success, "Withdrawal failed");
-    }
-
-    // ============ VIEW FUNCTIONS ============
-
-    function totalSupply() public view returns (uint256) {
-        return nextTokenId - 1;
-    }
-
-    function getSaleInfo() external view returns (
-        SalePhase phase,
-        uint256 currentPrice,
-        uint256 maxSupply_,
-        uint256 totalSupply_,
-        bool isRevealed
-    ) {
-        return (salePhase, price, maxSupply, totalSupply(), revealed);
-    }
-}
-```
-
-## Solidity vs OPNet Comparison
-
-### Key Differences Table
+## Solidity Comparison
 
 | Aspect | Solidity (ERC721) | OPNet (OP721) |
 |--------|-------------------|---------------|
-| **Inheritance** | `contract NFT is ERC721, Ownable` | `class NFT extends OP721` |
-| **Constructor** | `constructor() ERC721("Name", "SYM")` | `onDeployment()` + `this.instantiate(...)` |
-| **Enum Definition** | `enum SalePhase { INACTIVE, WHITELIST }` | `const PHASE_INACTIVE: u8 = 0` |
-| **Mint** | `_safeMint(to, tokenId)` | `this._mint(to, tokenId)` |
-| **Token Counter** | `uint256 private nextTokenId` | `StoredU256` with pointer |
-| **Timestamp** | `block.timestamp` | `Blockchain.block.medianTime` |
-| **Whitelist Storage** | `mapping(address => bool)` | `AddressMemoryMap` |
-| **Payment Handling** | `msg.value`, `payable` | Bitcoin UTXO model |
-| **String Concat** | `string(abi.encodePacked(...))` | `baseURI + tokenId.toString() + '.json'` |
-
-### Reservation Pattern Comparison
-
-**Solidity:**
-```solidity
-mapping(address => uint256) public reservations;
-uint256 public reservationEnd;
-
-function reserve(uint256 quantity) external payable {
-    require(block.timestamp < reservationEnd, "Reservation period ended");
-    require(reservations[msg.sender] + quantity <= maxPerWallet, "Exceeds max per wallet");
-    require(msg.value >= price * quantity, "Insufficient payment");
-
-    reservations[msg.sender] += quantity;
-}
-```
-
-**OPNet:**
-```typescript
-private _reservedBy: AddressMemoryMap;
-private _reservationEnd: StoredU256;
+| Inheritance | `contract NFT is ERC721, Ownable` | `class NFT extends OP721` |
+| Constructor | `constructor() ERC721("Name", "SYM")` | `onDeployment()` + `this.instantiate(...)` |
+| Mint | `_safeMint(to, tokenId)` | `this._mint(to, tokenId)` |
+| Timestamp | `block.timestamp` | `Blockchain.block.medianTime` |
+| Whitelist Storage | `mapping(address => bool)` | `AddressMemoryMap` |
 
-@method({ name: 'quantity', type: ABIDataTypes.UINT256 })
-@returns({ name: 'success', type: ABIDataTypes.BOOL })
-@emit('Reserved')
-public reserve(calldata: Calldata): BytesWriter {
-    const quantity = calldata.readU256();
-    const sender = Blockchain.tx.sender;
-
-    const now = u256.fromU64(Blockchain.block.medianTime);
-    if (now >= this._reservationEnd.value) {
-        throw new Revert('Reservation period ended');
-    }
-
-    const currentReserved = this._reservedBy.get(sender);
-    const newTotal = SafeMath.add(currentReserved, quantity);
-
-    if (newTotal > this._maxPerWallet.value) {
-        throw new Revert('Exceeds max per wallet');
-    }
-
-    this._reservedBy.set(sender, newTotal);
-    return new BytesWriter(0);
-}
-```
+For detailed OP721 API documentation, see [OP721 Contract](../contracts/op721-nft.md).
 
-### Whitelist Verification Comparison
+### Whitelist Implementation Comparison
 
 **Solidity (Using Merkle Proofs):**
 ```solidity

package/docs/storage/memory-maps.md

@@ -202,50 +202,7 @@ flowchart LR
 | `transfer(to, amount)` | `balances[msg.sender] -= amount; balances[to] += amount;` | `this.balances.set(sender, SafeMath.sub(...)); this.balances.set(to, SafeMath.add(...));` |
 | `approve(spender, amount)` | `allowances[msg.sender][spender] = amount;` | Use `MapOfMap<u256>` for nested mapping |
 
-### Full Comparison Example
-
-```solidity
-// Solidity
-contract Token {
-    mapping(address => uint256) public balances;
-
-    function transfer(address to, uint256 amount) external {
-        require(balances[msg.sender] >= amount, "Insufficient");
-        balances[msg.sender] -= amount;
-        balances[to] += amount;
-    }
-}
-```
-
-```typescript
-// OPNet
-@final
-export class Token extends OP_NET {
-    private balancesPointer: u16 = Blockchain.nextPointer;
-    private balances: AddressMemoryMap;
-
-    constructor() {
-        super();
-        this.balances = new AddressMemoryMap(this.balancesPointer);
-    }
-
-    public transfer(calldata: Calldata): BytesWriter {
-        const to = calldata.readAddress();
-        const amount = calldata.readU256();
-        const sender = Blockchain.tx.sender;
-
-        const senderBalance = this.balances.get(sender);
-        if (senderBalance < amount) {
-            throw new Revert('Insufficient balance');
-        }
-
-        this.balances.set(sender, SafeMath.sub(senderBalance, amount));
-        this.balances.set(to, SafeMath.add(this.balances.get(to), amount));
-
-        return new BytesWriter(0);
-    }
-}
-```
+For a complete token implementation using AddressMemoryMap, see [Basic Token Example](../examples/basic-token.md).
 
 ## Side-by-Side Code Examples
 

package/docs/storage/stored-arrays.md

@@ -238,71 +238,7 @@ if (this.holders.getLength() === 0) {
 | Get last element | `arr[arr.length - 1]` | `arr.get(arr.getLength() - 1)` |
 | Initialize with values | `arr = [1, 2, 3];` | Multiple `arr.push()` calls in `onDeployment`, then `arr.save()` |
 
-### Full Example Comparison
-
-```solidity
-// Solidity
-contract Registry {
-    address[] public members;
-
-    function addMember(address member) external {
-        members.push(member);
-    }
-
-    function removeMember(uint256 index) external {
-        members[index] = members[members.length - 1];
-        members.pop();
-    }
-
-    function getMemberCount() external view returns (uint256) {
-        return members.length;
-    }
-}
-```
-
-```typescript
-// OPNet
-@final
-export class Registry extends OP_NET {
-    private membersPointer: u16 = Blockchain.nextPointer;
-    private members: StoredAddressArray;
-
-    constructor() {
-        super();
-        this.members = new StoredAddressArray(this.membersPointer, EMPTY_POINTER);
-    }
-
-    public addMember(calldata: Calldata): BytesWriter {
-        const member = calldata.readAddress();
-        this.members.push(member);
-        this.members.save();
-        return new BytesWriter(0);
-    }
-
-    public removeMember(calldata: Calldata): BytesWriter {
-        const index = calldata.readU32();
-        const length = this.members.getLength();
-
-        if (index >= length) {
-            throw new Revert('Index out of bounds');
-        }
-
-        if (index < length - 1) {
-            this.members.set(index, this.members.get(length - 1));
-        }
-        this.members.deleteLast();
-        this.members.save();
-
-        return new BytesWriter(0);
-    }
-
-    public getMemberCount(_calldata: Calldata): BytesWriter {
-        const writer = new BytesWriter(4);
-        writer.writeU32(this.members.getLength());
-        return writer;
-    }
-}
-```
+For complete contract examples using stored arrays, see the [Examples](../examples/) section.
 
 ## Side-by-Side Code Examples
 

package/docs/storage/stored-maps.md

@@ -312,79 +312,7 @@ flowchart LR
 | Token metadata | `mapping(uint256 => string)` | `StoredMapU256` with encoded strings |
 | Checkpoints | `mapping(address => mapping(uint256 => uint256))` | `MapOfMap<u256>` or composite keys |
 
-### Full Example Comparison
-
-```solidity
-// Solidity
-contract Token {
-    mapping(address => uint256) public balances;
-    mapping(address => mapping(address => uint256)) public allowances;
-
-    function transfer(address to, uint256 amount) external {
-        require(balances[msg.sender] >= amount);
-        balances[msg.sender] -= amount;
-        balances[to] += amount;
-    }
-
-    function approve(address spender, uint256 amount) external {
-        allowances[msg.sender][spender] = amount;
-    }
-}
-```
-
-```typescript
-// OPNet
-@final
-export class Token extends OP_NET {
-    private balancesPointer: u16 = Blockchain.nextPointer;
-    private allowancesPointer: u16 = Blockchain.nextPointer;
-
-    private balances: StoredMapU256;
-    private allowances: MapOfMap<u256>;
-
-    constructor() {
-        super();
-        this.balances = new StoredMapU256(this.balancesPointer);
-        this.allowances = new MapOfMap<u256>(this.allowancesPointer);
-    }
-
-    private addressKey(addr: Address): u256 {
-        return u256.fromBytes(addr.toBytes());
-    }
-
-    public transfer(calldata: Calldata): BytesWriter {
-        const to = calldata.readAddress();
-        const amount = calldata.readU256();
-        const sender = Blockchain.tx.sender;
-
-        const senderKey = this.addressKey(sender);
-        const toKey = this.addressKey(to);
-
-        const senderBalance = this.balances.get(senderKey);
-        if (senderBalance < amount) {
-            throw new Revert('Insufficient balance');
-        }
-
-        this.balances.set(senderKey, SafeMath.sub(senderBalance, amount));
-        this.balances.set(toKey, SafeMath.add(this.balances.get(toKey), amount));
-
-        return new BytesWriter(0);
-    }
-
-    public approve(calldata: Calldata): BytesWriter {
-        const spender = calldata.readAddress();
-        const amount = calldata.readU256();
-        const sender = Blockchain.tx.sender;
-
-        // Correct two-step MapOfMap pattern
-        const senderMap = this.allowances.get(sender);
-        senderMap.set(spender, amount);
-        this.allowances.set(sender, senderMap);
-
-        return new BytesWriter(0);
-    }
-}
-```
+For a complete token implementation using these map types, see [Basic Token Example](../examples/basic-token.md).
 
 ## Side-by-Side Code Examples
 

package/docs/storage/stored-primitives.md

@@ -102,14 +102,7 @@ classDiagram
 
 ## Storage Key Generation
 
-Each stored primitive computes its storage key by combining the pointer and subPointer:
-
-```mermaid
-flowchart LR
-    A["pointer: u16<br/>subPointer: u256"] --> B["32-byte buffer<br/>[0-1] = pointer<br/>[2-31] = subPointer"]
-    B --> C["SHA256"]
-    C --> D["Storage Key<br/>(32 bytes)"]
-```
+Each stored primitive computes its storage key using `SHA256(pointer || subPointer)`. See [Pointers](../core-concepts/pointers.md#encodepointer-function-flow) for the detailed flow diagram.
 
 ## Usage
 
@@ -323,47 +316,7 @@ public override onDeployment(calldata: Calldata): void {
 | `bool public paused = false;` | `private pausedPtr: u16 = Blockchain.nextPointer;`<br>`private _paused: StoredBoolean = new StoredBoolean(this.pausedPtr, false);` |
 | `address public owner;` | `private ownerPtr: u16 = Blockchain.nextPointer;`<br>`private _owner: StoredAddress = new StoredAddress(this.ownerPtr);` |
 
-### Full Example Comparison
-
-```solidity
-// Solidity
-contract Token {
-    string public name;       // slot 0
-    uint256 public supply;    // slot 1
-    bool public paused;       // slot 2 (packed)
-
-    constructor(string memory _name, uint256 _supply) {
-        name = _name;
-        supply = _supply;
-    }
-}
-```
-
-```typescript
-// OPNet
-@final
-export class Token extends OP_NET {
-    private namePointer: u16 = Blockchain.nextPointer;
-    private supplyPointer: u16 = Blockchain.nextPointer;
-    private pausedPointer: u16 = Blockchain.nextPointer;
-
-    private _name: StoredString = new StoredString(this.namePointer, 0);
-    private _supply: StoredU256 = new StoredU256(this.supplyPointer, EMPTY_POINTER);
-    private _paused: StoredBoolean = new StoredBoolean(this.pausedPointer, false);
-
-    public override onDeployment(calldata: Calldata): void {
-        this._name.value = calldata.readString();
-        this._supply.value = calldata.readU256();
-    }
-
-    // Manual getter
-    public name(_calldata: Calldata): BytesWriter {
-        const writer = new BytesWriter(256);
-        writer.writeString(this._name.value);
-        return writer;
-    }
-}
-```
+For complete token examples using stored primitives, see [Basic Token Example](../examples/basic-token.md).
 
 ## Side-by-Side Code Examples
 

package/docs/types/bytes-writer-reader.md

@@ -31,6 +31,7 @@ classDiagram
         -Uint8Array typedArray
         -u32 currentOffset
         +BytesWriter(length)
+        +write~T~(value) void
         +writeU8(value)
         +writeU16(value, be)
         +writeU32(value, be)
@@ -38,9 +39,13 @@ classDiagram
         +writeU128(value, be)
         +writeU256(value, be)
         +writeAddress(addr)
+        +writeExtendedAddress(extAddr)
+        +writeSchnorrSignature(addr, sig)
         +writeString(str)
         +writeBytes(data)
         +writeBoolean(bool)
+        +writeExtendedAddressArray(arr)
+        +writeExtendedAddressMapU256(map)
         +getBuffer() Uint8Array
     }
 
@@ -48,6 +53,7 @@ classDiagram
         -DataView buffer
         -i32 currentOffset
         +BytesReader(bytes)
+        +read~T~() T
         +readU8() u8
         +readU16(be) u16
         +readU32(be) u32
@@ -55,9 +61,13 @@ classDiagram
         +readU128(be) u128
         +readU256(be) u256
         +readAddress() Address
+        +readExtendedAddress() ExtendedAddress
+        +readSchnorrSignature() SchnorrSignature
         +readString() string
         +readBytes(length) Uint8Array
         +readBoolean() bool
+        +readExtendedAddressArray() ExtendedAddress[]
+        +readExtendedAddressMapU256() ExtendedAddressMap
         +hasMoreData() bool
     }
 
@@ -113,6 +123,12 @@ writer.writeI64(value);
 // Address (32 bytes)
 writer.writeAddress(address);
 
+// ExtendedAddress (64 bytes: 32 tweaked key + 32 ML-DSA key hash)
+writer.writeExtendedAddress(extendedAddress);
+
+// Schnorr signature with signer address (128 bytes total)
+writer.writeSchnorrSignature(signerAddress, signature);
+
 // String without length prefix
 writer.writeString('Hello, World!');
 
@@ -129,6 +145,25 @@ writer.writeBytesWithLength(data);
 writer.writeSelector(selector);
 ```
 
+### Generic Write Method
+
+The `write<T>()` method automatically selects the correct write method based on the type:
+
+```typescript
+// Automatically dispatches to the correct write method
+writer.write<u64>(12345);                    // writeU64
+writer.write<u256>(amount);                  // writeU256
+writer.write<bool>(true);                    // writeBoolean
+writer.write<Address>(addr);                 // writeAddress
+writer.write<ExtendedAddress>(extAddr);      // writeExtendedAddress
+writer.write<string>('hello');               // writeStringWithLength
+
+// Supported types:
+// - Primitives: bool, u8, u16, u32, u64, i8, i16, i32, i64
+// - Big numbers: u128, u256, i128
+// - Complex: Address, ExtendedAddress, Selector, string, Uint8Array
+```
+
 ### Writing Arrays
 
 All array methods use a u16 length prefix (max 65535 elements):
@@ -137,6 +172,9 @@ All array methods use a u16 length prefix (max 65535 elements):
 // Address array (u16 length prefix + addresses)
 writer.writeAddressArray(addresses);
 
+// ExtendedAddress array (u16 length prefix + 64-byte addresses)
+writer.writeExtendedAddressArray(extendedAddresses);
+
 // Numeric arrays (u16 length prefix + values)
 writer.writeU8Array(u8Values);
 writer.writeU16Array(u16Values);
@@ -150,6 +188,9 @@ writer.writeArrayOfBuffer(buffers);
 
 // AddressMap<u256> (u16 count, then address + u256 pairs)
 writer.writeAddressMapU256(addressMap);
+
+// ExtendedAddressMap<u256> (u16 count, then 64-byte address + u256 pairs)
+writer.writeExtendedAddressMapU256(extendedAddressMap);
 ```
 
 ### Getting Results
@@ -222,6 +263,14 @@ const i64val: i64 = reader.readI64();
 // Address (32 bytes)
 const addr: Address = reader.readAddress();
 
+// ExtendedAddress (64 bytes: 32 tweaked key + 32 ML-DSA key hash)
+const extAddr: ExtendedAddress = reader.readExtendedAddress();
+
+// Schnorr signature with signer address (128 bytes)
+const schnorrSig: SchnorrSignature = reader.readSchnorrSignature();
+const signer: ExtendedAddress = schnorrSig.address;
+const signature: Uint8Array = schnorrSig.signature;
+
 // String with known length (bytes read, zeroStop = true)
 const name: string = reader.readString(32);  // reads up to 32 bytes, stops at null
 
@@ -238,6 +287,25 @@ const data2: Uint8Array = reader.readBytesWithLength();
 const selector: Selector = reader.readSelector();
 ```
 
+### Generic Read Method
+
+The `read<T>()` method automatically selects the correct read method based on the type:
+
+```typescript
+// Automatically dispatches to the correct read method
+const num: u64 = reader.read<u64>();              // readU64
+const amount: u256 = reader.read<u256>();         // readU256
+const flag: bool = reader.read<bool>();           // readBoolean
+const addr: Address = reader.read<Address>();     // readAddress
+const extAddr: ExtendedAddress = reader.read<ExtendedAddress>();  // readExtendedAddress
+const text: string = reader.read<string>();       // readStringWithLength
+
+// Supported types:
+// - Primitives: bool, u8, u16, u32, u64, i8, i16, i32, i64
+// - Big numbers: u128, u256, i128
+// - Complex: Address, ExtendedAddress, Selector, string
+```
+
 ### Reading Arrays
 
 All array methods expect a u16 length prefix:
@@ -246,6 +314,9 @@ All array methods expect a u16 length prefix:
 // Address array
 const addresses: Address[] = reader.readAddressArray();
 
+// ExtendedAddress array (64 bytes each)
+const extAddresses: ExtendedAddress[] = reader.readExtendedAddressArray();
+
 // Numeric arrays
 const u8Values: u8[] = reader.readU8Array();
 const u16Values: u16[] = reader.readU16Array();
@@ -259,6 +330,9 @@ const buffers: Uint8Array[] = reader.readArrayOfBuffer();
 
 // AddressMap<u256>
 const addressMap: AddressMap<u256> = reader.readAddressMapU256();
+
+// ExtendedAddressMap<u256> (64-byte addresses as keys)
+const extAddressMap: ExtendedAddressMap<u256> = reader.readExtendedAddressMapU256();
 ```
 
 ### Position Management
@@ -291,6 +365,8 @@ reader.verifyEnd(offset + 32);  // Throws Revert if not enough bytes
 | `u128`/`i128` | 16 | Big-endian (default) |
 | `u256` | 32 | Big-endian (default) |
 | `Address` | 32 | Raw bytes |
+| `ExtendedAddress` | 64 | 32 bytes tweaked key + 32 bytes ML-DSA key hash |
+| `SchnorrSignature` | 128 | 64 bytes ExtendedAddress + 64 bytes signature |
 | `Selector` | 4 | Big-endian (u32) |
 | `string` | 4 + n | Length prefix (u32 BE) + UTF-8 |
 | `bytes` | 4 + n | Length prefix (u32 BE) + raw |