[ERC7964] 1つの署名で複数チェーンの操作をまとめて実行するクロスチェーンEIP712署名の仕組みを理解しよう！

EIP712Domain: [
  { name: "name", type: "string" },
  { name: "version", type: "string" }
  // chainId は省略 → クロスチェーン署名
]

ChainOperation: [
  { name: "domain", type: "EIP712ChainDomain" },
  { name: "target", type: "address" },
  { name: "value", type: "uint256" },
  { name: "data", type: "bytes" }
],
EIP712ChainDomain: [
  { name: "chainId", type: "uint256" },
  { name: "verifyingContract", type: "address" }
]

keccak256(encodeData(element[0]) ‖ encodeData(element[1]) ‖ ... ‖ encodeData(element[n]))

bytes32 constant CROSSCHAIN_INTENT_TYPEHASH = keccak256(
    "CrossChainIntent(ChainOperation[] operations,uint256 nonce,uint256 deadline)ChainOperation(EIP712ChainDomain domain,address target,uint256 value,bytes data)EIP712ChainDomain(uint256 chainId,address verifyingContract)"
);

fullStructHash = keccak256(abi.encode(
    CROSSCHAIN_INTENT_TYPEHASH,
    keccak256(abi.encodePacked(chainOperationsArray)),
    nonce,
    deadline
));

bytes32 header = bytes32(abi.encodePacked(
    CrossChainSignatureChecker.ERC7964_MAGIC,
    fields,
    structIndex,
    address(application)
));
abi.encode(header, structsArray, crossChainSignature);

import {SignatureChecker} from "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
import {MessageHashUtils} from "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";
import {IERC5267} from "@openzeppelin/contracts/interfaces/IERC5267.sol";
import {Calldata} from "@openzeppelin/contracts/utils/Calldata.sol";

library CrossChainSignatureChecker {
    bytes9 internal constant ERC7964_MAGIC = 0x796479647964796479;

    function isValidCrossChainSignatureNow(
        address signer,
        bytes32 hash,
        bytes calldata erc7964Signature,
        function(bytes32) internal view returns (bytes32) structHash
    ) internal view returns (bool) {
        (
            bool success,
            bytes1 fields,
            uint16 structIndex,
            address application,
            bytes32[] calldata structsArray,
            bytes calldata crossChainSignature
        ) = parseCrossChainSignature(erc7964Signature);
        if (!success || structsArray[structIndex] != hash) return false;

        string memory name;
        string memory version;
        uint256 chainId;
        address verifyingContract;
        bytes32 domainSalt;
        (, name, version, chainId, verifyingContract, domainSalt, ) =
            IERC5267(application).eip712Domain();

        bytes32 typedHash = MessageHashUtils.toTypedDataHash(
            MessageHashUtils.toDomainSeparator(
                fields, name, version, chainId, verifyingContract, domainSalt
            ),
            structHash(keccak256(abi.encodePacked(structsArray)))
        );
        return SignatureChecker.isValidSignatureNowCalldata(
            signer, typedHash, crossChainSignature
        );
    }

    function parseCrossChainSignature(
        bytes calldata erc7964Signature
    )
        internal
        pure
        returns (
            bool success,
            bytes1 fields,
            uint16 structIndex,
            address application,
            bytes32[] calldata structsArray,
            bytes calldata crossChainSignature
        )
    {
        if (
            erc7964Signature.length < 0x9f ||
            bytes9(erc7964Signature[0:9]) != ERC7964_MAGIC
        ) {
            return (
                false, 0, 0, address(0),
                _empty32BytesArrayCalldata(), Calldata.emptyBytes()
            );
        }
        fields = erc7964Signature[9];
        structIndex = uint16(bytes2(erc7964Signature[10:]));
        application = address(bytes20(erc7964Signature[12:]));

        uint256 structsArrayOffset = uint256(bytes32(erc7964Signature[0x20:]));
        uint256 structsArrayDataOffset = structsArrayOffset + 32;
        if (
            structsArrayOffset < 0x60 ||
            structsArrayDataOffset > erc7964Signature.length
        ) {
            return (
                false, 0, 0, address(0),
                _empty32BytesArrayCalldata(), Calldata.emptyBytes()
            );
        }
        uint256 structsArrayLength = uint256(
            bytes32(erc7964Signature[structsArrayOffset:])
        );
        if (
            structsArrayDataOffset + structsArrayLength * 32 >
            erc7964Signature.length
        ) {
            return (
                false, 0, 0, address(0),
                _empty32BytesArrayCalldata(), Calldata.emptyBytes()
            );
        }

        uint256 crossChainSignatureOffset =
            structsArrayDataOffset + structsArrayLength * 32;
        uint256 crossChainSignatureDataOffset = crossChainSignatureOffset + 32;
        if (
            crossChainSignatureOffset < 0x60 ||
            crossChainSignatureDataOffset > erc7964Signature.length
        ) {
            return (
                false, 0, 0, address(0),
                _empty32BytesArrayCalldata(), Calldata.emptyBytes()
            );
        }
        uint256 crossChainSignatureLength = uint256(
            bytes32(erc7964Signature[crossChainSignatureOffset:])
        );
        if (
            crossChainSignatureDataOffset + crossChainSignatureLength >
            erc7964Signature.length
        ) {
            return (
                false, 0, 0, address(0),
                _empty32BytesArrayCalldata(), Calldata.emptyBytes()
            );
        }

        assembly ("memory-safe") {
            structsArray.offset := add(
                erc7964Signature.offset, structsArrayDataOffset
            )
            structsArray.length := structsArrayLength
        }
        crossChainSignature = erc7964Signature[
            crossChainSignatureDataOffset:
            crossChainSignatureDataOffset + crossChainSignatureLength
        ];
        return (
            true, fields, structIndex, application,
            structsArray, crossChainSignature
        );
    }

    function _empty32BytesArrayCalldata()
        private
        pure
        returns (bytes32[] calldata result)
    {
        assembly ("memory-safe") {
            result.offset := 0
            result.length := 0
        }
    }
}

{
  types: {
    EIP712Domain: [
      { name: "name", type: "string" },
      { name: "version", type: "string" }
      // chainId は省略
    ],
    CrossChainIntent: [
      { name: "operations", type: "ChainOperation[]" },
      { name: "nonce", type: "uint256" },
      { name: "deadline", type: "uint256" }
    ],
    ChainOperation: [
      { name: "domain", type: "EIP712ChainDomain" },
      { name: "target", type: "address" },
      { name: "value", type: "uint256" },
      { name: "data", type: "bytes" }
    ],
    EIP712ChainDomain: [
      { name: "chainId", type: "uint256" },
      { name: "verifyingContract", type: "address" }
    ]
  },
  primaryType: "CrossChainIntent",
  domain: {
    name: "CrossChainDEX",
    version: "1"
  },
  message: {
    operations: [
      {
        domain: {
          chainId: 1,                    // Ethereum
          verifyingContract: "0x123321..." // Ethereum上のアカウント
        },
        target: "0xA0b86a33E6776885F5Db...", // USDCコントラクト
        value: 0,
        data: "0xa9059cbb..."               // transfer(settler, 1000 USDC)
      },
      {
        domain: {
          chainId: 42161,                // Arbitrum
          verifyingContract: "0x123321..." // Arbitrum上のアカウント
        },
        target: "0xArbitrumSettler...",
        value: 0,
        data: "0x3ccfd60b..."               // claim(最低0.5 ETH)
      }
    ],
    nonce: 42,
    deadline: 1704067200
  }
}

import {EIP712} from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
import {Nonces} from "@openzeppelin/contracts/utils/Nonces.sol";
import {CrossChainSignatureChecker} from "./CrossChainSignatureChecker.sol";

contract CrossChainDEX is EIP712, Nonces {
    using CrossChainSignatureChecker for address;

    bytes32 public constant EIP712_CHAIN_DOMAIN_TYPEHASH =
        keccak256(
            "EIP712ChainDomain(uint256 chainId,address verifyingContract)"
        );
    bytes32 public constant CHAIN_OPERATION_TYPEHASH =
        keccak256(
            "ChainOperation(EIP712ChainDomain domain,address target,"
            "uint256 value,bytes data)"
            "EIP712ChainDomain(uint256 chainId,address verifyingContract)"
        );
    bytes32 public constant CROSSCHAIN_INTENT_TYPEHASH =
        keccak256(
            "CrossChainIntent(ChainOperation[] operations,"
            "uint256 nonce,uint256 deadline)"
            "ChainOperation(EIP712ChainDomain domain,address target,"
            "uint256 value,bytes data)"
            "EIP712ChainDomain(uint256 chainId,address verifyingContract)"
        );

    mapping(bytes32 operationHash => uint256) private _deadlines;

    constructor() EIP712("CrossChainDEX", "1") {}

    function executeIntent(
        address account,
        ChainOperation calldata currentOp,
        uint256 nonce,
        uint256 deadline,
        bytes calldata signature
    ) external {
        bytes32 currentOpHash = _structHash(currentOp);

        _useCheckedNonce(account, nonce);
        _deadlines[currentOpHash] = deadline;

        require(
            account.isValidCrossChainSignatureNowCalldata(
                currentOpHash,
                signature,
                _crossChainStructHash
            ),
            "Invalid signature"
        );

        (bool success, ) = currentOp.target.call{value: currentOp.value}(
            currentOp.data
        );
        require(success, "Execution failed");
    }

    function _crossChainStructHash(
        bytes32 operationsHash
    ) internal view returns (bytes32) {
        return keccak256(abi.encode(
            CROSSCHAIN_INTENT_TYPEHASH,
            operationsHash,
            nonces(account),
            _deadlines[operationsHash]
        ));
    }

    function _structHash(
        ChainOperation calldata op
    ) internal view returns (bytes32) {
        return keccak256(abi.encode(
            CHAIN_OPERATION_TYPEHASH,
            keccak256(abi.encode(
                EIP712_CHAIN_DOMAIN_TYPEHASH,
                block.chainid,
                address(this)
            )),
            op.target,
            op.value,
            keccak256(op.data)
        ));
    }
}

{
  types: {
    EIP712Domain: [
      { name: "name", type: "string" },
      { name: "version", type: "string" }
    ],
    MultiChainVote: [
      { name: "votes", type: "ChainVote[]" },
      { name: "nonce", type: "uint256" }
    ],
    ChainVote: [
      { name: "domain", type: "EIP712ChainDomain" },
      { name: "proposalId", type: "uint256" },
      { name: "support", type: "uint8" },
      { name: "reason", type: "string" }
    ],
    EIP712ChainDomain: [
      { name: "chainId", type: "uint256" },
      { name: "verifyingContract", type: "address" }
    ]
  },
  primaryType: "MultiChainVote",
  domain: {
    name: "MultiChainDAO",
    version: "1"
  },
  message: {
    votes: [
      {
        domain: {
          chainId: 1,                    // Ethereum
          verifyingContract: "0x123321..." // EthereumのDAOコントラクト
        },
        proposalId: 42,
        support: 1,  // 賛成
        reason: "This upgrade improves security"
      },
      {
        domain: {
          chainId: 137,                  // Polygon
          verifyingContract: "0x321321..." // PolygonのDAOコントラクト
        },
        proposalId: 42,
        support: 1,  // 賛成
        reason: "This upgrade improves security"
      }
    ],
    nonce: 7
  }
}

{
  types: {
    EIP712Domain: [
      { name: "name", type: "string" },
      { name: "version", type: "string" }
    ],
    MultiChainAccountUpdate: [
      { name: "updates", type: "AccountUpdate[]" },
      { name: "nonce", type: "uint256" }
    ],
    AccountUpdate: [
      { name: "domain", type: "EIP712ChainDomain" },
      { name: "operation", type: "uint8" },
      { name: "signerData", type: "bytes" },
      { name: "threshold", type: "uint256" }
    ],
    EIP712ChainDomain: [
      { name: "chainId", type: "uint256" },
      { name: "verifyingContract", type: "address" }
    ]
  },
  primaryType: "MultiChainAccountUpdate",
  domain: {
    name: "MultiChainMultisig",
    version: "1"
  },
  message: {
    updates: [
      {
        domain: {
          chainId: 1,
          verifyingContract: "0x123321..."
        },
        operation: 0,  // addSigner
        signerData: "0x0102...1f20",
        threshold: 3
      },
      {
        domain: {
          chainId: 137,
          verifyingContract: "0x123321..."
        },
        operation: 0,  // addSigner
        signerData: "0x0102...1f20",
        threshold: 3
      },
      {
        domain: {
          chainId: 42161,
          verifyingContract: "0x123321..."
        },
        operation: 0,  // addSigner
        signerData: "0x0102...1f20",
        threshold: 3
      }
    ],
    nonce: 42
  }
}

{
  types: {
    EIP712Domain: [
      { name: "name", type: "string" },
      { name: "version", type: "string" }
    ],
    MultiChainRecovery: [
      { name: "recoveries", type: "ChainRecovery[]" },
      { name: "nonce", type: "uint256" }
    ],
    ChainRecovery: [
      { name: "domain", type: "EIP712ChainDomain" },
      { name: "newOwner", type: "address" }
    ],
    EIP712ChainDomain: [
      { name: "chainId", type: "uint256" },
      { name: "verifyingContract", type: "address" }
    ]
  },
  primaryType: "MultiChainRecovery",
  domain: {
    name: "CrossChainSocialRecovery",
    version: "1"
  },
  message: {
    recoveries: [
      {
        domain: {
          chainId: 1,
          verifyingContract: "0x123321..."  // Ethereumのリカバリモジュール
        },
        newOwner: "0x9999999999999999999999999999999999999999"
      },
      {
        domain: {
          chainId: 137,
          verifyingContract: "0x321321..."  // Polygonのリカバリモジュール
        },
        newOwner: "0x9999999999999999999999999999999999999999"
      },
      {
        domain: {
          chainId: 42161,
          verifyingContract: "0x432432..."  // Arbitrumのリカバリモジュール
        },
        newOwner: "0x9999999999999999999999999999999999999999"
      }
    ],
    nonce: 1
  }
}