Sign typed data

signTypedData(input: SignTypedDataParams, options?: SignTypedDataOptions): Promise<{signature: string}>

import {useSignTypedData} from '@privy-io/react-auth';

const {signTypedData} = useSignTypedData();
const {signature} = await signTypedData({...});

import {useSignTypedData} from '@privy-io/react-auth';

const {signTypedData} = useSignTypedData({
  onSuccess: ({signature}) => {
    console.log(signature);
    // Any logic you'd like to execute after a user successfully signs the EIP-712 typed data
  },
  onError: (error) => {
    console.log(error);
    // Any logic you'd like to execute after a user exits the signing flow or there is an error
  }
});

// Then call `signTypedData` in your code, which will invoke these callbacks on completion

request: ({method: 'eth_signTypedData_v4', params: [address, typedData]}) => Promise<{signature: string}>

import {useEmbeddedEthereumWallet} from '@privy-io/expo';

const {wallets} = useEmbeddedEthereumWallet();
const wallet = wallets[0];

// Get an EIP-1193 Provider
const provider = await wallet.getProvider();
// Get address
const accounts = await provider.request({
  method: 'eth_requestAccounts'
});

const signature = await provider.request({
  method: 'eth_signTypedData_v4',
  params: [accounts[0], typedData]
});

// Define a struct to represent your typed data
struct Param: Codable {
    let types: ParamTypes
    let primaryType: String
    let domain: Domain
    let message: Message
}

struct ParamTypes: Codable {
    let eIP712Domain: [DomainType]
    let person: [DomainType]
    let mail: [DomainType]

    enum CodingKeys: String, CodingKey {
        case eIP712Domain = "EIP712Domain"
        case person = "Person"
        case mail = "Mail"
    }
}

struct DomainType: Codable {
    let name: String
    let type: String
}

struct Domain: Codable {
    let name: String
    let version: String
    let chainId: Int
    let verifyingContract: String
}

struct Message: Codable {
    struct W: Codable {
        let name: String
        let wallet: String
    }

    let from: W
    let to: W
    let contents: String
}

func typedData() async throws {
    let wallets = user.embeddedEthereumWallets

    // Grab the desired wallet. Here, we retrieve the first wallet
    guard let wallet = wallets.first else {
        // No ETH wallets
        return
    }

    let typedData = Param(
        types: ParamTypes(
            eIP712Domain: [
                DomainType(name: "name", type: "string"),
                DomainType(name: "version", type: "string"),
                DomainType(name: "chainId", type: "uint256"),
                DomainType(name: "verifyingContract", type: "address"),
            ],
            person: [
                DomainType(name: "name", type: "string"),
                DomainType(name: "wallet", type: "address")
            ],
            mail: [
                DomainType(name: "from", type: "Person"),
                DomainType(name: "to", type: "Person"),
                DomainType(name: "contents", type: "string"),
            ]
        ), primaryType: "Mail",
        domain: Domain(
            name: "Ether Mail",
            version: "1",
            chainId: 1,
            verifyingContract: "0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC"
        ),
        message: Message(
            from: Message.W(name: "Cow", wallet: "0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826"),
            to: Message.W(name: "Bob", wallet: "0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB"),
            contents: "Hello, Bob!"
        )
    )

    let encodedTypedData = try JSONEncoder().encode(typedData)

    guard let typedDataStr = String(data: encodedTypedData, encoding: .utf8) else {
        print("Data parse error")
        return
    }

    let signature = try await wallet.provider.request(
        EthereumRpcRequest(
            method: "eth_signTypedData_v4",
            params: [wallet.address, typedDataStr]
        )
    )

    print(signature)
}

// Retrieve list of user's embedded Ethereum wallets
let ethereumWallets = user.embeddedEthereumWallets

// the target wallet here is looked up by it's position in the list,
// but you may choose to have some application state that includes
// it's address, and look it up that way
let wallet = wallets[1]

// Get RPC provider for wallet
let provider = wallet.provider

let response = try await provider.request(
    RpcRequest(
        method: "personal_sign",
        params: ["The message that is being signed", wallet.address]
    )
)

// Get Privy user
ethereumWallet.provider.request(
  request = EthereumRpcRequest(
    method = "eth_signTypedData_v4",
    params = listOf(ethereumWallet.address, typedData),
  ),
)

try {
    IEmbeddedEthereumWallet embeddedWallet = PrivyManager.Instance.User.EmbeddedWallets[0];
    var rpcRequest = new RpcRequest
    {m
        Method = "eth_signTypedData_v4",
        Params = new string[] {embeddedWallet.Address, typedData }  // Use the 'new' keyword here
    };
    RpcResponse signTypedDataResponse = await embeddedWallet.RpcProvider.Request(rpcRequest);
    Debug.Log(signTypedDataResponse.Data);
} catch (PrivyException.EmbeddedWalletException ex){
    Debug.LogError($"Could not sign message due to error: {ex.Error} {ex.Message}");
} catch (Exception ex) {
    Debug.LogError($"Could not sign message exception {ex.Message}");
}

// Get an EIP-1193 Provider
final ethereumWallet = privy.user.embeddedEthereumWallets.first;
final provider = ethereumWallet.provider;

// Define the typed data
final typedData = {
  'types': {
    'EIP712Domain': [
      {'name': 'name', 'type': 'string'},
      {'name': 'version', 'type': 'string'},
      {'name': 'chainId', 'type': 'uint256'},
      {'name': 'verifyingContract', 'type': 'address'},
    ],
    'Person': [
      {'name': 'name', 'type': 'string'},
      {'name': 'wallet', 'type': 'address'},
    ],
    'Mail': [
      {'name': 'from', 'type': 'Person'},
      {'name': 'to', 'type': 'Person'},
      {'name': 'contents', 'type': 'string'},
    ],
  },
  'primaryType': 'Mail',
  'domain': {
    'name': 'Ether Mail',
    'version': '1',
    'chainId': 1,
    'verifyingContract': '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
  },
  'message': {
    'from': {
      'name': 'Cow',
      'wallet': '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826',
    },
    'to': {
      'name': 'Bob',
      'wallet': '0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB',
    },
    'contents': 'Hello, Bob!',
  },
};

// Create the RPC request
final request = EthereumRpcRequest(
  method: 'eth_signTypedData_v4',
  params: [ethereumWallet.address, jsonEncode(typedData)],
);

// Sign the typed data
final result = await provider.request(request);

result.fold(
  onSuccess: (response) {
    final signature = response.data;
    print('Signature: $signature');
  },
  onFailure: (error) {
    print('Error signing typed data: ${error.message}');
  },
);

signTypedData: (input: {walletId: string, typedData: TypedData}) => Promise<{signature: string, encoding: 'hex'}>

// Get the signature and encoding from the response
const {signature, encoding} = await privy.walletApi.ethereum.signTypedData({
  walletId: 'insert-wallet-id',
  typedData: {
    domain: {
      name: 'Ether Mail',
      version: '1',
      chainId: 1,
      verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC'
    },
    types: {
      EIP712Domain: [
        {name: 'name', type: 'string'},
        {name: 'version', type: 'string'},
        {name: 'chainId', type: 'uint256'},
        {name: 'verifyingContract', type: 'address'}
      ],
      Person: [
        {name: 'name', type: 'string'},
        {name: 'wallet', type: 'address'}
      ],
      Mail: [
        {name: 'from', type: 'Person'},
        {name: 'to', type: 'Person'},
        {name: 'contents', type: 'string'}
      ]
    },
    primaryType: 'Mail',
    message: {
      from: {
        name: 'Cow',
        wallet: '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826'
      },
      to: {
        name: 'Bob',
        wallet: '0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB'
      },
      contents: 'Hello, Bob!'
    }
  }
});

https://api.privy.io/v1/wallets/<wallet_id>/rpc

curl --request POST https://api.privy.io/v1/wallets/<wallet_id>/rpc \
-u "<your-privy-app-id>:<your-privy-app-secret>" \
-H "privy-app-id: <your-privy-app-id>" \
-H "privy-authorization-signature: <authorization-signature-for-request>" \
-H 'Content-Type: application/json' \
-d '{
  "method": "eth_signTypedData_v4",
  "params": {
    "typed_data": {
      "types": {
        "EIP712Domain": [
          { "name": "name", "type": "string" },
          { "name": "version", "type": "string" },
          { "name": "chainId", "type": "uint256" },
          { "name": "verifyingContract", "type": "address" }
        ],
        "Person": [
          { "name": "name", "type": "string" },
          { "name": "wallet", "type": "address" }
        ],
        "Mail": [
          { "name": "from", "type": "Person" },
          { "name": "to", "type": "Person" },
          { "name": "contents", "type": "string" }
        ]
      },
      "message": {
        "from": {
          "name": "Alice",
          "wallet": "0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826"
        },
        "to": {
          "name": "Bob",
          "wallet": "0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB"
        },
        "contents": "Hello, Bob!"
      },
      "primary_type": "Mail",
      "domain": {
        "name": "DApp Mail",
        "version": "1",
        "chainId": 1,
        "verifyingContract": "0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC"
      }
    }
  }
}'