> ## Documentation Index
> Fetch the complete documentation index at: https://voltaire.tevm.sh/llms.txt
> Use this file to discover all available pages before exploring further.

# SWAP7 (0x96)

> Swap top with 8th stack item

<Warning>
  **This page is a placeholder.** All examples on this page are currently AI-generated and are not correct. This documentation will be completed in the future with accurate, tested examples.
</Warning>

## Overview

**Opcode:** `0x96`
**Introduced:** Frontier (EVM genesis)

SWAP7 exchanges the top stack item with the 8th item from the top. Only these two positions change - all other items remain in place.

## Specification

**Stack Input:**

```
[..., valueN, item6, ..., item1, top]
```

**Stack Output:**

```
[..., top, item6, ..., item1, valueN]
```

**Gas Cost:** 3 (GasFastestStep)

**Operation:**

```
temp = stack[top]
stack[top] = stack[top - 8]
stack[top - 8] = temp
```

## Behavior

SWAP7 exchanges positions of the top item and the item at position 8 from top. Requires stack depth ≥ 8.

Key characteristics:

* Requires stack depth ≥ 8
* Only two items change positions
* Middle items (items 1-7) unchanged
* StackUnderflow if depth \< 8
* Stack depth unchanged

## Examples

### Basic Usage

```typescript theme={null}
import { handler_0x96_SWAP7 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';

// Swap top with 8th item
const frame = createFrame({
  stack: [800n, 700n, 600n, 500n, 400n, 300n, 200n, 100n],
  gasRemaining: 1000n
});

const err = handler_0x96_SWAP7(frame);

console.log(frame.stack); // [100n, 700n, 600n, 500n, 400n, 300n, 200n, 800n] - positions 0 and 7 swapped
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```

### Solidity Compilation

```solidity theme={null}
contract Example {
    function deepSwap() public pure {
        assembly {
            push1 0x01
            push1 0x02
            push1 0x03
            push1 0x04
            push1 0x05
            push1 0x06
            push1 0x07
            push1 0x08
            // Stack: [1, 2, 3, 4, 5, 6, 7, 8]
            swap7
            // Stack: [8, 2, 3, 4, 5, 6, 7, 1]
        }
    }
}
```

### Assembly Usage

```solidity theme={null}
assembly {
    push1 0xa
    push1 0xb
    push1 0xc
    push1 0xd
    push1 0xe
    push1 0xf
    push1 0xg
    push1 0xh
    // Stack: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']

    swap7
    // Stack: ['h', 'b', 'c', 'd', 'e', 'f', 'g', 'a'] - 'a' and 'h' swapped
}
```

## Gas Cost

**Cost:** 3 gas (GasFastestStep)

All SWAP1-16 operations cost the same despite different stack depths accessed.

**Comparison:**

| Operation | Gas | Note               |
| --------- | --- | ------------------ |
| SWAP7     | 3   | Swap with 8th item |
| DUP1-16   | 3   | Same cost tier     |
| POP       | 2   | Cheaper            |

## Common Usage

### Deep Stack Manipulation

````solidity theme={null}
function complex() public pure {
    assembly {
        let v0 := 0
        let v1 := 1
        let v2 := 2
        let v3 := 3
        let v4 := 4
        let v5 := 5
        let v6 := 6
        let v7 := 7
        // Need v0 at top
        swap7
        // v0 now at top
    }
}```

### Efficient Reordering

```solidity
// Reorder for function call
assembly {
    // Have: [value, to, token]
    // Need: [token, to, value]
    swap2  // [token, to, value]

    // Call transfer(token, to, value)
    call(gas(), target, 0, 0, 100, 0, 0)
}
````

### Storage Optimization

```solidity theme={null}
assembly {
    let slot := 0
    let value := 42
    // Stack: [slot, value]

    // SSTORE needs (slot, value) but we have them reversed
    // No swap needed in this case, but if we did:
    swap1
    // Stack: [value, slot]
    sstore
}
```

## Stack Depth Requirements

### Minimum Depth

```solidity theme={null}
// SWAP7 requires 8 items
assembly {
    push1 0x01
    push1 0x02
    push1 0x03
    push1 0x04
    push1 0x05
    push1 0x06
    push1 0x07
    // Only 7 items - SWAP7 will fail!
    swap7  // StackUnderflow
}
```

### Safe Usage

```solidity theme={null}
assembly {
    push1 0x01
    push1 0x02
    push1 0x03
    push1 0x04
    push1 0x05
    push1 0x06
    push1 0x07
    push1 0x08
    // Exactly 8 items - safe
    swap7  // Success
}
```

## Implementation

<Tabs>
  <Tab title="TypeScript">
    ```typescript theme={null}
    /**
     * SWAP7 opcode (0x96) - Swap top with 8th item
     *
     * Stack: [..., valueN, ..., top] => [..., top, ..., valueN]
     * Gas: 3 (GasFastestStep)
     */
    export function handler_0x96_SWAP7(frame: FrameType): EvmError | null {
      const gasErr = consumeGas(frame, FastestStep);
      if (gasErr) return gasErr;

      if (frame.stack.length <= 7) {
        return { type: "StackUnderflow" };
      }

      const topIdx = frame.stack.length - 1;
      const swapIdx = frame.stack.length - 8;
      const temp = frame.stack[topIdx];
      frame.stack[topIdx] = frame.stack[swapIdx];
      frame.stack[swapIdx] = temp;

      frame.pc += 1;
      return null;
    }
    ```
  </Tab>
</Tabs>

## Edge Cases

### Stack Underflow

```typescript theme={null}
// Insufficient stack depth
const frame = createFrame({
  stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n]  // Only 7 items, need 8
});

const err = handler_0x96_SWAP7(frame);
console.log(err); // { type: "StackUnderflow" }
```

### Out of Gas

```typescript theme={null}
// Insufficient gas
const frame = createFrame({
  stack: [100n, 100n, 100n, 100n, 100n, 100n, 100n, 100n],
  gasRemaining: 2n  // Need 3
});

const err = handler_0x96_SWAP7(frame);
console.log(err); // { type: "OutOfGas" }
```

### Identity Swap

```typescript theme={null}
// Swap same values
const frame = createFrame({
  stack: new Array(8).fill(42n)
});

handler_0x96_SWAP7(frame);
console.log(frame.stack); // All still 42n
```

### Maximum Values

```typescript theme={null}
// Swap with max uint256
const MAX = (1n << 256n) - 1n;
const frame = createFrame({
  stack: [0n, 0n, 0n, 0n, 0n, 0n, 0n, MAX, 1n]
});

handler_0x96_SWAP7(frame);
console.log(frame.stack[0]); // 1n (was at top)
console.log(frame.stack[7]); // MAX (was at bottom)
```

## References

* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.1 (Stack Operations)
* [EVM Codes - SWAP7](https://www.evm.codes/#96?fork=cancun)
* [Solidity Assembly - swap7](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)