Requesting signatures and transactions

To request signatures or transactions from a connected wallet, you can either:

use the wallet's EIP-1193 provider to send JSON-RPC requests to the wallet directly.
pass the wallet to a library like viem, ethers, or wagmi.
for the embedded wallet specifically, create a transactionIntent from the server and signMessage it with the embedded signer (client).

The request method

At a high-level, the EIP-1193 provider implements a method called request that accepts an object with the following fields:

method: the name of a JSON-RPC request to send to the wallet
params: any parameters to include with the request

Signatures#

The request method of the EIP-1193 provider can be used to request signatures. First, get the provider:

client.tsx

openfortConfig.ts

import openfort from "./openfortConfig"
// This example assumes you have already checked that Openfort 'embeddedState' is 
// `ready` and the user is `authenticated`
const provider = openfort.getEthereumProvider();

Then use the provider's request method with eth_sign or related methods:

const message = "Sign this message";
const signature = await provider.request({
  method: 'personal_sign',
  params: [message, address]
});

Popular web3 libraries provide convenient methods for requesting signatures:

Library	Method
Ethers	Use the signer's `signMessage` method
Wagmi	Use the `useSignMessage` hook
Viem	Use the `signMessage` action

Transactions#

Get the provider and optionally configure gas policy to make a sponsored transaction:

client.tsx

import openfort from "./openfortConfig"
// This example assumes you have already checked that Openfort 'embeddedState' is 
// `ready` and the user is `authenticated`
const provider = await openfort.getEthereumProvider({
      policy: 'pol_...',
    }

Then, using the provider's request method, send a eth_sendTransaction JSON-RPC to the wallet. In the params array, include as the first entry an object containing the transaction's parameters, such as to, value, data, gasLimit, maxPriorityFeePerGas, maxFeePerGas, and gasPrice.

const transactionRequest = {
  to: '0xRecipientAddress',
  value: 100000,
};
const txHash = await provider.request({
  method: 'eth_sendTransaction',
  params: [transactionRequest],
});

See these docs for the parameters that can be passed in eth_sendTransaction.

You do not need to specify from as we populate it from the user's connected wallet, and you can pass either a number, bigint, or a hexadecimal string into the value parameter.

Popular web3 libraries provide methods for sending transactions:

Library	Method
Ethers	Use the signer's `sendTransaction` method.
Wagmi	Use the `useSendTransaction` hook.
Viem	`sendTransaction` action

Smart Contracts#

Calling a smart contract is a special case of sending a transaction. To call a smart contract, you should send a transaction with the following parameters:

to: the address of the smart contract to call
data: the encoded function call data
value: any value to send (for payable functions)

To prepare the calldata for a smart contract interaction, we recommend using viem's encodeFunctionData method, like so:

import { encodeFunctionData } from 'viem';
const data = encodeFunctionData({
  abi: contractAbi,
  functionName: 'methodName',
  args: [arg1, arg2]
});

You can then send a transaction from the wallet as normal, and pass the calldata in the data field of the transaction request:

const transactionRequest = {
  to: '0xTheContractAddress',
  data: data,
  value: 100000, // Only necessary for payable methods
};
const txHash = await provider.request({
  method: 'eth_sendTransaction',
  params: [transactionRequest]
});

Batched transactions#

Smart wallets support sending a batch of transactions in a single, atomic submission to the network.

To send a batched transactions with a smart wallet, call the wallet_sendCalls method with a calls array the transactions to batch together.

As an example, you might batch together a transaction to approve a USDC spender and to transfer USDC like so:

const transactionRequest = {
  to: '0xTheContractAddress',
  data: data,
  value: 100000, // Only necessary for payable methods
};
const txHash = await provider.request({
  method: 'wallet_sendCalls',
  params: [
    {
      calls: [
        // Approve transaction
        {
          to: USDC_ADDRESS,
          data: encodeFunctionData({
            abi: USDC_ABI,
            functionName: 'approve',
            args: ['insert-spender-address', BigInt(1e6)],
          }),
        },
        // Transfer transaction
        {
          to: USDC_ADDRESS,
          data: encodeFunctionData({
            abi: USDC_ABI,
            functionName: 'transfer',
            args: ['insert-recipient-address', BigInt(1e6)],
          }),
        },
      ],
    },
  ],
});

Popular web3 libraries provide methods for sending batched transactions:

Library	Method
Wagmi	Use the `useWriteContracts` hook.
Viem	`sendCalls` action

Examples#

NextJS Sample

An integration with Google OAuth using Firebase Auth as a third party auth provider to create a non-custodial embedded signer.

Unity Sample Android

An integration with Google Play Games using Firebase Auth as a third party auth provider to create a non-custodial embedded signer.

Unity Sample WebGL

An integration with Openfort Auth with non-custodial embedded signer.