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]
});

struct Message: Encodable {
  struct W: Encodable {
    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 = EthereumRpcRequest.EIP712TypedData(
    types: [
      "EIP712Domain": [
        .init("name", type: "string"),
        .init("version", type: "string"),
        .init("chainId", type: "uint256"),
        .init("verifyingContract", type: "address"),
      ],
      "Person": [
        .init("name", type: "string"),
        .init("wallet", type: "address"),
      ],
      "Mail": [
        .init("from", type: "Person"),
        .init("to", type: "Person"),
        .init("contents", type: "string"),
      ],
    ],
    primaryType: "Mail",
    domain: .init(
      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 signature = try await provider.request(.ethSignTypedDataV4(address: wallet.address, typedData: typedData))

  print(signature)
}

// 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"
      }
    }
  }
}'