Class WebTaker

The WebTaker class extends the functionalities of the Trader class and is designed specifically for gRPC-web clients like browsers and React apps. It provides the capability to send and handle RFQs in environments where bidirectional streaming over gRPC is not available.

Hierarchy (view full)

Trader
- WebTaker

Constructors

constructor

new WebTaker(args): WebTaker
Constructs a new WebTaker instance with the given trading functionalities.
Parameters
- args: TraderConstructorArgs
  Constructor arguments for the Trader, including GRPC clients and account details.
Returns WebTaker
Overrides Trader.constructor
- Defined in src/entities/trader/web-taker.ts:17

Properties

account

account: Account

authClient

authClient: PromiseClient<{
    methods: {
        authenticate: {
            I: typeof Empty;
            O: typeof H160;
            kind: Unary;
            name: "Authenticate";
        };
        geofenced: {
            I: typeof Empty;
            O: typeof BoolValue;
            kind: Unary;
            name: "Geofenced";
        };
        nonce: {
            I: typeof Empty;
            O: typeof NonceText;
            kind: Unary;
            name: "Nonce";
        };
        session: {
            I: typeof Empty;
            O: typeof SiweSession;
            kind: Unary;
            name: "Session";
        };
        signOut: {
            I: typeof Empty;
            O: typeof Empty;
            kind: Unary;
            name: "SignOut";
        };
        verify: {
            I: typeof VerifyText;
            O: typeof H160;
            kind: Unary;
            name: "Verify";
        };
    };
    typeName: "valorem.trade.v1.Auth";
}>

Type declaration

Readonly methods: {
    authenticate: {
        I: typeof Empty;
        O: typeof H160;
        kind: Unary;
        name: "Authenticate";
    };
    geofenced: {
        I: typeof Empty;
        O: typeof BoolValue;
        kind: Unary;
        name: "Geofenced";
    };
    nonce: {
        I: typeof Empty;
        O: typeof NonceText;
        kind: Unary;
        name: "Nonce";
    };
    session: {
        I: typeof Empty;
        O: typeof SiweSession;
        kind: Unary;
        name: "Session";
    };
    signOut: {
        I: typeof Empty;
        O: typeof Empty;
        kind: Unary;
        name: "SignOut";
    };
    verify: {
        I: typeof VerifyText;
        O: typeof H160;
        kind: Unary;
        name: "Verify";
    };
}
- Readonly authenticate: {
      I: typeof Empty;
      O: typeof H160;
      kind: Unary;
      name: "Authenticate";
  }
  Used to check if a given connection is authenticated, returns the address which is authenticated for a nonce cookie
  
  Generated
  from rpc valorem.trade.v1.Auth.Authenticate
  - Readonly I: typeof Empty
  - Readonly O: typeof H160
  - Readonly kind: Unary
  - Readonly name: "Authenticate"
- Readonly geofenced: {
      I: typeof Empty;
      O: typeof BoolValue;
      kind: Unary;
      name: "Geofenced";
  }
  Used to check if a given connection is geofenced. If access is restricted, returns true, otherwise false.
  
  Generated
  from rpc valorem.trade.v1.Auth.Geofenced
  - Readonly I: typeof Empty
  - Readonly O: typeof BoolValue
  - Readonly kind: Unary
  - Readonly name: "Geofenced"
- Readonly nonce: {
      I: typeof Empty;
      O: typeof NonceText;
      kind: Unary;
      name: "Nonce";
  }
  Returns an EIP-4361 nonce for session and invalidates existing session
  
  Generated
  from rpc valorem.trade.v1.Auth.Nonce
  - Readonly I: typeof Empty
  - Readonly O: typeof NonceText
  - Readonly kind: Unary
  - Readonly name: "Nonce"
- Readonly session: {
      I: typeof Empty;
      O: typeof SiweSession;
      kind: Unary;
      name: "Session";
  }
  Returns the SIWE Session for the request's sessionId
  
  Generated
  from rpc valorem.trade.v1.Auth.Session
  - Readonly I: typeof Empty
  - Readonly O: typeof SiweSession
  - Readonly kind: Unary
  - Readonly name: "Session"
- Readonly signOut: {
      I: typeof Empty;
      O: typeof Empty;
      kind: Unary;
      name: "SignOut";
  }
  Invalidates the session for the request's sessionId
  
  Generated
  from rpc valorem.trade.v1.Auth.SignOut
  - Readonly I: typeof Empty
  - Readonly O: typeof Empty
  - Readonly kind: Unary
  - Readonly name: "SignOut"
- Readonly verify: {
      I: typeof VerifyText;
      O: typeof H160;
      kind: Unary;
      name: "Verify";
  }
  Verifies the SignedMessage is valid and returns the verified address
  
  Generated
  from rpc valorem.trade.v1.Auth.Verify
  - Readonly I: typeof VerifyText
  - Readonly O: typeof H160
  - Readonly kind: Unary
  - Readonly name: "Verify"
Readonly typeName: "valorem.trade.v1.Auth"

authenticated

authenticated: boolean = false

chain

chain: Chain

clearinghouse

clearinghouse: ClearinghouseContract

publicClient

publicClient: PublicClient

rfqClient

rfqClient: PromiseClient<{
    methods: {
        maker: {
            I: typeof QuoteResponse;
            O: typeof QuoteRequest;
            kind: BiDiStreaming;
            name: "Maker";
        };
        taker: {
            I: typeof QuoteRequest;
            O: typeof QuoteResponse;
            kind: BiDiStreaming;
            name: "Taker";
        };
        webTaker: {
            I: typeof QuoteRequest;
            O: typeof QuoteResponse;
            kind: ServerStreaming;
            name: "WebTaker";
        };
    };
    typeName: "valorem.trade.v1.RFQ";
}>

Type declaration

Readonly methods: {
    maker: {
        I: typeof QuoteResponse;
        O: typeof QuoteRequest;
        kind: BiDiStreaming;
        name: "Maker";
    };
    taker: {
        I: typeof QuoteRequest;
        O: typeof QuoteResponse;
        kind: BiDiStreaming;
        name: "Taker";
    };
    webTaker: {
        I: typeof QuoteRequest;
        O: typeof QuoteResponse;
        kind: ServerStreaming;
        name: "WebTaker";
    };
}
- Readonly maker: {
      I: typeof QuoteResponse;
      O: typeof QuoteRequest;
      kind: BiDiStreaming;
      name: "Maker";
  }
  Send quotes to takers via a stream of QuoteResponse messages and receive a stream of QuoteRequest messages.
  
  Generated
  from rpc valorem.trade.v1.RFQ.Maker
  - Readonly I: typeof QuoteResponse
  - Readonly O: typeof QuoteRequest
  - Readonly kind: BiDiStreaming
  - Readonly name: "Maker"
- Readonly taker: {
      I: typeof QuoteRequest;
      O: typeof QuoteResponse;
      kind: BiDiStreaming;
      name: "Taker";
  }
  Request quotes from makers via a stream of QuoteRequest messages and receive a stream of QuoteResponse messages.
  
  Generated
  from rpc valorem.trade.v1.RFQ.Taker
  - Readonly I: typeof QuoteRequest
  - Readonly O: typeof QuoteResponse
  - Readonly kind: BiDiStreaming
  - Readonly name: "Taker"
- Readonly webTaker: {
      I: typeof QuoteRequest;
      O: typeof QuoteResponse;
      kind: ServerStreaming;
      name: "WebTaker";
  }
  Request quotes from makers via a single QuoteRequest message and receive a stream of QuoteResponse messages for use by gRPC-web clients.
  
  Generated
  from rpc valorem.trade.v1.RFQ.WebTaker
  - Readonly I: typeof QuoteRequest
  - Readonly O: typeof QuoteResponse
  - Readonly kind: ServerStreaming
  - Readonly name: "WebTaker"
Readonly typeName: "valorem.trade.v1.RFQ"

seaport

seaport: SeaportContract

walletClient

walletClient: {
    account: Account;
    addChain: ((args) => Promise<void>);
    batch?: {
        multicall?: boolean | {
            batchSize?: number;
            wait?: number;
        };
    };
    cacheTime: number;
    chain: Chain;
    deployContract: (<const TAbi, TChainOverride>(args) => Promise<`0x${string}`>);
    extend: (<const client>(fn) => Client<Transport, Chain, Account, WalletRpcSchema, {
        [K in string | number | symbol]: client[K]
    } & WalletActions<Chain, Account>>);
    getAddresses: (() => Promise<GetAddressesReturnType>);
    getChainId: (() => Promise<number>);
    getPermissions: (() => Promise<GetPermissionsReturnType>);
    key: string;
    name: string;
    pollingInterval: number;
    prepareTransactionRequest: (<TChainOverride>(args) => Promise<PrepareTransactionRequestReturnType>);
    request: EIP1193RequestFn<WalletRpcSchema>;
    requestAddresses: (() => Promise<RequestAddressesReturnType>);
    requestPermissions: ((args) => Promise<RequestPermissionsReturnType>);
    sendRawTransaction: ((args) => Promise<`0x${string}`>);
    sendTransaction: (<TChainOverride>(args) => Promise<`0x${string}`>);
    signMessage: ((args) => Promise<`0x${string}`>);
    signTransaction: (<TChainOverride>(args) => Promise<`0x${string}`>);
    signTypedData: (<const TTypedData, TPrimaryType>(args) => Promise<`0x${string}`>);
    switchChain: ((args) => Promise<void>);
    transport: TransportConfig<string, EIP1193RequestFn> & Record<string, any>;
    type: string;
    uid: string;
    watchAsset: ((args) => Promise<boolean>);
    writeContract: (<const TAbi, TFunctionName, TChainOverride>(args) => Promise<`0x${string}`>);
}

Type declaration

account: Account
The Account of the Client.

addChain: ((args) => Promise<void>)

Adds an EVM chain to the wallet.

Docs: https://viem.sh/docs/actions/wallet/addChain.html
JSON-RPC Methods: eth_addEthereumChain

Param: args

AddChainParameters

Example

import { createWalletClient, custom } from 'viem'
import { optimism } from 'viem/chains'

const client = createWalletClient({
  transport: custom(window.ethereum),
})
await client.addChain({ chain: optimism })

(args): Promise<void>

Adds an EVM chain to the wallet.

Docs: https://viem.sh/docs/actions/wallet/addChain.html
JSON-RPC Methods: eth_addEthereumChain

Parameters

args: AddChainParameters
AddChainParameters

Returns Promise<void>

Example

import { createWalletClient, custom } from 'viem'
import { optimism } from 'viem/chains'

const client = createWalletClient({
  transport: custom(window.ethereum),
})
await client.addChain({ chain: optimism })

Optional batch?: {
    multicall?: boolean | {
        batchSize?: number;
        wait?: number;
    };
}
Flags for batch settings.
- Optional multicall?: boolean | {
  batchSize?: number;
  wait?: number;
  }
  Toggle to enable eth_call multicall aggregation.
cacheTime: number
Time (in ms) that cached data will remain in memory.
chain: Chain
Chain for the client.
deployContract: (<const TAbi, TChainOverride>(args) => Promise<`0x${string}`>)
Deploys a contract to the network, given bytecode and constructor arguments.
- Docs: https://viem.sh/docs/contract/deployContract.html
- Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/contracts/deploying-contracts
Param: args
DeployContractParameters

Returns
The Transaction hash. DeployContractReturnType

Example
```
import { createWalletClient, http } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  account: privateKeyToAccount('0x…'),
  chain: mainnet,
  transport: http(),
})
const hash = await client.deployContract({
  abi: [],
  account: '0x…,
  bytecode: '0x608060405260405161083e38038061083e833981016040819052610...',
})
```
- - <const TAbi, TChainOverride>(args): Promise<`0x${string}`>
  - Deploys a contract to the network, given bytecode and constructor arguments.
    - Docs: https://viem.sh/docs/contract/deployContract.html
    - Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/contracts/deploying-contracts
    Type Parameters
    - const TAbi extends Abi | readonly unknown[]
    - TChainOverride extends undefined | Chain = undefined
    Parameters
    - args: DeployContractParameters<TAbi, Chain, Account, TChainOverride>
      DeployContractParameters
    Returns Promise<`0x${string}`>
    The Transaction hash. DeployContractReturnType
    Example
```
import { createWalletClient, http } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  account: privateKeyToAccount('0x…'),
  chain: mainnet,
  transport: http(),
})
const hash = await client.deployContract({
  abi: [],
  account: '0x…,
  bytecode: '0x608060405260405161083e38038061083e833981016040819052610...',
})
```
extend: (<const client>(fn) => Client<Transport, Chain, Account, WalletRpcSchema, {
[K in string | number | symbol]: client[K]
} & WalletActions<Chain, Account>>)
- - <const client>(fn): Client<Transport, Chain, Account, WalletRpcSchema, {
    [K in string | number | symbol]: client[K]
    } & WalletActions<Chain, Account>>
  - Type Parameters
    - const client extends {
          account?: undefined;
          batch?: undefined;
          cacheTime?: undefined;
          chain?: undefined;
          key?: undefined;
          name?: undefined;
          pollingInterval?: undefined;
          request?: undefined;
          transport?: undefined;
          type?: undefined;
          uid?: undefined;
      } & Partial<ExtendableProtectedActions>
    Parameters
    - fn: ((client) => client)
      (client): client
      Parameters
      client: Client<Transport, Chain, Account, WalletRpcSchema, WalletActions<Chain, Account>>
      Returns client
    Returns Client<Transport, Chain, Account, WalletRpcSchema, {
    [K in string | number | symbol]: client[K]
    } & WalletActions<Chain, Account>>
getAddresses: (() => Promise<GetAddressesReturnType>)
Returns a list of account addresses owned by the wallet or client.
- Docs: https://viem.sh/docs/actions/wallet/getAddresses.html
- JSON-RPC Methods: eth_accounts
Returns
List of account addresses owned by the wallet or client. GetAddressesReturnType

Example
```
import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const accounts = await client.getAddresses()
```
- - (): Promise<GetAddressesReturnType>
  - Returns a list of account addresses owned by the wallet or client.
    - Docs: https://viem.sh/docs/actions/wallet/getAddresses.html
    - JSON-RPC Methods: eth_accounts
    Returns Promise<GetAddressesReturnType>
    List of account addresses owned by the wallet or client. GetAddressesReturnType
    Example
```
import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const accounts = await client.getAddresses()
```

getChainId: (() => Promise<number>)

Returns the chain ID associated with the current network.

Docs: https://viem.sh/docs/actions/public/getChainId.html
JSON-RPC Methods: eth_chainId

Returns

The current chain ID. GetChainIdReturnType

Example

import { createWalletClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const chainId = await client.getChainId()
// 1

(): Promise<number>

Returns the chain ID associated with the current network.

Docs: https://viem.sh/docs/actions/public/getChainId.html
JSON-RPC Methods: eth_chainId

Returns Promise<number>

The current chain ID. GetChainIdReturnType

Example

import { createWalletClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const chainId = await client.getChainId()
// 1

getPermissions: (() => Promise<GetPermissionsReturnType>)
Gets the wallets current permissions.
- Docs: https://viem.sh/docs/actions/wallet/getPermissions.html
- JSON-RPC Methods: wallet_getPermissions
Returns
The wallet permissions. GetPermissionsReturnType

Example
```
import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const permissions = await client.getPermissions()
```
- - (): Promise<GetPermissionsReturnType>
  - Gets the wallets current permissions.
    - Docs: https://viem.sh/docs/actions/wallet/getPermissions.html
    - JSON-RPC Methods: wallet_getPermissions
    Returns Promise<GetPermissionsReturnType>
    The wallet permissions. GetPermissionsReturnType
    Example
```
import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const permissions = await client.getPermissions()
```
key: string
A key for the client.
name: string
A name for the client.
pollingInterval: number
Frequency (in ms) for polling enabled actions & events. Defaults to 4_000 milliseconds.

prepareTransactionRequest: (<TChainOverride>(args) => Promise<PrepareTransactionRequestReturnType>)

Prepares a transaction request for signing.

Docs: https://viem.sh/docs/actions/wallet/prepareTransactionRequest.html

Param: args

PrepareTransactionRequestParameters

Returns

The transaction request. PrepareTransactionRequestReturnType

Example

import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const request = await client.prepareTransactionRequest({
  account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
  to: '0x0000000000000000000000000000000000000000',
  value: 1n,
})

Example

// Account Hoisting
import { createWalletClient, http } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  account: privateKeyToAccount('0x…'),
  chain: mainnet,
  transport: custom(window.ethereum),
})
const request = await client.prepareTransactionRequest({
  to: '0x0000000000000000000000000000000000000000',
  value: 1n,
})

<TChainOverride>(args): Promise<PrepareTransactionRequestReturnType>

Prepares a transaction request for signing.

Docs: https://viem.sh/docs/actions/wallet/prepareTransactionRequest.html

Type Parameters

TChainOverride extends undefined | Chain = undefined

Parameters

args: PrepareTransactionRequestParameters<Chain, Account, TChainOverride>
PrepareTransactionRequestParameters

Returns Promise<PrepareTransactionRequestReturnType>

The transaction request. PrepareTransactionRequestReturnType

Example

import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const request = await client.prepareTransactionRequest({
  account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
  to: '0x0000000000000000000000000000000000000000',
  value: 1n,
})

Example

// Account Hoisting
import { createWalletClient, http } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  account: privateKeyToAccount('0x…'),
  chain: mainnet,
  transport: custom(window.ethereum),
})
const request = await client.prepareTransactionRequest({
  to: '0x0000000000000000000000000000000000000000',
  value: 1n,
})

request: EIP1193RequestFn<WalletRpcSchema>
Request function wrapped with friendly error handling
requestAddresses: (() => Promise<RequestAddressesReturnType>)
Requests a list of accounts managed by a wallet.
- Docs: https://viem.sh/docs/actions/wallet/requestAddresses.html
- JSON-RPC Methods: eth_requestAccounts
Sends a request to the wallet, asking for permission to access the user's accounts. After the user accepts the request, it will return a list of accounts (addresses).

This API can be useful for dapps that need to access the user's accounts in order to execute transactions or interact with smart contracts.
Returns
List of accounts managed by a wallet RequestAddressesReturnType

Example
```
import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const accounts = await client.requestAddresses()
```
- - (): Promise<RequestAddressesReturnType>
  - Requests a list of accounts managed by a wallet.
    - Docs: https://viem.sh/docs/actions/wallet/requestAddresses.html
    - JSON-RPC Methods: eth_requestAccounts
    Sends a request to the wallet, asking for permission to access the user's accounts. After the user accepts the request, it will return a list of accounts (addresses).
    
    This API can be useful for dapps that need to access the user's accounts in order to execute transactions or interact with smart contracts.
    Returns Promise<RequestAddressesReturnType>
    List of accounts managed by a wallet RequestAddressesReturnType
    Example
```
import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const accounts = await client.requestAddresses()
```
requestPermissions: ((args) => Promise<RequestPermissionsReturnType>)
Requests permissions for a wallet.
- Docs: https://viem.sh/docs/actions/wallet/requestPermissions.html
- JSON-RPC Methods: wallet_requestPermissions
Param: args
RequestPermissionsParameters

Returns
The wallet permissions. RequestPermissionsReturnType

Example
```
import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const permissions = await client.requestPermissions({
  eth_accounts: {}
})
```
- - (args): Promise<RequestPermissionsReturnType>
  - Requests permissions for a wallet.
    - Docs: https://viem.sh/docs/actions/wallet/requestPermissions.html
    - JSON-RPC Methods: wallet_requestPermissions
    Parameters
    - args: {
      eth_accounts: Record<string, any>;
      }
      RequestPermissionsParameters
      
      eth_accounts: Record<string, any>
    Returns Promise<RequestPermissionsReturnType>
    The wallet permissions. RequestPermissionsReturnType
    Example
```
import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const permissions = await client.requestPermissions({
  eth_accounts: {}
})
```

sendRawTransaction: ((args) => Promise<`0x${string}`>)

Sends a signed transaction to the network

Docs: https://viem.sh/docs/actions/wallet/sendRawTransaction.html
JSON-RPC Method: eth_sendRawTransaction

Param: client

Client to use

Param: parameters

SendRawTransactionParameters

Returns

The transaction hash. SendRawTransactionReturnType

Example

import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'
import { sendRawTransaction } from 'viem/wallet'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})

const hash = await client.sendRawTransaction({
  serializedTransaction: '0x02f850018203118080825208808080c080a04012522854168b27e5dc3d5839bab5e6b39e1a0ffd343901ce1622e3d64b48f1a04e00902ae0502c4728cbf12156290df99c3ed7de85b1dbfe20b5c36931733a33'
})

(args): Promise<`0x${string}`>

Sends a signed transaction to the network

Docs: https://viem.sh/docs/actions/wallet/sendRawTransaction.html
JSON-RPC Method: eth_sendRawTransaction

Parameters

args: SendRawTransactionParameters

Returns Promise<`0x${string}`>

The transaction hash. SendRawTransactionReturnType

Example

import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'
import { sendRawTransaction } from 'viem/wallet'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})

const hash = await client.sendRawTransaction({
  serializedTransaction: '0x02f850018203118080825208808080c080a04012522854168b27e5dc3d5839bab5e6b39e1a0ffd343901ce1622e3d64b48f1a04e00902ae0502c4728cbf12156290df99c3ed7de85b1dbfe20b5c36931733a33'
})

sendTransaction: (<TChainOverride>(args) => Promise<`0x${string}`>)

Creates, signs, and sends a new transaction to the network.

Docs: https://viem.sh/docs/actions/wallet/sendTransaction.html
Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/transactions/sending-transactions
JSON-RPC Methods:
- JSON-RPC Accounts: eth_sendTransaction
- Local Accounts: eth_sendRawTransaction

Param: args

SendTransactionParameters

Returns

The Transaction hash. SendTransactionReturnType

Example

import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const hash = await client.sendTransaction({
  account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
  to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
  value: 1000000000000000000n,
})

Example

// Account Hoisting
import { createWalletClient, http } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  account: privateKeyToAccount('0x…'),
  chain: mainnet,
  transport: http(),
})
const hash = await client.sendTransaction({
  to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
  value: 1000000000000000000n,
})

<TChainOverride>(args): Promise<`0x${string}`>

Creates, signs, and sends a new transaction to the network.

Docs: https://viem.sh/docs/actions/wallet/sendTransaction.html
Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/transactions/sending-transactions
JSON-RPC Methods:
- JSON-RPC Accounts: eth_sendTransaction
- Local Accounts: eth_sendRawTransaction

Type Parameters

TChainOverride extends undefined | Chain = undefined

Parameters

args: SendTransactionParameters<Chain, Account, TChainOverride>
SendTransactionParameters

Returns Promise<`0x${string}`>

The Transaction hash. SendTransactionReturnType

Example

import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const hash = await client.sendTransaction({
  account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
  to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
  value: 1000000000000000000n,
})

Example

// Account Hoisting
import { createWalletClient, http } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  account: privateKeyToAccount('0x…'),
  chain: mainnet,
  transport: http(),
})
const hash = await client.sendTransaction({
  to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
  value: 1000000000000000000n,
})

signMessage: ((args) => Promise<`0x${string}`>)

Calculates an Ethereum-specific signature in EIP-191 format: keccak256("\x19Ethereum Signed Message:\n" + len(message) + message)).

Docs: https://viem.sh/docs/actions/wallet/signMessage.html
JSON-RPC Methods:
- JSON-RPC Accounts: personal_sign
- Local Accounts: Signs locally. No JSON-RPC request.

With the calculated signature, you can:

use verifyMessage to verify the signature,
use recoverMessageAddress to recover the signing address from a signature.

Param: args

SignMessageParameters

Returns

The signed message. SignMessageReturnType

Example

import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const signature = await client.signMessage({
  account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
  message: 'hello world',
})

Example

// Account Hoisting
import { createWalletClient, http } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  account: privateKeyToAccount('0x…'),
  chain: mainnet,
  transport: http(),
})
const signature = await client.signMessage({
  message: 'hello world',
})

(args): Promise<`0x${string}`>

Calculates an Ethereum-specific signature in EIP-191 format: keccak256("\x19Ethereum Signed Message:\n" + len(message) + message)).

Docs: https://viem.sh/docs/actions/wallet/signMessage.html
JSON-RPC Methods:
- JSON-RPC Accounts: personal_sign
- Local Accounts: Signs locally. No JSON-RPC request.

With the calculated signature, you can:

use verifyMessage to verify the signature,
use recoverMessageAddress to recover the signing address from a signature.

Parameters

args: SignMessageParameters<Account>
SignMessageParameters

Returns Promise<`0x${string}`>

The signed message. SignMessageReturnType

Example

import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const signature = await client.signMessage({
  account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
  message: 'hello world',
})

Example

// Account Hoisting
import { createWalletClient, http } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  account: privateKeyToAccount('0x…'),
  chain: mainnet,
  transport: http(),
})
const signature = await client.signMessage({
  message: 'hello world',
})

signTransaction: (<TChainOverride>(args) => Promise<`0x${string}`>)

Signs a transaction.

Docs: https://viem.sh/docs/actions/wallet/signTransaction.html
JSON-RPC Methods:
- JSON-RPC Accounts: eth_signTransaction
- Local Accounts: Signs locally. No JSON-RPC request.

Param: args

SignTransactionParameters

Returns

The signed message. SignTransactionReturnType

Example

import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const request = await client.prepareTransactionRequest({
  account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
  to: '0x0000000000000000000000000000000000000000',
  value: 1n,
})
const signature = await client.signTransaction(request)

Example

// Account Hoisting
import { createWalletClient, http } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  account: privateKeyToAccount('0x…'),
  chain: mainnet,
  transport: custom(window.ethereum),
})
const request = await client.prepareTransactionRequest({
  to: '0x0000000000000000000000000000000000000000',
  value: 1n,
})
const signature = await client.signTransaction(request)

<TChainOverride>(args): Promise<`0x${string}`>

Signs a transaction.

Docs: https://viem.sh/docs/actions/wallet/signTransaction.html
JSON-RPC Methods:
- JSON-RPC Accounts: eth_signTransaction
- Local Accounts: Signs locally. No JSON-RPC request.

Type Parameters

TChainOverride extends undefined | Chain = undefined

Parameters

args: SignTransactionParameters<Chain, Account, TChainOverride>
SignTransactionParameters

Returns Promise<`0x${string}`>

The signed message. SignTransactionReturnType

Example

import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const request = await client.prepareTransactionRequest({
  account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
  to: '0x0000000000000000000000000000000000000000',
  value: 1n,
})
const signature = await client.signTransaction(request)

Example

// Account Hoisting
import { createWalletClient, http } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  account: privateKeyToAccount('0x…'),
  chain: mainnet,
  transport: custom(window.ethereum),
})
const request = await client.prepareTransactionRequest({
  to: '0x0000000000000000000000000000000000000000',
  value: 1n,
})
const signature = await client.signTransaction(request)

signTypedData: (<const TTypedData, TPrimaryType>(args) => Promise<`0x${string}`>)

Signs typed data and calculates an Ethereum-specific signature in EIP-191 format: keccak256("\x19Ethereum Signed Message:\n" + len(message) + message)).

Docs: https://viem.sh/docs/actions/wallet/signTypedData.html
JSON-RPC Methods:
- JSON-RPC Accounts: eth_signTypedData_v4
- Local Accounts: Signs locally. No JSON-RPC request.

Param: client

Client to use

Param: args

SignTypedDataParameters

Returns

The signed data. SignTypedDataReturnType

Example

import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const signature = await client.signTypedData({
  account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
  domain: {
    name: 'Ether Mail',
    version: '1',
    chainId: 1,
    verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
  },
  types: {
    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!',
  },
})

Example

// Account Hoisting
import { createWalletClient, http } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  account: privateKeyToAccount('0x…'),
  chain: mainnet,
  transport: http(),
})
const signature = await client.signTypedData({
  domain: {
    name: 'Ether Mail',
    version: '1',
    chainId: 1,
    verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
  },
  types: {
    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!',
  },
})

- <const TTypedData, TPrimaryType>(args): Promise<`0x${string}`>
- Signs typed data and calculates an Ethereum-specific signature in EIP-191 format: keccak256("\x19Ethereum Signed Message:\n" + len(message) + message)).
  - Docs: https://viem.sh/docs/actions/wallet/signTypedData.html
  - JSON-RPC Methods:
    - JSON-RPC Accounts: eth_signTypedData_v4
    - Local Accounts: Signs locally. No JSON-RPC request.
  Type Parameters
  - const TTypedData extends {
        address: undefined;
        bool: undefined;
        bytes: undefined;
        bytes1: undefined;
        bytes10: undefined;
        bytes11: undefined;
        bytes12: undefined;
        bytes13: undefined;
        bytes14: undefined;
        bytes15: undefined;
        bytes16: undefined;
        bytes17: undefined;
        bytes18: undefined;
        bytes19: undefined;
        bytes2: undefined;
        bytes20: undefined;
        bytes21: undefined;
        bytes22: undefined;
        bytes23: undefined;
        bytes24: undefined;
        bytes25: undefined;
        bytes26: undefined;
        bytes27: undefined;
        bytes28: undefined;
        bytes29: undefined;
        bytes3: undefined;
        bytes30: undefined;
        bytes31: undefined;
        bytes32: undefined;
        bytes4: undefined;
        bytes5: undefined;
        bytes6: undefined;
        bytes7: undefined;
        bytes8: undefined;
        bytes9: undefined;
        int104: undefined;
        int112: undefined;
        int120: undefined;
        int128: undefined;
        int136: undefined;
        int144: undefined;
        int152: undefined;
        int16: undefined;
        int160: undefined;
        int168: undefined;
        int176: undefined;
        int184: undefined;
        int192: undefined;
        int200: undefined;
        int208: undefined;
        int216: undefined;
        int224: undefined;
        int232: undefined;
        int24: undefined;
        int240: undefined;
        int248: undefined;
        int256: undefined;
        int32: undefined;
        int40: undefined;
        int48: undefined;
        int56: undefined;
        int64: undefined;
        int72: undefined;
        int8: undefined;
        int80: undefined;
        int88: undefined;
        int96: undefined;
        string: undefined;
        uint104: undefined;
        uint112: undefined;
        uint120: undefined;
        uint128: undefined;
        uint136: undefined;
        uint144: undefined;
        uint152: undefined;
        uint16: undefined;
        uint160: undefined;
        uint168: undefined;
        uint176: undefined;
        uint184: undefined;
        uint192: undefined;
        uint200: undefined;
        uint208: undefined;
        uint216: undefined;
        uint224: undefined;
        uint232: undefined;
        uint24: undefined;
        uint240: undefined;
        uint248: undefined;
        uint256: undefined;
        uint32: undefined;
        uint40: undefined;
        uint48: undefined;
        uint56: undefined;
        uint64: undefined;
        uint72: undefined;
        uint8: undefined;
        uint80: undefined;
        uint88: undefined;
        uint96: undefined;
    } | {
        [key: string]: unknown;
    }
  - TPrimaryType extends string
  Parameters
  - args: SignTypedDataParameters<TTypedData, TPrimaryType, Account>
    SignTypedDataParameters
  Returns Promise<`0x${string}`>
  The signed data. SignTypedDataReturnType
  Example
```
import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const signature = await client.signTypedData({
  account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
  domain: {
    name: 'Ether Mail',
    version: '1',
    chainId: 1,
    verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
  },
  types: {
    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!',
  },
})
```
  Example
```
// Account Hoisting
import { createWalletClient, http } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  account: privateKeyToAccount('0x…'),
  chain: mainnet,
  transport: http(),
})
const signature = await client.signTypedData({
  domain: {
    name: 'Ether Mail',
    version: '1',
    chainId: 1,
    verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
  },
  types: {
    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!',
  },
})
```

switchChain: ((args) => Promise<void>)

Switch the target chain in a wallet.

Docs: https://viem.sh/docs/actions/wallet/switchChain.html
JSON-RPC Methods: eth_switchEthereumChain

Param: args

SwitchChainParameters

Example

import { createWalletClient, custom } from 'viem'
import { mainnet, optimism } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
await client.switchChain({ id: optimism.id })

(args): Promise<void>

Switch the target chain in a wallet.

Docs: https://viem.sh/docs/actions/wallet/switchChain.html
JSON-RPC Methods: eth_switchEthereumChain

Parameters

args: SwitchChainParameters
SwitchChainParameters

Returns Promise<void>

Example

import { createWalletClient, custom } from 'viem'
import { mainnet, optimism } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
await client.switchChain({ id: optimism.id })

transport: TransportConfig<string, EIP1193RequestFn> & Record<string, any>
The RPC transport
type: string
The type of client.
uid: string
A unique ID for the client.

watchAsset: ((args) => Promise<boolean>)

Adds an EVM chain to the wallet.

Docs: https://viem.sh/docs/actions/wallet/watchAsset.html
JSON-RPC Methods: eth_switchEthereumChain

Param: args

WatchAssetParameters

Returns

Boolean indicating if the token was successfully added. WatchAssetReturnType

Example

import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const success = await client.watchAsset({
  type: 'ERC20',
  options: {
    address: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
    decimals: 18,
    symbol: 'WETH',
  },
})

(args): Promise<boolean>

Adds an EVM chain to the wallet.

Docs: https://viem.sh/docs/actions/wallet/watchAsset.html
JSON-RPC Methods: eth_switchEthereumChain

Parameters

args: WatchAssetParams
WatchAssetParameters

Returns Promise<boolean>

Boolean indicating if the token was successfully added. WatchAssetReturnType

Example

import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const success = await client.watchAsset({
  type: 'ERC20',
  options: {
    address: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
    decimals: 18,
    symbol: 'WETH',
  },
})

writeContract: (<const TAbi, TFunctionName, TChainOverride>(args) => Promise<`0x${string}`>)
Executes a write function on a contract.
- Docs: https://viem.sh/docs/contract/writeContract.html
- Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/contracts/writing-to-contracts
A "write" function on a Solidity contract modifies the state of the blockchain. These types of functions require gas to be executed, and hence a Transaction is needed to be broadcast in order to change the state.

Internally, uses a Wallet Client to call the sendTransaction action with ABI-encoded data.

Warning: The write internally sends a transaction – it does not validate if the contract write will succeed (the contract may throw an error). It is highly recommended to simulate the contract write with contract.simulate before you execute it.
Param: args
WriteContractParameters

Returns
A Transaction Hash. WriteContractReturnType

Example
```
import { createWalletClient, custom, parseAbi } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const hash = await client.writeContract({
  address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
  abi: parseAbi(['function mint(uint32 tokenId) nonpayable']),
  functionName: 'mint',
  args: [69420],
})
```
Example
```
// With Validation
import { createWalletClient, custom, parseAbi } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const { request } = await client.simulateContract({
  address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
  abi: parseAbi(['function mint(uint32 tokenId) nonpayable']),
  functionName: 'mint',
  args: [69420],
}
const hash = await client.writeContract(request)
```
- - <const TAbi, TFunctionName, TChainOverride>(args): Promise<`0x${string}`>
  - Executes a write function on a contract.
    - Docs: https://viem.sh/docs/contract/writeContract.html
    - Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/contracts/writing-to-contracts
    A "write" function on a Solidity contract modifies the state of the blockchain. These types of functions require gas to be executed, and hence a Transaction is needed to be broadcast in order to change the state.
    
    Internally, uses a Wallet Client to call the sendTransaction action with ABI-encoded data.
    
    Warning: The write internally sends a transaction – it does not validate if the contract write will succeed (the contract may throw an error). It is highly recommended to simulate the contract write with contract.simulate before you execute it.
    Type Parameters
    - const TAbi extends Abi | readonly unknown[]
    - TFunctionName extends string
    - TChainOverride extends undefined | Chain = undefined
    Parameters
    - args: WriteContractParameters<TAbi, TFunctionName, Chain, Account, TChainOverride>
      WriteContractParameters
    Returns Promise<`0x${string}`>
    A Transaction Hash. WriteContractReturnType
    Example
```
import { createWalletClient, custom, parseAbi } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const hash = await client.writeContract({
  address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
  abi: parseAbi(['function mint(uint32 tokenId) nonpayable']),
  functionName: 'mint',
  args: [69420],
})
```
    Example
```
// With Validation
import { createWalletClient, custom, parseAbi } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const { request } = await client.simulateContract({
  address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
  abi: parseAbi(['function mint(uint32 tokenId) nonpayable']),
  functionName: 'mint',
  args: [69420],
}
const hash = await client.writeContract(request)
```

Methods

acceptQuote

acceptQuote(__namedParameters): Promise<void>
Parameters
- __namedParameters: {
      quote: {
          chainId: undefined | number;
          makerAddress: `0x${string}`;
          order: {
              parameters: {
                  conduitKey: `0x${string}`;
                  consideration: {
                      endAmount: bigint;
                      identifierOrCriteria: bigint;
                      itemType: ItemType;
                      recipient: `0x${string}`;
                      startAmount: bigint;
                      token: `0x${string}`;
                  }[];
                  endTime: bigint;
                  offer: {
                      endAmount: bigint;
                      identifierOrCriteria: bigint;
                      itemType: ItemType;
                      startAmount: bigint;
                      token: `0x${string}`;
                  }[];
                  offerer: `0x${string}`;
                  orderType: OrderType;
                  salt: bigint;
                  startTime: bigint;
                  totalOriginalConsiderationItems: bigint;
                  zone: `0x${string}`;
                  zoneHash: `0x${string}`;
              };
              signature: `0x${string}`;
          };
          seaportAddress: `0x${string}`;
          ulid: bigint;
      };
  }
  - quote: {
        chainId: undefined | number;
        makerAddress: `0x${string}`;
        order: {
            parameters: {
                conduitKey: `0x${string}`;
                consideration: {
                    endAmount: bigint;
                    identifierOrCriteria: bigint;
                    itemType: ItemType;
                    recipient: `0x${string}`;
                    startAmount: bigint;
                    token: `0x${string}`;
                }[];
                endTime: bigint;
                offer: {
                    endAmount: bigint;
                    identifierOrCriteria: bigint;
                    itemType: ItemType;
                    startAmount: bigint;
                    token: `0x${string}`;
                }[];
                offerer: `0x${string}`;
                orderType: OrderType;
                salt: bigint;
                startTime: bigint;
                totalOriginalConsiderationItems: bigint;
                zone: `0x${string}`;
                zoneHash: `0x${string}`;
            };
            signature: `0x${string}`;
        };
        seaportAddress: `0x${string}`;
        ulid: bigint;
    }
    - chainId: undefined | number
    - makerAddress: `0x${string}`
    - order: {
          parameters: {
              conduitKey: `0x${string}`;
              consideration: {
                  endAmount: bigint;
                  identifierOrCriteria: bigint;
                  itemType: ItemType;
                  recipient: `0x${string}`;
                  startAmount: bigint;
                  token: `0x${string}`;
              }[];
              endTime: bigint;
              offer: {
                  endAmount: bigint;
                  identifierOrCriteria: bigint;
                  itemType: ItemType;
                  startAmount: bigint;
                  token: `0x${string}`;
              }[];
              offerer: `0x${string}`;
              orderType: OrderType;
              salt: bigint;
              startTime: bigint;
              totalOriginalConsiderationItems: bigint;
              zone: `0x${string}`;
              zoneHash: `0x${string}`;
          };
          signature: `0x${string}`;
      }
      parameters: {
          conduitKey: `0x${string}`;
          consideration: {
              endAmount: bigint;
              identifierOrCriteria: bigint;
              itemType: ItemType;
              recipient: `0x${string}`;
              startAmount: bigint;
              token: `0x${string}`;
          }[];
          endTime: bigint;
          offer: {
              endAmount: bigint;
              identifierOrCriteria: bigint;
              itemType: ItemType;
              startAmount: bigint;
              token: `0x${string}`;
          }[];
          offerer: `0x${string}`;
          orderType: OrderType;
          salt: bigint;
          startTime: bigint;
          totalOriginalConsiderationItems: bigint;
          zone: `0x${string}`;
          zoneHash: `0x${string}`;
      }
      conduitKey: `0x${string}`
      consideration: {
          endAmount: bigint;
          identifierOrCriteria: bigint;
          itemType: ItemType;
          recipient: `0x${string}`;
          startAmount: bigint;
          token: `0x${string}`;
      }[]
      endTime: bigint
      offer: {
          endAmount: bigint;
          identifierOrCriteria: bigint;
          itemType: ItemType;
          startAmount: bigint;
          token: `0x${string}`;
      }[]
      offerer: `0x${string}`
      orderType: OrderType
      salt: bigint
      startTime: bigint
      totalOriginalConsiderationItems: bigint
      zone: `0x${string}`
      zoneHash: `0x${string}`
      signature: `0x${string}`
    - seaportAddress: `0x${string}`
    - ulid: bigint
Returns Promise<void>
Inherited from Trader.acceptQuote
- Defined in src/entities/trader/base-trader.ts:404

approveERC20

approveERC20(__namedParameters): Promise<void>
Contract Writes
Parameters
- __namedParameters: {
      amount: bigint;
      spender: `0x${string}`;
      tokenAddress: `0x${string}`;
  }
  - amount: bigint
  - spender: `0x${string}`
  - tokenAddress: `0x${string}`
Returns Promise<void>
Inherited from Trader.approveERC20
- Defined in src/entities/trader/base-trader.ts:372

checkAuthentication

checkAuthentication(): Promise<boolean>
Checks if the trader is currently authenticated.

Returns Promise<boolean>
- A promise indicating authentication status.
Inherited from Trader.checkAuthentication
- Defined in src/entities/trader/base-trader.ts:167

createAndSignMessage

createAndSignMessage(nonce): Promise<{
message: string;
signature: `0x${string}`;
}>
Creates and signs a SIWE message for authentication.
Parameters
- nonce: string
  The nonce to use in the message.
Returns Promise<{
message: string;
signature: `0x${string}`;
}>
- A promise with the message and its signature.
Inherited from Trader.createAndSignMessage
- Defined in src/entities/trader/base-trader.ts:209

createQuoteRequest

createQuoteRequest(__namedParameters): QuoteRequest
Creates a new quote request for trading options. This method is used to generate the request payload for an RFQ, specifying details such as the option ID, quantity, and other relevant parameters.
Parameters
- __namedParameters: {
  optionId: bigint;
  quantityToBuy: number;
  }
  - optionId: bigint
  - quantityToBuy: number
Returns QuoteRequest
Inherited from Trader.createQuoteRequest
- Defined in src/entities/trader/base-trader.ts:229

executeTransaction

executeTransaction(request): Promise<TransactionReceipt>
Executes a given transaction request. This method is crucial for submitting and confirming blockchain transactions as part of trading operations, such as option exercises, claim redemptions, and accepting quotes.
Parameters
- request: SimulatedTxRequest
  The simulated transaction request.
Returns Promise<TransactionReceipt>
- A promise with the transaction receipt.
Inherited from Trader.executeTransaction
- Defined in src/entities/trader/base-trader.ts:448

getNonce

getNonce(): Promise<string>
Retrieves a nonce for SIWE authentication.

Returns Promise<string>
- A promise that resolves to the nonce.
Inherited from Trader.getNonce
- Defined in src/entities/trader/base-trader.ts:156

hasEnoughERC20Allowance

hasEnoughERC20Allowance(__namedParameters): Promise<boolean>
Parameters
- __namedParameters: {
      amount: bigint;
      erc20: ERC20Contract;
      spender: Spender;
  }
  - amount: bigint
  - erc20: ERC20Contract
  - spender: Spender
Returns Promise<boolean>
Inherited from Trader.hasEnoughERC20Allowance
- Defined in src/entities/trader/base-trader.ts:324

hasEnoughERC20Balance

hasEnoughERC20Balance(__namedParameters): Promise<boolean>
Contract Reads
Parameters
- __namedParameters: {
  amount: bigint;
  erc20: ERC20Contract;
  }
  - amount: bigint
  - erc20: ERC20Contract
Returns Promise<boolean>
Inherited from Trader.hasEnoughERC20Balance
- Defined in src/entities/trader/base-trader.ts:313

openRFQStream

openRFQStream<TMethod>(__namedParameters): Promise<void>
Opens a stream for RFQs, continuously sending requests and handling responses. This method is a key part of the trading process, allowing the trader to interact with market makers and receive quotes for option trades.
Type Parameters
- TMethod extends "taker" | "webTaker"
Parameters
- __namedParameters: {
      method: TMethod;
      onQuoteResponse: ((quoteResponse) => void);
      options?: {
          signal?: AbortSignal;
          timeoutMs: number;
      };
      request: TMethod extends "webTaker"
          ? PartialMessage<QuoteRequest>
          : (() => AsyncIterable<PartialMessage<QuoteRequest>>);
  }
  - method: TMethod
  - onQuoteResponse: ((quoteResponse) => void)
    - (quoteResponse): void
      Parameters
      quoteResponse: {
          chainId: undefined | number;
          makerAddress: `0x${string}`;
          order: {
              parameters: {
                  conduitKey: `0x${string}`;
                  consideration: {
                      endAmount: bigint;
                      identifierOrCriteria: bigint;
                      itemType: ItemType;
                      recipient: `0x${string}`;
                      startAmount: bigint;
                      token: `0x${string}`;
                  }[];
                  endTime: bigint;
                  offer: {
                      endAmount: bigint;
                      identifierOrCriteria: bigint;
                      itemType: ItemType;
                      startAmount: bigint;
                      token: `0x${string}`;
                  }[];
                  offerer: `0x${string}`;
                  orderType: OrderType;
                  salt: bigint;
                  startTime: bigint;
                  totalOriginalConsiderationItems: bigint;
                  zone: `0x${string}`;
                  zoneHash: `0x${string}`;
              };
              signature: `0x${string}`;
          };
          seaportAddress: `0x${string}`;
          ulid: bigint;
      }
      chainId: undefined | number
      makerAddress: `0x${string}`
      order: {
          parameters: {
              conduitKey: `0x${string}`;
              consideration: {
                  endAmount: bigint;
                  identifierOrCriteria: bigint;
                  itemType: ItemType;
                  recipient: `0x${string}`;
                  startAmount: bigint;
                  token: `0x${string}`;
              }[];
              endTime: bigint;
              offer: {
                  endAmount: bigint;
                  identifierOrCriteria: bigint;
                  itemType: ItemType;
                  startAmount: bigint;
                  token: `0x${string}`;
              }[];
              offerer: `0x${string}`;
              orderType: OrderType;
              salt: bigint;
              startTime: bigint;
              totalOriginalConsiderationItems: bigint;
              zone: `0x${string}`;
              zoneHash: `0x${string}`;
          };
          signature: `0x${string}`;
      }
      parameters: {
          conduitKey: `0x${string}`;
          consideration: {
              endAmount: bigint;
              identifierOrCriteria: bigint;
              itemType: ItemType;
              recipient: `0x${string}`;
              startAmount: bigint;
              token: `0x${string}`;
          }[];
          endTime: bigint;
          offer: {
              endAmount: bigint;
              identifierOrCriteria: bigint;
              itemType: ItemType;
              startAmount: bigint;
              token: `0x${string}`;
          }[];
          offerer: `0x${string}`;
          orderType: OrderType;
          salt: bigint;
          startTime: bigint;
          totalOriginalConsiderationItems: bigint;
          zone: `0x${string}`;
          zoneHash: `0x${string}`;
      }
      conduitKey: `0x${string}`
      consideration: {
          endAmount: bigint;
          identifierOrCriteria: bigint;
          itemType: ItemType;
          recipient: `0x${string}`;
          startAmount: bigint;
          token: `0x${string}`;
      }[]
      endTime: bigint
      offer: {
          endAmount: bigint;
          identifierOrCriteria: bigint;
          itemType: ItemType;
          startAmount: bigint;
          token: `0x${string}`;
      }[]
      offerer: `0x${string}`
      orderType: OrderType
      salt: bigint
      startTime: bigint
      totalOriginalConsiderationItems: bigint
      zone: `0x${string}`
      zoneHash: `0x${string}`
      signature: `0x${string}`
      seaportAddress: `0x${string}`
      ulid: bigint
      Returns void
  - Optional options?: {
    signal?: AbortSignal;
    timeoutMs: number;
    }
    - Optional signal?: AbortSignal
    - timeoutMs: number
  - request: TMethod extends "webTaker"
    ? PartialMessage<QuoteRequest>
    : (() => AsyncIterable<PartialMessage<QuoteRequest>>)
Returns Promise<void>
Inherited from Trader.openRFQStream
- Defined in src/entities/trader/base-trader.ts:254

sendRFQ

sendRFQ(__namedParameters): Promise<void>
Sends a Request For Quote (RFQ) and handles the quote response. This method is specifically designed for gRPC-web clients.
Parameters
- __namedParameters: {
      onQuoteResponse: ((quoteResponse) => void);
      quoteRequest: QuoteRequest;
      signal: AbortSignal;
  }
  - onQuoteResponse: ((quoteResponse) => void)
    - (quoteResponse): void
      Parameters
      quoteResponse: {
          chainId: undefined | number;
          makerAddress: `0x${string}`;
          order: {
              parameters: {
                  conduitKey: `0x${string}`;
                  consideration: {
                      endAmount: bigint;
                      identifierOrCriteria: bigint;
                      itemType: ItemType;
                      recipient: `0x${string}`;
                      startAmount: bigint;
                      token: `0x${string}`;
                  }[];
                  endTime: bigint;
                  offer: {
                      endAmount: bigint;
                      identifierOrCriteria: bigint;
                      itemType: ItemType;
                      startAmount: bigint;
                      token: `0x${string}`;
                  }[];
                  offerer: `0x${string}`;
                  orderType: OrderType;
                  salt: bigint;
                  startTime: bigint;
                  totalOriginalConsiderationItems: bigint;
                  zone: `0x${string}`;
                  zoneHash: `0x${string}`;
              };
              signature: `0x${string}`;
          };
          seaportAddress: `0x${string}`;
          ulid: bigint;
      }
      chainId: undefined | number
      makerAddress: `0x${string}`
      order: {
          parameters: {
              conduitKey: `0x${string}`;
              consideration: {
                  endAmount: bigint;
                  identifierOrCriteria: bigint;
                  itemType: ItemType;
                  recipient: `0x${string}`;
                  startAmount: bigint;
                  token: `0x${string}`;
              }[];
              endTime: bigint;
              offer: {
                  endAmount: bigint;
                  identifierOrCriteria: bigint;
                  itemType: ItemType;
                  startAmount: bigint;
                  token: `0x${string}`;
              }[];
              offerer: `0x${string}`;
              orderType: OrderType;
              salt: bigint;
              startTime: bigint;
              totalOriginalConsiderationItems: bigint;
              zone: `0x${string}`;
              zoneHash: `0x${string}`;
          };
          signature: `0x${string}`;
      }
      parameters: {
          conduitKey: `0x${string}`;
          consideration: {
              endAmount: bigint;
              identifierOrCriteria: bigint;
              itemType: ItemType;
              recipient: `0x${string}`;
              startAmount: bigint;
              token: `0x${string}`;
          }[];
          endTime: bigint;
          offer: {
              endAmount: bigint;
              identifierOrCriteria: bigint;
              itemType: ItemType;
              startAmount: bigint;
              token: `0x${string}`;
          }[];
          offerer: `0x${string}`;
          orderType: OrderType;
          salt: bigint;
          startTime: bigint;
          totalOriginalConsiderationItems: bigint;
          zone: `0x${string}`;
          zoneHash: `0x${string}`;
      }
      conduitKey: `0x${string}`
      consideration: {
          endAmount: bigint;
          identifierOrCriteria: bigint;
          itemType: ItemType;
          recipient: `0x${string}`;
          startAmount: bigint;
          token: `0x${string}`;
      }[]
      endTime: bigint
      offer: {
          endAmount: bigint;
          identifierOrCriteria: bigint;
          itemType: ItemType;
          startAmount: bigint;
          token: `0x${string}`;
      }[]
      offerer: `0x${string}`
      orderType: OrderType
      salt: bigint
      startTime: bigint
      totalOriginalConsiderationItems: bigint
      zone: `0x${string}`
      zoneHash: `0x${string}`
      signature: `0x${string}`
      seaportAddress: `0x${string}`
      ulid: bigint
      Returns void
  - quoteRequest: QuoteRequest
  - signal: AbortSignal
Returns Promise<void>
- Defined in src/entities/trader/web-taker.ts:28

signIn

signIn(): Promise<void>
Authenticates the trader with the Valorem Trade API using SIWE (Sign-In with Ethereum). This process involves getting a session nonce, creating and signing a SIWE message, and submitting the verification to Valorem Trade API.

Returns Promise<void>
Inherited from Trader.signIn
- Defined in src/entities/trader/base-trader.ts:130

verifyWithSIWE

verifyWithSIWE(message, signature): Promise<{
verified: boolean;
} | {
verified: null;
}>
Verifies the signed SIWE message for authentication.
Parameters
- message: string
  The signed message.
- signature: `0x${string}`
  The signature of the message.
Returns Promise<{
verified: boolean;
} | {
verified: null;
}>
- A promise with the verification result.
Inherited from Trader.verifyWithSIWE
- Defined in src/entities/trader/base-trader.ts:185

Class WebTaker

Hierarchy (view full)

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

args: TraderConstructorArgs

Returns WebTaker

Properties

account

authClient

Type declaration

Readonly authenticate: { I: typeof Empty; O: typeof H160; kind: Unary; name: "Authenticate"; }

Generated

Readonly I: typeof Empty

Readonly O: typeof H160

Readonly kind: Unary

Readonly name: "Authenticate"

Readonly geofenced: { I: typeof Empty; O: typeof BoolValue; kind: Unary; name: "Geofenced"; }

Generated

Readonly I: typeof Empty

Readonly O: typeof BoolValue

Readonly kind: Unary

Readonly name: "Geofenced"

Readonly nonce: { I: typeof Empty; O: typeof NonceText; kind: Unary; name: "Nonce"; }

Generated

Readonly I: typeof Empty

Readonly O: typeof NonceText

Readonly kind: Unary

Readonly name: "Nonce"

Readonly session: { I: typeof Empty; O: typeof SiweSession; kind: Unary; name: "Session"; }

Generated

Readonly I: typeof Empty

Readonly O: typeof SiweSession

Readonly kind: Unary

Readonly name: "Session"

Readonly signOut: { I: typeof Empty; O: typeof Empty; kind: Unary; name: "SignOut"; }

Generated

Readonly I: typeof Empty

Readonly O: typeof Empty

Readonly kind: Unary

Readonly name: "SignOut"

Readonly verify: { I: typeof VerifyText; O: typeof H160; kind: Unary; name: "Verify"; }

Generated

Readonly I: typeof VerifyText

Readonly O: typeof H160

Readonly kind: Unary

Readonly name: "Verify"

Readonly typeName: "valorem.trade.v1.Auth"

authenticated

chain

clearinghouse

publicClient

rfqClient

Type declaration

Readonly maker: { I: typeof QuoteResponse; O: typeof QuoteRequest; kind: BiDiStreaming; name: "Maker"; }

Generated

Readonly I: typeof QuoteResponse

Readonly O: typeof QuoteRequest

Readonly kind: BiDiStreaming

Readonly name: "Maker"

Readonly taker: { I: typeof QuoteRequest; O: typeof QuoteResponse; kind: BiDiStreaming; name: "Taker"; }

Generated

Readonly I: typeof QuoteRequest

Readonly O: typeof QuoteResponse

Readonly kind: BiDiStreaming

Readonly name: "Taker"

Readonly webTaker: { I: typeof QuoteRequest; O: typeof QuoteResponse; kind: ServerStreaming; name: "WebTaker"; }

Generated

Readonly I: typeof QuoteRequest

Readonly O: typeof QuoteResponse

Readonly kind: ServerStreaming

Readonly name: "WebTaker"

Readonly typeName: "valorem.trade.v1.RFQ"

seaport

walletClient

Type declaration

`Readonly` authenticate: {
I: typeof Empty;
O: typeof H160;
kind: Unary;
name: "Authenticate";
}

`Readonly` I: typeof Empty

`Readonly` O: typeof H160

`Readonly` kind: Unary

`Readonly` name: "Authenticate"

`Readonly` geofenced: {
I: typeof Empty;
O: typeof BoolValue;
kind: Unary;
name: "Geofenced";
}

`Readonly` I: typeof Empty

`Readonly` O: typeof BoolValue

`Readonly` kind: Unary

`Readonly` name: "Geofenced"

`Readonly` nonce: {
I: typeof Empty;
O: typeof NonceText;
kind: Unary;
name: "Nonce";
}

`Readonly` I: typeof Empty

`Readonly` O: typeof NonceText

`Readonly` kind: Unary

`Readonly` name: "Nonce"

`Readonly` session: {
I: typeof Empty;
O: typeof SiweSession;
kind: Unary;
name: "Session";
}

`Readonly` I: typeof Empty

`Readonly` O: typeof SiweSession

`Readonly` kind: Unary

`Readonly` name: "Session"

`Readonly` signOut: {
I: typeof Empty;
O: typeof Empty;
kind: Unary;
name: "SignOut";
}

`Readonly` I: typeof Empty

`Readonly` O: typeof Empty

`Readonly` kind: Unary

`Readonly` name: "SignOut"

`Readonly` verify: {
I: typeof VerifyText;
O: typeof H160;
kind: Unary;
name: "Verify";
}

`Readonly` I: typeof VerifyText

`Readonly` O: typeof H160

`Readonly` kind: Unary

`Readonly` name: "Verify"

`Readonly` typeName: "valorem.trade.v1.Auth"

`Readonly` maker: {
I: typeof QuoteResponse;
O: typeof QuoteRequest;
kind: BiDiStreaming;
name: "Maker";
}

`Readonly` I: typeof QuoteResponse

`Readonly` O: typeof QuoteRequest

`Readonly` kind: BiDiStreaming

`Readonly` name: "Maker"

`Readonly` taker: {
I: typeof QuoteRequest;
O: typeof QuoteResponse;
kind: BiDiStreaming;
name: "Taker";
}

`Readonly` I: typeof QuoteRequest

`Readonly` O: typeof QuoteResponse

`Readonly` kind: BiDiStreaming

`Readonly` name: "Taker"

`Readonly` webTaker: {
I: typeof QuoteRequest;
O: typeof QuoteResponse;
kind: ServerStreaming;
name: "WebTaker";
}

`Readonly` I: typeof QuoteRequest

`Readonly` O: typeof QuoteResponse

`Readonly` kind: ServerStreaming

`Readonly` name: "WebTaker"

`Readonly` typeName: "valorem.trade.v1.RFQ"

`Optional` batch?: {
multicall?: boolean | {
batchSize?: number;
wait?: number;
};
}

`Optional` multicall?: boolean | {
batchSize?: number;
wait?: number;
}

extend: (<const client>(fn) => Client<Transport, Chain, Account, WalletRpcSchema, {
[K in string | number | symbol]: client[K]
} & WalletActions<Chain, Account>>)

const client extends {
account?: undefined;
batch?: undefined;
cacheTime?: undefined;
chain?: undefined;
key?: undefined;
name?: undefined;
pollingInterval?: undefined;
request?: undefined;
transport?: undefined;
type?: undefined;
uid?: undefined;
} & Partial<ExtendableProtectedActions>

Returns Client<Transport, Chain, Account, WalletRpcSchema, {
[K in string | number | symbol]: client[K]
} & WalletActions<Chain, Account>>