RETURNDATACOPY (0x3e)

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.

Overview

Opcode: 0x3e Introduced: Byzantium (EIP-211) RETURNDATACOPY copies return data from the most recent external call into memory.

Specification

Stack Input:

destOffset (memory offset)
offset (returndata offset)
length (bytes to copy)

Stack Output:

[]

Gas Cost: 3 + memory expansion + (length / 32) * 3

Behavior

Copies length bytes from return data at offset to memory at destOffset. Reverts if offset + length exceeds return data size. Key difference from other copy opcodes:

Does NOT zero-pad - reverts on out-of-bounds access
Strict bounds checking prevents reading beyond return data

Examples

Basic Usage

function copyReturnData() public {
    address target = 0x...;
    target.call("");

    assembly {
        let size := returndatasize()
        returndatacopy(0, 0, size)
        return(0, size)
    }
}

Proxy Forwarding

fallback() external payable {
    address impl = implementation;
    assembly {
        calldatacopy(0, 0, calldatasize())

        let result := delegatecall(gas(), impl, 0, calldatasize(), 0, 0)

        returndatacopy(0, 0, returndatasize())

        switch result
        case 0 { revert(0, returndatasize()) }
        default { return(0, returndatasize()) }
    }
}

Error Bubbling

function bubbleRevert(address target, bytes memory data) public {
    (bool success,) = target.call(data);

    if (!success) {
        assembly {
            let size := returndatasize()
            returndatacopy(0, 0, size)
            revert(0, size)
        }
    }
}

Gas Cost

Base: 3 gas Memory expansion: Variable Copy cost: 3 gas per 32-byte word

Common Usage

Efficient Proxy

function delegate(address impl, bytes memory data) public returns (bytes memory) {
    assembly {
        let result := delegatecall(gas(), impl, add(data, 0x20), mload(data), 0, 0)

        let size := returndatasize()
        let output := mload(0x40)
        mstore(output, size)
        returndatacopy(add(output, 0x20), 0, size)
        mstore(0x40, add(add(output, 0x20), size))

        switch result
        case 0 { revert(add(output, 0x20), size) }
        default { return(add(output, 0x20), size) }
    }
}

Security

Out-of-Bounds Reverts

Unlike CALLDATACOPY/CODECOPY, RETURNDATACOPY reverts on out-of-bounds:

function outOfBounds() public {
    address(0).call(""); // Returns empty

    assembly {
        // This REVERTS because returndatasize() = 0
        returndatacopy(0, 0, 32) // OutOfBounds!
    }
}

Safe Pattern

function safeReturnCopy(uint256 offset, uint256 length) public {
    require(offset + length <= returndatasize(), "Out of bounds");

    assembly {
        returndatacopy(0, offset, length)
    }
}

Implementation

TypeScript

export function returndatacopy(frame: FrameType): EvmError | null {
  const destOffsetResult = popStack(frame);
  if (destOffsetResult.error) return destOffsetResult.error;

  const offsetResult = popStack(frame);
  if (offsetResult.error) return offsetResult.error;

  const lengthResult = popStack(frame);
  if (lengthResult.error) return lengthResult.error;

  const offset = Number(offsetResult.value);
  const length = Number(lengthResult.value);

  // Strict bounds check - REVERTS if out of bounds
  if (offset > frame.returnData.length ||
      length > frame.returnData.length - offset) {
    return { type: "OutOfBounds" };
  }

  // Copy returndata to memory
  // See full implementation in codebase

  frame.pc += 1;
  return null;
}

Edge Cases

Empty Return Data

address(0).call("");
assembly {
    returndatacopy(0, 0, 0) // OK: copying 0 bytes
    returndatacopy(0, 0, 1) // REVERTS: out of bounds
}

Partial Copy

// returndata = 64 bytes
assembly {
    returndatacopy(0, 0, 32)   // OK: first 32 bytes
    returndatacopy(0, 32, 32)  // OK: second 32 bytes
    returndatacopy(0, 64, 1)   // REVERTS: beyond bounds
}

References

EIP-211 - RETURNDATASIZE and RETURNDATACOPY opcodes
EVM Codes - RETURNDATACOPY
Yellow Paper - Byzantium changes

Overview

Getting Started

Core Concepts

Skills

JSONRPCProvider

Contract

Primitives

Cryptography

EVM

Utils

Guides

Examples

Swift

Zig

Developer Documentation

Generated API (TypeDoc)

RETURNDATACOPY (0x3e)

Overview

Specification

Behavior

Examples

Basic Usage

Proxy Forwarding

Error Bubbling

Gas Cost

Common Usage

Efficient Proxy

Security

Out-of-Bounds Reverts

Safe Pattern

Implementation

Edge Cases

Empty Return Data

Partial Copy

References

​Overview

​Specification

​Behavior

​Examples

​Basic Usage

​Proxy Forwarding

​Error Bubbling

​Gas Cost

​Common Usage

​Efficient Proxy

​Security

​Out-of-Bounds Reverts

​Safe Pattern

​Implementation

​Edge Cases

​Empty Return Data

​Partial Copy

​References

Overview

Specification

Behavior

Examples

Basic Usage

Proxy Forwarding

Error Bubbling

Gas Cost

Common Usage

Efficient Proxy

Security

Out-of-Bounds Reverts

Safe Pattern

Implementation

Edge Cases

Empty Return Data

Partial Copy

References