@0xsequence/catapult 1.3.16 → 1.4.0

package/src/lib/core/__tests__/resolver.spec.ts

@@ -1,7 +1,7 @@
 import { ethers } from 'ethers'
 import { ValueResolver } from '../resolver'
 import { ExecutionContext } from '../context'
-import { BasicArithmeticValue, Network, ReadBalanceValue, ComputeCreate2Value, ConstructorEncodeValue, AbiEncodeValue, AbiPackValue, CallValue, ContractExistsValue, ComputeCreateValue, SliceBytesValue } from '../../types'
+import { BasicArithmeticValue, Network, ReadBalanceValue, GetStorageAtValue, ComputeSlotValue, ComputeCreate2Value, ConstructorEncodeValue, AbiEncodeValue, AbiPackValue, CallValue, ContractExistsValue, ComputeCreateValue, SliceBytesValue } from '../../types'
 import { ContractRepository } from '../../contracts/repository'
 
 describe('ValueResolver', () => {
@@ -2050,4 +2050,447 @@ describe('ValueResolver', () => {
       expect(result).toBe('0x010203')
     })
   })
+
+  describe('get-storage-at', () => {
+    const testAddress = '0x1234567890123456789012345678901234567890'
+    const testSlot = '0x0000000000000000000000000000000000000000000000000000000000000000'
+    const testSlotNumber = 0
+    const expectedStorageValue = '0x0000000000000000000000000000000000000000000000000000000000000001'
+    let anvilProvider: ethers.JsonRpcProvider
+
+    beforeEach(async () => {
+      anvilProvider = context.provider as ethers.JsonRpcProvider
+    })
+
+    it('should read storage slot with hex string slot', async () => {
+      // Set storage at a specific slot using anvil_setStorageAt
+      await anvilProvider.send('anvil_setStorageAt', [testAddress, testSlot, expectedStorageValue])
+
+      const value: GetStorageAtValue = {
+        type: 'get-storage-at',
+        arguments: {
+          address: testAddress,
+          slot: testSlot
+        },
+      }
+      const result = await resolver.resolve(value, context)
+      expect(result).toBe(expectedStorageValue)
+    })
+
+    it('should read storage slot with numeric slot', async () => {
+      // Set storage at slot 0
+      await anvilProvider.send('anvil_setStorageAt', [testAddress, testSlot, expectedStorageValue])
+
+      const value: GetStorageAtValue = {
+        type: 'get-storage-at',
+        arguments: {
+          address: testAddress,
+          slot: testSlotNumber
+        },
+      }
+      const result = await resolver.resolve(value, context)
+      expect(result).toBe(expectedStorageValue)
+    })
+
+    it('should read storage slot with string number slot', async () => {
+      // Set storage at slot 0
+      await anvilProvider.send('anvil_setStorageAt', [testAddress, testSlot, expectedStorageValue])
+
+      const value: GetStorageAtValue = {
+        type: 'get-storage-at',
+        arguments: {
+          address: testAddress,
+          slot: '0'
+        },
+      }
+      const result = await resolver.resolve(value, context)
+      expect(result).toBe(expectedStorageValue)
+    })
+
+    it('should read different storage slots', async () => {
+      const slot1 = '0x0000000000000000000000000000000000000000000000000000000000000000'
+      const slot2 = '0x0000000000000000000000000000000000000000000000000000000000000001'
+      const value1 = '0x00000000000000000000000000000000000000000000000000000000000000aa'
+      const value2 = '0x00000000000000000000000000000000000000000000000000000000000000bb'
+
+      await anvilProvider.send('anvil_setStorageAt', [testAddress, slot1, value1])
+      await anvilProvider.send('anvil_setStorageAt', [testAddress, slot2, value2])
+
+      const valueForSlot1: GetStorageAtValue = {
+        type: 'get-storage-at',
+        arguments: {
+          address: testAddress,
+          slot: slot1
+        },
+      }
+      const valueForSlot2: GetStorageAtValue = {
+        type: 'get-storage-at',
+        arguments: {
+          address: testAddress,
+          slot: slot2
+        },
+      }
+
+      const result1 = await resolver.resolve(valueForSlot1, context)
+      const result2 = await resolver.resolve(valueForSlot2, context)
+
+      expect(result1).toBe(value1)
+      expect(result2).toBe(value2)
+    })
+
+    it('should resolve address from context variable', async () => {
+      context.setOutput('myAddress', testAddress)
+      await anvilProvider.send('anvil_setStorageAt', [testAddress, testSlot, expectedStorageValue])
+
+      const value: GetStorageAtValue = {
+        type: 'get-storage-at',
+        arguments: {
+          address: '{{myAddress}}',
+          slot: testSlot
+        },
+      }
+      const result = await resolver.resolve(value, context)
+      expect(result).toBe(expectedStorageValue)
+    })
+
+    it('should resolve slot from context variable', async () => {
+      context.setOutput('mySlot', testSlot)
+      await anvilProvider.send('anvil_setStorageAt', [testAddress, testSlot, expectedStorageValue])
+
+      const value: GetStorageAtValue = {
+        type: 'get-storage-at',
+        arguments: {
+          address: testAddress,
+          slot: '{{mySlot}}'
+        },
+      }
+      const result = await resolver.resolve(value, context)
+      expect(result).toBe(expectedStorageValue)
+    })
+
+    it('should return zero storage for non-existent slot', async () => {
+      const nonExistentSlot = '0x000000000000000000000000000000000000000000000000000000000000ffff'
+
+      const value: GetStorageAtValue = {
+        type: 'get-storage-at',
+        arguments: {
+          address: testAddress,
+          slot: nonExistentSlot
+        },
+      }
+      const result = await resolver.resolve(value, context)
+      // Non-existent slots return 0x00...00
+      expect(result).toBe('0x0000000000000000000000000000000000000000000000000000000000000000')
+    })
+
+    it('should throw error for invalid address', async () => {
+      const value: GetStorageAtValue = {
+        type: 'get-storage-at',
+        arguments: {
+          address: 'invalid-address',
+          slot: testSlot
+        },
+      }
+
+      await expect(resolver.resolve(value, context)).rejects.toThrow('Invalid address: invalid-address')
+    })
+
+    it('should throw error for null address', async () => {
+      const value: GetStorageAtValue = {
+        type: 'get-storage-at',
+        arguments: {
+          address: null as any,
+          slot: testSlot
+        },
+      }
+
+      await expect(resolver.resolve(value, context)).rejects.toThrow('Invalid address: null')
+    })
+
+    it('should throw error for undefined address', async () => {
+      const value: GetStorageAtValue = {
+        type: 'get-storage-at',
+        arguments: {
+          address: undefined as any,
+          slot: testSlot
+        },
+      }
+
+      await expect(resolver.resolve(value, context)).rejects.toThrow('Invalid address: undefined')
+    })
+
+    it('should handle checksummed addresses', async () => {
+      const checksummedAddress = '0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed'
+      await anvilProvider.send('anvil_setStorageAt', [checksummedAddress, testSlot, expectedStorageValue])
+
+      const value: GetStorageAtValue = {
+        type: 'get-storage-at',
+        arguments: {
+          address: checksummedAddress,
+          slot: testSlot
+        },
+      }
+      const result = await resolver.resolve(value, context)
+      expect(result).toBe(expectedStorageValue)
+    })
+
+    it('should handle lowercase addresses', async () => {
+      const lowercaseAddress = testAddress.toLowerCase()
+      await anvilProvider.send('anvil_setStorageAt', [lowercaseAddress, testSlot, expectedStorageValue])
+
+      const value: GetStorageAtValue = {
+        type: 'get-storage-at',
+        arguments: {
+          address: lowercaseAddress,
+          slot: testSlot
+        },
+      }
+      const result = await resolver.resolve(value, context)
+      expect(result).toBe(expectedStorageValue)
+    })
+
+    it('should handle large slot numbers', async () => {
+      // EIP-1967 implementation slot
+      const eip1967Slot = '0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc'
+      await anvilProvider.send('anvil_setStorageAt', [testAddress, eip1967Slot, expectedStorageValue])
+
+      const value: GetStorageAtValue = {
+        type: 'get-storage-at',
+        arguments: {
+          address: testAddress,
+          slot: eip1967Slot
+        },
+      }
+      const result = await resolver.resolve(value, context)
+      expect(result).toBe(expectedStorageValue)
+    })
+  })
+
+  describe('compute-slot', () => {
+    describe('mapping', () => {
+      it('should compute a mapping value slot with an address key', async () => {
+        const value: ComputeSlotValue = {
+          type: 'compute-slot',
+          arguments: {
+            kind: 'mapping',
+            slot: 2,
+            key: '0x1111111111111111111111111111111111111111',
+            keyType: 'address',
+          },
+        }
+        const result = await resolver.resolve(value, context)
+        expect(result).toBe('0x06bb1b9bc4293ba066a12274418b7ea4df183c2e4e6b39591987369520ca3956')
+      })
+
+      it('should default keyType to uint256', async () => {
+        const value: ComputeSlotValue = {
+          type: 'compute-slot',
+          arguments: {
+            kind: 'mapping',
+            slot: 1,
+            key: 5,
+          },
+        }
+        const result = await resolver.resolve(value, context)
+        expect(result).toBe('0xe2689cd4a84e23ad2f564004f1c9013e9589d260bde6380aba3ca7e09e4df40c')
+      })
+
+      it('should pack dynamic (string) keys', async () => {
+        const value: ComputeSlotValue = {
+          type: 'compute-slot',
+          arguments: {
+            kind: 'mapping',
+            slot: 7,
+            key: 'hello',
+            keyType: 'string',
+          },
+        }
+        const result = await resolver.resolve(value, context)
+        expect(result).toBe('0xa39e328cf6237afe41b514c6c18ccdc6b503f43ce841d4b5bca5e763723b44a9')
+      })
+
+      it('should support nesting for nested mappings', async () => {
+        // balances[a][b] where the outer mapping is at slot 0
+        const value: ComputeSlotValue = {
+          type: 'compute-slot',
+          arguments: {
+            kind: 'mapping',
+            key: '0x2222222222222222222222222222222222222222',
+            keyType: 'address',
+            slot: {
+              type: 'compute-slot',
+              arguments: {
+                kind: 'mapping',
+                slot: 0,
+                key: '0x1111111111111111111111111111111111111111',
+                keyType: 'address',
+              },
+            },
+          },
+        }
+        const result = await resolver.resolve(value, context)
+        expect(result).toBe('0xd1360c905f62126f789549525bc3219e0fb5feba645fd0705768a3cc3bf3fc5c')
+      })
+
+      it('should resolve references in arguments', async () => {
+        context.setOutput('mapSlot', 2)
+        context.setOutput('owner', '0x1111111111111111111111111111111111111111')
+        const value: ComputeSlotValue = {
+          type: 'compute-slot',
+          arguments: {
+            kind: 'mapping',
+            slot: '{{mapSlot}}',
+            key: '{{owner}}',
+            keyType: 'address',
+          },
+        }
+        const result = await resolver.resolve(value, context)
+        expect(result).toBe('0x06bb1b9bc4293ba066a12274418b7ea4df183c2e4e6b39591987369520ca3956')
+      })
+
+      it('should throw when key is missing', async () => {
+        const value = {
+          type: 'compute-slot',
+          arguments: { kind: 'mapping', slot: 0 },
+        } as unknown as ComputeSlotValue
+        await expect(resolver.resolve(value, context)).rejects.toThrow('compute-slot (mapping): "key" is required')
+      })
+    })
+
+    describe('dynamic-array', () => {
+      it('should compute an element slot', async () => {
+        const value: ComputeSlotValue = {
+          type: 'compute-slot',
+          arguments: { kind: 'dynamic-array', slot: 3, index: 4 },
+        }
+        const result = await resolver.resolve(value, context)
+        expect(result).toBe('0xc2575a0e9e593c00f959f8c92f12db2869c3395a3b0502d05e2516446f71f85f')
+      })
+
+      it('should default index to 0', async () => {
+        const value: ComputeSlotValue = {
+          type: 'compute-slot',
+          arguments: { kind: 'dynamic-array', slot: 3 },
+        }
+        const result = await resolver.resolve(value, context)
+        // keccak256(slot) with index 0
+        expect(result).toBe(ethers.keccak256(ethers.toBeHex(3, 32)))
+      })
+
+      it('should account for multi-slot elements via elementSize', async () => {
+        const value: ComputeSlotValue = {
+          type: 'compute-slot',
+          arguments: { kind: 'dynamic-array', slot: 3, index: 1, elementSize: 2 },
+        }
+        const result = await resolver.resolve(value, context)
+        expect(result).toBe('0xc2575a0e9e593c00f959f8c92f12db2869c3395a3b0502d05e2516446f71f85d')
+      })
+    })
+
+    describe('struct-field', () => {
+      it('should add the field offset to the base slot', async () => {
+        const value: ComputeSlotValue = {
+          type: 'compute-slot',
+          arguments: { kind: 'struct-field', slot: 100, offset: 3 },
+        }
+        const result = await resolver.resolve(value, context)
+        expect(result).toBe('0x0000000000000000000000000000000000000000000000000000000000000067')
+      })
+
+      it('should throw when offset is missing', async () => {
+        const value = {
+          type: 'compute-slot',
+          arguments: { kind: 'struct-field', slot: 1 },
+        } as unknown as ComputeSlotValue
+        await expect(resolver.resolve(value, context)).rejects.toThrow('compute-slot (struct-field): "offset" is required')
+      })
+    })
+
+    describe('erc7201', () => {
+      it('should compute the namespaced root for the EIP-7201 example', async () => {
+        const value: ComputeSlotValue = {
+          type: 'compute-slot',
+          arguments: { kind: 'erc7201', id: 'example.main' },
+        }
+        const result = await resolver.resolve(value, context)
+        expect(result).toBe('0x183a6125c38840424c4a85fa12bab2ab606c4b6d0e7cc73c0c06ba5300eab500')
+      })
+
+      it('should match OpenZeppelin Ownable namespace', async () => {
+        const value: ComputeSlotValue = {
+          type: 'compute-slot',
+          arguments: { kind: 'erc7201', id: 'openzeppelin.storage.Ownable' },
+        }
+        const result = await resolver.resolve(value, context)
+        expect(result).toBe('0x9016d09d72d40fdae2fd8ceac6b6234c7706214fd39c1cd1e609a0528c199300')
+      })
+
+      it('should throw on empty id', async () => {
+        const value = {
+          type: 'compute-slot',
+          arguments: { kind: 'erc7201', id: '' },
+        } as unknown as ComputeSlotValue
+        await expect(resolver.resolve(value, context)).rejects.toThrow('compute-slot (erc7201): "id" must be a non-empty string')
+      })
+    })
+
+    describe('eip1967', () => {
+      it('should compute the implementation slot', async () => {
+        const value: ComputeSlotValue = {
+          type: 'compute-slot',
+          arguments: { kind: 'eip1967', name: 'implementation' },
+        }
+        const result = await resolver.resolve(value, context)
+        expect(result).toBe('0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc')
+      })
+
+      it('should compute the admin slot', async () => {
+        const value: ComputeSlotValue = {
+          type: 'compute-slot',
+          arguments: { kind: 'eip1967', name: 'admin' },
+        }
+        const result = await resolver.resolve(value, context)
+        expect(result).toBe('0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103')
+      })
+
+      it('should compute the beacon slot', async () => {
+        const value: ComputeSlotValue = {
+          type: 'compute-slot',
+          arguments: { kind: 'eip1967', name: 'beacon' },
+        }
+        const result = await resolver.resolve(value, context)
+        expect(result).toBe('0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50')
+      })
+
+      it('should throw on unknown name', async () => {
+        const value = {
+          type: 'compute-slot',
+          arguments: { kind: 'eip1967', name: 'nope' },
+        } as unknown as ComputeSlotValue
+        await expect(resolver.resolve(value, context)).rejects.toThrow('compute-slot (eip1967): "name" must be one of')
+      })
+    })
+
+    it('should chain into get-storage-at as the slot argument', async () => {
+      // The computed slot is a valid bytes32 hex that get-storage-at can consume.
+      const computed = await resolver.resolve<string>({
+        type: 'compute-slot',
+        arguments: { kind: 'eip1967', name: 'implementation' },
+      } as ComputeSlotValue, context)
+      expect(computed).toBe('0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc')
+    })
+
+    it('should throw when kind is missing', async () => {
+      const value = { type: 'compute-slot', arguments: {} } as unknown as ComputeSlotValue
+      await expect(resolver.resolve(value, context)).rejects.toThrow('compute-slot: "kind" is required')
+    })
+
+    it('should throw on unknown kind', async () => {
+      const value = {
+        type: 'compute-slot',
+        arguments: { kind: 'bogus' },
+      } as unknown as ComputeSlotValue
+      await expect(resolver.resolve(value, context)).rejects.toThrow('compute-slot: unknown kind "bogus"')
+    })
+  })
 })

package/src/lib/core/engine.ts

@@ -987,6 +987,58 @@ export class ExecutionEngine {
         }
         break
       }
+      case 'assert': {
+        // Determine the source of ACTUAL value
+        let actual: any
+        let describe: string
+        if (action.arguments.to !== undefined) {
+          // Use eth_call via the call resolver
+          actual = await this.resolver.resolve(
+            { type: 'call', arguments: { to: action.arguments.to, signature: action.arguments.signature, values: action.arguments.values ?? [] } },
+            context,
+            scope,
+          )
+          describe = action.arguments.signature ?? 'call'
+        } else {
+          // Use the `actual` value resolver
+          actual = await this.resolver.resolve(action.arguments.actual, context, scope)
+          describe = action.arguments.signature ?? 'value'
+        }
+
+        // Determine the comparator key and expected value (exactly one required)
+        const comparatorKeys = ['eq', 'neq', 'gt', 'lt', 'gte', 'lte']
+        const args = action.arguments as any
+        const presentKeys = comparatorKeys.filter((key) => args[key] !== undefined)
+        if (presentKeys.length === 0) {
+          throw new Error(`Action "${actionName}": assert must have exactly one of: ${comparatorKeys.join(', ')}`)
+        }
+        if (presentKeys.length > 1) {
+          throw new Error(`Action "${actionName}": assert must have exactly one comparator, but got: ${presentKeys.join(', ')}`)
+        }
+        const operation = presentKeys[0]
+        let expected: any = args[operation]
+
+        // Resolve expected value
+        expected = await this.resolver.resolve(expected, context, scope)
+
+        // Compare using basic-arithmetic (which returns a boolean for eq/neq/gt/lt/gte/lte)
+        const ok = await this.resolver.resolve(
+          { type: 'basic-arithmetic', arguments: { operation, values: [actual, expected] } },
+          context,
+          scope,
+        )
+
+        if (!ok) {
+          const messagePart = action.arguments.message ? `: ${action.arguments.message}` : ''
+          throw new Error(`assert failed${messagePart}: ${describe} (actual=${actual}, expected=${expected}, op=${operation})`)
+        }
+
+        // Store output if named and no custom output
+        if (action.name && !hasCustomOutput) {
+          context.setOutput(`${action.name}.actual`, actual)
+        }
+        break
+      }
       default:
         throw new Error(`Unknown or unimplemented primitive action type: ${(action as any).type}`)
     }

package/src/lib/core/loader.ts

@@ -7,6 +7,7 @@ import { parseConstants } from '../parsers/constants'
 
 export interface ProjectLoaderOptions {
   loadStdTemplates?: boolean
+  loadContracts?: boolean
 }
 
 export class ProjectLoader {
@@ -28,7 +29,9 @@ export class ProjectLoader {
 
   async load() {
     // Load all contracts from the project root first
-    await this.contractRepository.loadFrom(this.projectRoot)
+    if (this.options.loadContracts !== false) {
+      await this.contractRepository.loadFrom(this.projectRoot)
+    }
 
     // Load standard library templates (unless disabled)
     if (this.options.loadStdTemplates !== false) {
@@ -119,6 +122,9 @@ export class ProjectLoader {
           this.templates.set(template.name, template)
           continue
         }
+        if (raw && typeof raw === 'object' && (raw.type === 'source' || raw.type === 'constants')) {
+          continue
+        }
 
         const job = parseJob(content)
         job._path = filePath
@@ -244,4 +250,4 @@ export class ProjectLoader {
           return false
       }
   }
-}
+}

package/src/lib/core/resolver.ts

@@ -8,6 +8,8 @@ import {
   ComputeCreateValue,
   ComputeCreate2Value,
   ReadBalanceValue,
+  GetStorageAtValue,
+  ComputeSlotValue,
   BasicArithmeticValue,
   CallValue,
   ContractExistsValue,
@@ -197,6 +199,10 @@ export class ValueResolver {
         return this.resolveComputeCreate2(resolvedArgs as ComputeCreate2Value['arguments'])
       case 'read-balance':
         return this.resolveReadBalance(resolvedArgs as ReadBalanceValue['arguments'], context)
+      case 'get-storage-at':
+        return this.resolveGetStorageAt(resolvedArgs as GetStorageAtValue['arguments'], context)
+      case 'compute-slot':
+        return this.resolveComputeSlot(resolvedArgs as ComputeSlotValue['arguments'])
       case 'basic-arithmetic':
         return this.resolveBasicArithmetic(resolvedArgs as BasicArithmeticValue['arguments'])
       case 'call':
@@ -375,6 +381,116 @@ export class ValueResolver {
     return balance.toString()
   }
 
+  private async resolveGetStorageAt(args: GetStorageAtValue['arguments'], context: ExecutionContext): Promise<string> {
+    const { address, slot } = args
+
+    // Check if the address is a valid address
+    if (!isAddress(address)) {
+      throw new Error(`Invalid address: ${address}`)
+    }
+
+    // Normalize the slot to a BigInt
+    // After resolution, slot should be a string or number
+    const slotValue = ethers.toBigInt(slot as string | number)
+
+    const storageValue = await context.provider.getStorage(address, slotValue)
+    // getStorage returns a hex string, ensure it's 32 bytes (64 hex chars + 0x)
+    return ethers.hexlify(storageValue)
+  }
+
+  /**
+   * Computes EVM storage slots for the common Solidity storage layouts.
+   * Always returns a 32-byte, 0x-prefixed lowercase hex string so the result can
+   * be fed straight into `get-storage-at` or nested as the `slot` of another
+   * `compute-slot` (e.g. nested mappings, structs inside mappings, ...).
+   */
+  private resolveComputeSlot(args: ComputeSlotValue['arguments']): string {
+    if (!args || typeof args !== 'object' || typeof (args as any).kind !== 'string') {
+      throw new Error('compute-slot: "kind" is required')
+    }
+
+    switch (args.kind) {
+      case 'mapping': {
+        const { slot, key, keyType } = args
+        if (slot === undefined || slot === null) {
+          throw new Error('compute-slot (mapping): "slot" is required')
+        }
+        if (key === undefined || key === null) {
+          throw new Error('compute-slot (mapping): "key" is required')
+        }
+        const baseSlot = ethers.toBigInt(slot as string | number)
+        const type = (keyType as string) || 'uint256'
+        try {
+          // mapping value slot = keccak256(h(key) . p)
+          // Dynamic key types (string/bytes) are packed; value types are ABI-encoded (left-padded to 32 bytes).
+          if (type === 'string' || type === 'bytes') {
+            return ethers.solidityPackedKeccak256([type, 'uint256'], [key, baseSlot])
+          }
+          const encoded = ethers.AbiCoder.defaultAbiCoder().encode([type, 'uint256'], [key, baseSlot])
+          return ethers.keccak256(encoded)
+        } catch (error) {
+          throw new Error(`compute-slot (mapping): failed to encode key as "${type}": ${error instanceof Error ? error.message : String(error)}`)
+        }
+      }
+
+      case 'dynamic-array': {
+        const { slot, index, elementSize } = args
+        if (slot === undefined || slot === null) {
+          throw new Error('compute-slot (dynamic-array): "slot" is required')
+        }
+        const baseSlot = ethers.toBigInt(slot as string | number)
+        const idx = index === undefined || index === null ? 0n : ethers.toBigInt(index as string | number)
+        const size = elementSize === undefined || elementSize === null ? 1n : ethers.toBigInt(elementSize as string | number)
+        // element slot = keccak256(slot) + index * elementSize
+        const dataStart = ethers.toBigInt(ethers.keccak256(ethers.toBeHex(baseSlot, 32)))
+        return ethers.toBeHex(dataStart + idx * size, 32)
+      }
+
+      case 'struct-field': {
+        const { slot, offset } = args
+        if (slot === undefined || slot === null) {
+          throw new Error('compute-slot (struct-field): "slot" is required')
+        }
+        if (offset === undefined || offset === null) {
+          throw new Error('compute-slot (struct-field): "offset" is required')
+        }
+        const result = ethers.toBigInt(slot as string | number) + ethers.toBigInt(offset as string | number)
+        return ethers.toBeHex(result, 32)
+      }
+
+      case 'erc7201': {
+        const { id } = args
+        if (typeof id !== 'string' || id.length === 0) {
+          throw new Error('compute-slot (erc7201): "id" must be a non-empty string')
+        }
+        // keccak256(abi.encode(uint256(keccak256(id)) - 1)) & ~bytes32(uint256(0xff))
+        const idHash = ethers.toBigInt(ethers.keccak256(ethers.toUtf8Bytes(id)))
+        const inner = ethers.keccak256(ethers.toBeHex(idHash - 1n, 32))
+        const mask = ((1n << 256n) - 1n) ^ 0xffn
+        return ethers.toBeHex(ethers.toBigInt(inner) & mask, 32)
+      }
+
+      case 'eip1967': {
+        const labels: Record<string, string> = {
+          implementation: 'eip1967.proxy.implementation',
+          admin: 'eip1967.proxy.admin',
+          beacon: 'eip1967.proxy.beacon',
+        }
+        const name = args.name as string
+        const label = labels[name]
+        if (!label) {
+          throw new Error(`compute-slot (eip1967): "name" must be one of implementation, admin, beacon (got "${name}")`)
+        }
+        // slot = keccak256("eip1967.proxy.<name>") - 1
+        const slot = ethers.toBigInt(ethers.keccak256(ethers.toUtf8Bytes(label))) - 1n
+        return ethers.toBeHex(slot, 32)
+      }
+
+      default:
+        throw new Error(`compute-slot: unknown kind "${(args as any).kind}"`)
+    }
+  }
+
   private resolveBasicArithmetic(args: BasicArithmeticValue['arguments']): string | boolean {
     if (!args.values || args.values.length < 2) {
       throw new Error(`basic-arithmetic requires at least 2 values, got ${args.values?.length ?? 0}`)