Skip to main content

Try it Live

Run AccessList examples in the interactive playground

​
Constructors

Methods for creating AccessList instances.

​
AccessList.create()

Create empty access list. 
AccessList.create(): BrandedAccessList
Returns: Empty access list Example: 
const list = AccessList.create();
// list = []
Use Cases:
  • Starting point for incremental building
  • Default/empty state
  • Conditional list building

​
AccessList()

Canonical constructor accepting items array or RLP bytes. 
AccessList(value: readonly Item[] | Uint8Array): BrandedAccessList
Parameters:
  • value: Item array or RLP-encoded bytes
Returns: BrandedAccessList Example: 
// From items
const list = AccessList([
  { address: addr1, storageKeys: [key1] },
  { address: addr2, storageKeys: [] }
]);

// From RLP bytes
const list2 = AccessList(bytes);
Notes:
  • Delegates to fromBytes for Uint8Array input
  • No validation - use assertValid if needed

​
Alias: AccessList.from()

AccessList.from() is an alias for AccessList() for backward compatibility. Use AccessList() directly in new code.

​
AccessList.fromBytes()

Decode RLP bytes to access list. 
AccessList(bytes: Uint8Array): BrandedAccessList
Parameters:
  • bytes: RLP-encoded access list
Returns: Decoded BrandedAccessList Throws:
  • Error if invalid RLP structure
  • Error if addresses not 20 bytes
  • Error if storage keys not 32 bytes
Example: 
const bytes = Hex('0xc0'); // RLP-encoded empty list
const list = AccessList(Hex.toBytes(bytes));
RLP Structure: 
[
  [address1, [key1, key2, ...]],
  [address2, [key3, key4, ...]],
  ...
]
Validation:
  • Top level must be RLP list
  • Each item must be [address, keys] pair
  • Address must be 20 bytes
  • Keys must be list of 32-byte hashes

​
Patterns

​
Empty List

let list = AccessList.create();

​
From Transaction Data

// Decode from RLP
const list = AccessList(tx.accessListBytes);

​
From Items Array

const items = [
  { address: router, storageKeys: [] },
  { address: token, storageKeys: [balanceSlot] }
];
const list = AccessList(items);

​
Incremental Building

// Start empty
let list = AccessList.create();

// Add addresses
list = list.withAddress(addr1);
list = list.withAddress(addr2);

// Add keys
list = list.withStorageKey(addr1, key1);
list = list.withStorageKey(addr1, key2);

​
Safe Construction

function safeFromBytes(bytes: Uint8Array): BrandedAccessList | null {
  try {
    const list = AccessList(bytes);
    AccessList.assertValid(list);
    return list;
  } catch {
    return null;
  }
}

​
Clone List

// Lists are readonly, so this creates independent copy
const clone = AccessList(original);

​
Best Practices

  1. Use create() for incremental building 
    // Good
let list = AccessList.create();
list = list.withAddress(addr);

// Avoid
let list = AccessList([]);
  2. Validate untrusted bytes 
    try {
  const list = AccessList(userBytes);
  AccessList.assertValid(list);
} catch (err) {
  // Handle invalid data
}
  3. Use factory for literal values 
    const list = AccessList([
  { address: addr, storageKeys: [key] }
]);
  4. Deduplicate after construction 
    const list = AccessList(items);
const deduped = list.deduplicate();

​
Error Handling

​
fromBytes Errors

try {
  const list = AccessList(bytes);
} catch (err) {
  if (err.message.includes('expected list')) {
    // Invalid RLP structure
  } else if (err.message.includes('address')) {
    // Invalid address length
  } else if (err.message.includes('storage key')) {
    // Invalid key length
  }
}

​
Validation After Construction

const list = AccessList(externalData);

// Validate
try {
  AccessList.assertValid(list);
} catch (err) {
  console.error('Invalid access list:', err);
}