with 712不适用于字符串。

Question

我试图使用eip-712签名与我的智能合同，但我发现，它只适用于固定大小的类型。有人知道我如何使用动态大小的类型，如字符串、数组和字节吗？

这是我用过的测试合同，

它适用于bytes32但是，

pragma solidity ^0.8.7;

import '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';
import '@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol';

contract SignCheck is EIP712 {
    using ECDSA for bytes32;
    address org;
    struct forwardData {
        address from;
        bytes32 name;
    }

    bytes32 private constant typeHash =
        keccak256(
            'forwardData(address from,bytes32 name)' //here
        );

    constructor(address org_) EIP712('test', '1') {
        org = org_;
    }

    function verify(forwardData calldata data, bytes calldata signature)
        internal
        view
        returns (address)
    {
        return _hashTypedDataV4(
            keccak256(
                abi.encode(typeHash, data.from, data.name)
            )
        ).recover(signature);
    }

    function check(
        forwardData calldata data,
        bytes calldata signature
    ) external view returns (address) {
        return verify(data, signature);
    }
}

在这种情况下，当我将类型更改为string时，它不会

pragma solidity ^0.8.7;

import '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';
import '@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol';

contract SignCheck is EIP712 {
    using ECDSA for bytes32;
    address org;
    struct forwardData {
        address from;
        string name;
    }

    bytes32 private constant typeHash =
        keccak256(
            'forwardData(address from,string name)' //here
        );

    constructor(address org_) EIP712('test', '1') {
        org = org_;
    }

    function verify(forwardData calldata data, bytes calldata signature)
        internal
        view
        returns (address)
    {
        return _hashTypedDataV4(
            keccak256(
                abi.encode(typeHash, data.from, data.name)
            )
        ).recover(signature);
    }

    function check(
        forwardData calldata data,
        bytes calldata signature
    ) external view returns (address) {
        return verify(data, signature);
    }
}

这是我如何在这个例子中实现以太的。

const contractAddress = "0x3b1B4DAb15c2222Ae2d30dc835235C990d7d515f";
const inName = "just name";

const domainSeparator = {
  name: "test",
  version: "1",
  // chainId: Number(id_),
  chainId: 1337,
  verifyingContract: contractAddress,
};

const types = {
  forwardData: [
    { name: "from", type: "address" },
    { name: "name", type: "string" },
  ],
};

const value = {
  from: address,
  name: inName,
};

// const digest = TypedDataUtils.encodeDigest(typedData);
const signature = signer._signTypedData(domainSeparator, types, value);

知道吗？

Answer 1

您需要首先对字符串进行abi.encodePacked和keccak256。

function verify(forwardData calldata data, bytes calldata signature) internal view returns (address)
{
    return _hashTypedDataV4(
        keccak256(abi.encode(
            typeHash,
            data.from,
            keccak256(abi.encodePacked(data.name)) // Change applied here
        ))
    ).recover(signature);
}