# JavaScript Libraries
Source: https://docs.qu.ai/build/apis/javascript-libraries

An overview of the JavaScript APIs available for interacting with Quai Network.

## Overview

Every application built on top of Quai Network requires a connection to the network in order to interact with smart contracts, send transactions, or sign messages on behalf of a user. Using the direct client JSON-RPC API is possible, but the methods can be quite verbose for use in application interfaces.

JavaScript APIs and SDKs offer a simplified interface for web applications to interact with Quai Network via one-line methods, conversion utils, and smart contract wrappers. The available libraries can be found below.

### quais.js

A complete Quai Network interaction library for JavaScript and TypeScript.

<CardGroup>
  <Card title="Github" icon="github" href="/sdk/introduction" />

  <Card title="Package" icon="npm" href="https://www.npmjs.com/package/quais" />

  <Card title="Examples" icon="code" href="https://github.com/dominant-strategies/quais.js/tree/master/examples" />
</CardGroup>

## Library Features

### Connect to Quai Nodes

Abstract providers make it easy to connect to, read data from, and broadcast transactions to Quai Network nodes. Providers are composable, so you can connect to remote endpoints, local nodes, or even custom infrastructure.

Providers can query **any zone chain** in the network for:

* Block data
* Transaction data and gas estimates
* Account balances
* Smart contract data
* And more...

```javascript theme={null}
// Connect to a remote node
const provider = new quais.JsonRpcProvider('https://rpc.quai.network', undefined, { usePathing: true })

// Connect to an injected provider (e.g. Pelagus)
const provider = new quais.BrowserProvider(window.pelagus)
```

### Smart Contract Functionality

Libraries like Quais.js provide smart contract wrappers that make it easy to call smart contract functions, return event data, and read state variables.

Smart contract wrappers serve as JavaScript interpreters for contract ABIs, allowing you to call functions and read data from smart contracts without having to interface with Solidity directly.

Smart contract wrappers also provide a number of useful features, including:

* Transaction simulation
* Raw transaction generation
* Event filtering

```javascript theme={null}
// set up a contract interface
const contract = new quais.Contract(contractAddress, contractABI, provider)

// call a contract function
const result = await contract.setGreeting('Hello, world!')

// read a contract state variable
const greeting = await contract.staticCallResult.greet()
```

### Utilities

Quais.js ships with a number of small but powerful utilities that make working with Quai Network simple. They provide useful shortcuts for converting units, getting shard information, and formatting data.

Other useful utilities include:

* Unit conversion and parsing
* Data encoding and formatting
* Address validation

```javascript theme={null}
// get zone name from an address
const shard = quais.getZoneFromAddress('0xa844d9a88331e9688d3065f92c11e25ab1e50aa6')

// parse units to BigNumber
const quai = quais.parseQuai('1')

// base58 encode a string
const decoded = quais.decodeBase58('MergedMining')
```


# Variables
Source: https://docs.qu.ai/build/apis/postman/environment

How to configure and use environment variables in Postman for the Quai Network API.

## Introduction

Postman supports a number of different variable "scopes":

* **Global**
* **Collection**
* **Environment**
* **Data**
* **Local**

In this guide, we'll focus on **Environment Variables**. Environment variables are a way to store and reuse values across multiple requests in a collection, which can be particularly useful in our case for storing RPC endpoint URLs, addresses, and other values that are shared across multiple go-quai API requests.

## Environment Variables

The Example Quai Postman Environment includes a small number of pre-defined environment variables that you can use in your requests. These variables include:

* `chain`
* `myAddress`
* `txHash`
* `blockNumber`

<Note>
  This guide assumes you have already installed Postman and imported the [Example Quai Postman
  Environment](https://github.com/dominant-strategies/quai-postman-collection). If you have not done so, please refer to the [Setting Up
  Postman](/build/apis/postman/setup) guide.
</Note>

The pre-configured environment variables can be accessed via the `Environment` tab in the top left of the Postman application:

<Frame>
  <img />
</Frame>

To add your own environment variable, simply type your variable name in the `Add new variable` field at the bottom of the list and fill it in with the desired value.

## Chain Specific Variables

Quai Network has [many distinct chains](/build/networks/#testnet), each with their own [sharded address space](/learn/advanced-introduction/hierarchical-structure/sharding), state, and unique data. To send a request to a specific chain, you must define the `chain` environment variable with the chain name you want to interact with and ensure that all of the arguments you pass to the request are valid for that chain.

For example, to request balance data for my address on Cyprus 1, I need to:

* set the `chain` environment variable to `cyprus1` to route to the Cyprus 1 RPC endpoint
* ensure that the `myAddress` parameter in the request is a valid Cyprus 1 address

If the data passed to the request is not valid on the specified chain, **the request will return an error**.

## Usage

Environment variables can be used in any request by wrapping the variable name in double curly braces (`{{}}`).

For example, **all Quai Postman Collection requests** use a `{{chain}}` variable to specify the chain to request data from in the RPC endpoint URL:

```
https://rpc.{{chain}}.colosseum.quaiscan.io
```

<Note>
  The `{{ chain }}` variable is the only environment variable used by default in all requests. All other variables are optional and can be
  used as needed.
</Note>

The same principle applies to any other defined environment variable. For example, if you define the `{{txHash}}` variable with your own transaction hash, you can use it in a request like this:

```json theme={null}
{
  "jsonrpc": "2.0",
  "method": "quai_getTransactionByHash",
  "params": [
    {{txHash}}
  ],
  "id": 1
}
```

When the request is sent, Postman will automatically replace `{{chain}}` with the value of the `chain` environment variable. You can hover over the `{{}}` to see the resolved value:

<Frame>
  <img />
</Frame>


# Setting Up Postman
Source: https://docs.qu.ai/build/apis/postman/setup

How to set up Postman for use with the Quai Network API.

Our team has created a [Postman collection for Quai Network](https://docs.api.qu.ai/), which includes all of the publicly available API calls for go-quai bundled with documentation, examples, and environment variables. Postman provides a user-friendly interface for making API requests to a go-quai node without having to deal with long `curl` commands or JSON-RPC payloads. A JSON formatted version of the Quai Postman collection can be found in the [`quai-postman-collection` repository](https://github.com/dominant-strategies/quai-postman-collection).

## Introduction to Postman

Postman is a popular API client that makes it easy to send requests, test endpoints, and share collections of methods through a unified and scalable interface. Postman is available as both a **desktop application** and **web application** available on Linux, MacOS, and Windows. *The desktop application is the most feature-rich and is recommended for most users*.

The Quai Postman collection ships with a full library of API request templates and commonly used environment variables so you don't have to constantly re-write requests or variable definitions. Using the Quai Postman collection, you can interact with any Quai Network client *with minimal code and configuration*.

## Configuration

<Steps>
  <Step title="Install Postman">
    As mentioned above, Postman is available as both a desktop application and web application. While the web application is convenient for quick access, **we recommend using the desktop application** for access to all features and better performance.

    To download the Postman desktop application, visit the [Postman website](https://www.postman.com/downloads/) and download the version for your operating system. Once downloaded, it is recommended that you sign up with an email address to save and sync your collections across devices and platforms.

    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Import Quai API Collection">
    Postman supports raw collection imports from a URL or a local file. To import the Quai Postman collection, click the `Import` button in the top left corner of the Postman application:

    <Frame>
      <img />
    </Frame>

    This will open the import options modal:

    <Frame>
      <img />
    </Frame>

    To import the Quai Postman collection, paste the following URL into the `Paste cURL, Raw Text, or URL...` field:

    ```
    https://raw.githubusercontent.com/dominant-strategies/quai-postman-collection/main/go-quai.postman_collection.json
    ```

    Once the import has completed, you'll see the **Quai Postman Collection** in the left sidebar of the Postman application:

    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Import Environment Variables">
    Now that we have the Quai Postman collection imported, we need to import the environment variables. To import the Quai Postman environment variables, click the `Import` button in the top left corner of Postman like before, but this time, **paste the URL to the environment variables file**:

    ```
    https://raw.githubusercontent.com/dominant-strategies/quai-postman-collection/main/example-quai-environment.postman_environment.json
    ```

    Postman will automatically recognize the format of the environment variables file. When the import is complete, you should see this modal in the left right corner of the Postman application:

    <Frame>
      <img />
    </Frame>

    Lastly, you'll need to select the `Example Quai Postman Environment` from the dropdown in the top right corner of the Postman application:

    <Frame>
      <img />
    </Frame>

    Your environment variables are now **set as the active environment** and ready to use. When set as the active environment, the Quai Postman collection will be correctly configured with RPC endpoints, addresses, and hashes!
  </Step>
</Steps>

## Conclusion

Now that you've installed Postman, imported the Quai API collection, and configured environment variables, **you're ready to start making requests to a go-quai node**. *Further documentation and tutorials* on how to use the Quai Postman collection can be found below:

**Quai Postman Guides**

* [Environment Variables Guide](/build/api/postman/environment)
* [Making Requests Guide](/build/api/postman/use)

**API Specification**

* Pre-packaged specs and examples inside of the Quai Postman Collection
* [Quai Postman Collection Documentation](https://docs.api.qu.ai/)
* [JSON-RPC API Documentation](/build/playground/overview)


# Making Requests
Source: https://docs.qu.ai/build/apis/postman/use

How to make API requests to Quai Network using Postman.

<Note>
  This guide assumes you have already installed [Postman](https://www.postman.com/downloads/) and imported the [Quai Postman
  Collection](/build/apis/postman/setup) and [Example Quai Postman
  Environment](/build/apis/postman/variables).
</Note>

## Introduction

Making requests to a go-quai client via the Quai Postman collection is straightforward. The basic steps to making a request are:

<Steps>
  <Step title="Chose A  Request">Select a request from the Quai Postman collection</Step>

  <Step title="Verify URL">
    Ensure the URL in the request is correct for the chain you want to interact with (e.g. cyprus1 endpoint for cyprus 1 queries)
  </Step>

  <Step title="Edit Params">Edit the request body with the desired parameters (e.g. address, block number, etc.)</Step>
  <Step title="Send Request">Click the `Send` button to make the request</Step>
  <Step title="View Repsone">View the response in the section below the request body</Step>
</Steps>

## Making Your First Request

To make your first request to a go-quai client, open the Quai Postman Collection in the left sidebar of Postman and select a request from the collection. For example, let's select the `getBalance` request under the `quai` folder:

<Frame>
  <img />
</Frame>

Once you've selected `getBalance`, you'll be directed to the `Params` tab for the request. To edit the parameters for the request, choose the `Body` tab to see the JSON-RPC request body:

```JSON theme={null}
{
    "jsonrpc": "2.0",
    "method": "quai_getBalance",
    "params": [
        "0x0255b093f1c3c54d2d56af9909a9b8e6466f1926", // can replace with {{myAddress}}
        "latest"
    ],
    "id": 1
}
```

To request the balance of a specific address, replace the placeholder address `0x0255b093f1c3c54d2d56af9909a9b8e6466f1926` with the address you'd like to query. You can also use the `{{myAddress}}` environment variable to reference your own address *if you've configured it in the environments tab on the left*.

<Note>
  More information on how to configure environment variables like `{{ myAddress }}` can be found in the [Environment Variables
  Guide](/build/apis/postman/environment).
</Note>

Once you've updated the request body with the desired address, click the `Send` button to make the request. The response will be displayed in the response section below the request body:

```JSON theme={null}
{
    "jsonrpc": "2.0",
    "id": 1,
    "result": "0x0"
}
```

## Common Mistakes

### Chain and Data Mismatch

Often times sending a request using the Quai Postman Collection can result in one of the following errors: `address is not in scope` or `genesis is not traceable`.

If this is the case, it's likely that the params you are passing to the method call do not correspond with the RPC endpoint you are querying. Ensure that the `chain` environment variable (or manually set request URL) is set to the correct chain you are querying data from.

**Example**:

* Querying the URL: `https://rpc.cyprus1.quaiscan.io` with a `getBalance` request for an address that only exists on `hydra3`: `0xfbca7e03dc8b5c4cc327c92de8ba1af66d34ac70`.

### Non-Existent Data

When sending requests related to blocks or transactions, often times the node will return an error related to `method handler crashed` or `no data found`. This is often due to the block or transaction hash not existing on the chain you are sending the request to.

Ensure that the block number or transaction hash you are providing exists on the canonical chain you are querying.

**Example:**

* Requesting block data for block 10000 when the chain you are querying only has 5000 blocks.

## Conclusion

Now that you've made your first request to a go-quai client using the Quai Postman Collection, you're ready to start exploring the full range of API requests available in the collection. For specifications on available methods and parameters, refer to the [Quai JSON-RPC API documentation](/build/playground/overview) or the [Quai Postman Collection](https://docs.api.qu.ai/).


# Quai Builders Program & Grants
Source: https://docs.qu.ai/build/grants

Get started building on Quai Network today!

The Quai Builders Program seeks innovative projects that harness the network's distinctive features, including its dual-token architecture, PoEM consensus mechanism, and vision for a decentralized energy-based currency.

<Note>
  **Quai Team Contact:** Email: [bd@quai.org](mailto:bd@quai.org)
</Note>

## Vision and Framework

We welcome proposals across a wide spectrum of project categories that leverage Quai Network's unique capabilities.

### 1. Quai Public Goods

Infrastructure protocols and development tools that enhance the foundation for all applications built on Quai Network. We're seeking projects that improve developer experience, user interactions, and overall ecosystem functionality.

### 2. Cross-Chain Infrastructure

Bridging services and pricing oracles that allow the Quai Network users to bring their liquidity from their other homes into ours and also allow trading to occur cross-chain.

### 3. DeFi Protocols

Advanced borrowing and lending protocols that strengthen Quai Network's financial infrastructure. We're looking for innovative DeFi applications that leverage Quai's unique features and expand the network's capabilities.

### 4. Novel Applications

Groundbreaking dApps that push the boundaries of what's possible on Quai Network. We welcome visionary builders with compelling ideas that demonstrate technical excellence and real-world utility.

## Evaluation Criteria

Projects submitted to the Quai Builders Program will be evaluated based on the following criteria:

<CardGroup>
  <Card title="User Adoption & Engagement" icon="users">
    Number of active wallets, transaction volume, user growth rate, community engagement metrics, and social media presence.
  </Card>

  <Card title="Technical Implementation" icon="code">
    Demonstrated working product, publicly available code, smart contract security measures, and technical innovation utilizing Quai's features.
  </Card>

  <Card title="Team Assessment" icon="people-group">
    Track record in crypto/blockchain development, previous successful project launches, and commitment to the project.
  </Card>

  <Card title="Market Presence" icon="chart-line">
    Partnership development, media coverage and industry recognition, marketing strategy and execution, and community building efforts.
  </Card>
</CardGroup>

## Illustrative Project Ideas

Looking for inspiration? Here are some project ideas that could make a significant impact on the Quai ecosystem:

<CardGroup>
  <Card title="Analytics and Insights" icon="chart-simple">
    A comprehensive analytics suite for Quai/Qi token metrics and network health.
  </Card>

  <Card title="DeFi Innovations" icon="coins">
    An innovative DeFi product leveraging Quai's unique mining reward system.
  </Card>

  <Card title="Payment Solutions" icon="credit-card">
    A seamless payment gateway integrating Qi with conventional financial systems or a turnkey solution for e-commerce platforms to accept Qi payments.
  </Card>

  <Card title="Cross-Chain Integration" icon="link">
    A robust cross-chain bridge connecting Quai to other major networks.
  </Card>

  <Card title="Economic Analysis" icon="magnifying-glass-chart">
    An in-depth economic analysis of Quai and Qi's roles in the broader crypto landscape or a sophisticated model for predicting Qi mining profitability.
  </Card>

  <Card title="Educational Content" icon="graduation-cap">
    Educational content highlighting Quai's advantages as an energy-based currency.
  </Card>
</CardGroup>

## Grant Program Overview

<div>
  <div>
    <div>10M \$QUAI</div>
    <div>Total Program Allocation</div>
  </div>
</div>

Projects can receive up to **1M \$QUAI** per grant based on:

* Quality of application submission
* Potential reach to new users
* Impact on ecosystem growth
* **Note** restrictions on the use of funds may apply, such as vesting periods or specific milestones

## How to Apply

Follow these steps to submit your application to the Quai Builders Program:

<Steps>
  <Step title="Launch Application">
    Launch your application on Quai mainnet.
  </Step>

  <Step title="Create Account">
    Create a Questbook account.
  </Step>

  <Step title="Access Dashboard">
    Go to the dashboard of the "Quai Grants".
  </Step>

  <Step title="Submit New Application">
    Click on the "Submit New" button on the top left of the page.
  </Step>

  <Step title="Complete Form">
    Fill the form with all the data requested.
  </Step>

  <Step title="Use Template">
    Use the [application template](https://docs.google.com/document/d/1QILbW9Bp_jM8pDoKv_nkSN8cFJ2zMvIQ5MpGuKVwDXY/edit?usp=sharing) to fill in the "details" section.
  </Step>

  <Step title="Await Response">
    If your grant application is considered, team members will be in touch directly.
  </Step>
</Steps>

<Card title="Ready to Apply?" icon="rocket" href="https://questbook.app/dashboard/?grantId=66b26b564a88e5bd2a0f936d&chainId=10&role=admin&proposalId=67d1acf446da2f90ccd285b9">
  Submit your application on Questbook
</Card>


# Development Introduction
Source: https://docs.qu.ai/build/introduction

Learn the basics of developing on Quai.

The main differences between Quai’s EVM and the traditional EVM can be seen below.

<AccordionGroup>
  <Accordion title="Address Sharding">
    Each zone chain contains a [unique set of Quai and Qi
    addresses](/learn/advanced-introduction/hierarchical-structure/sharding)
    based on each address's prefix. The prefix denotes which shard and ledger
    the address belongs to.
  </Accordion>

  <Accordion title="API Methods and Namespace">
    The [Go-Quai client API](/build/playground/introduction) closely resembles
    that of Ethereum, but uses the `quai_` namespace rather than the `eth_`
    namespace. The API also contains many of, but not all, the same methods.
  </Accordion>

  <Accordion title="Interoperability Opcodes">
    Quai’s EVM handles traditional
    [Solidity](/build/smart-contracts/solidity) smart contracts.
  </Accordion>

  <Accordion title="Additional Tooling">
    Both Ethereum and [Quai-specific tooling](#available-tooling) can be used to
    build on Quai Network.
    Read more in [Migrating your Ethereum App to Quai](#migrating-your-ethereum-app-to-quai).
  </Accordion>

  <Accordion title="Transaction Types">
    Quai utilizes additional [new transaction
    types](/learn/advanced-introduction/hierarchical-structure/sharding)
    compared to the typical EVM to handle cross-chain and UTXO transactions.
  </Accordion>
</AccordionGroup>

## Available Tooling

As mentioned earlier, Quai has a subset of Ethereum tooling that has been adapted to handle the multi-chain network. This tooling includes:

<CardGroup>
  <Card title="Pelagus Wallet" icon="wallet" href="https://pelaguswallet.io/">
    The community built wallet for Quai with support for both Quai and Qi
    environments.
  </Card>

  <Card title="Hardhat" icon="helmet-safety" href="https://github.com/dominant-strategies/hardhat-example">
    A modified version of the Hardhat framework built for Quai Network.
  </Card>

  <Card title="Quais SDK" icon="screwdriver-wrench" href="/sdk/introduction">
    A complete Quai Network interaction library for JavaScript and TypeScript.
  </Card>

  <Card title="Local Node Runner" icon="terminal" href="/guides/client/containerized-node">
    A containerized, feature complete local node environment for Quai.
  </Card>

  <Card title="Testnet Faucet" icon="faucet" href="https://orchard.faucet.quai.network/">
    The central source for testnet Quai token drips.
  </Card>

  <Card title="Explorer" icon="link" href="https://quaiscan.io/">
    Track transactions and blocks on the testnet.
  </Card>
</CardGroup>

## Migrating your Ethereum App to Quai

Ethereum applications are typically built with some combination of Ethers, Web3.js, Viem, and WAGMI. These tools work out of the box for web based dapp development *as long as* you are using Pelagus wallet as an injected provider.

If you are using a different wallet or not building a web based dapp, you can still use these tools for querying chain data, however, you will need to incorporate or transition to the [Quais SDK](https://www.npmjs.com/package/quais) for sending transactions.

The Quais SDK is a fork of [Ethers v6](https://docs.ethers.org/v6/). Because of this, syntax in Quais is nealy identical to Ethers with the caveat that the above changes have been applied. If your application is currently built with Viem or Web3.js, these guides are helpful in understanding syntax mapping of your existing code to Quais:

* [**Viem to Ethers Guide**](https://viem.sh/docs/ethers-migration)
* [**Web3.js to Ethers Guide**](https://docs.ethers.org/v5/migration/web3/)

Almost all of the existing functions and utilities in Ethers, Viem, and Web3.js have direct mappings to similar or the same methods in Quais.js, with the exception of methods that utilize provider polling.


# Networks
Source: https://docs.qu.ai/build/networks

Specifications for Quai Network and its testing environments.

## Quai Mainnet

The Quai Mainnet serves as the production environment for Quai Network. This network can be used by all to interact with tokens Quai and Qi. The Quai Mainnet is currently live and running the latest version of [go-quai](guides/client/node). Developers looking to test can use the Orchard Testnet.

### Network Specifications

<CardGroup>
  <Card title="Chain ID" icon="link">
    9
  </Card>

  <Card title="Genesis Nonce" icon="lock">
    23621466532946281564673705261963422
  </Card>

  <Card title="Stats" icon="chart-simple">
    [https://stats.quai.network](https://stats.quai.network)
  </Card>

  <Card title="Block Explorer" icon="link">
    [https://quaiscan.io](https://quaiscan.io)
  </Card>
</CardGroup>

#### RPC Endpoints

<Info>Cyprus-1 is the only active zone in Quai Network as of now.</Info>

| Zone Name | Zone Index | RPC Endpoint (https)                                                 | RPC Endpoint (wss)              | GraphQL Endpoint                                         |
| --------- | ---------- | -------------------------------------------------------------------- | ------------------------------- | -------------------------------------------------------- |
| cyprus    | \[0 0]     | [https://rpc.quai.network/cyprus1](https://rpc.quai.network/cyprus1) | wss\://rpc.quai.network/cyprus1 | [https://graph.quai.network](https://graph.quai.network) |

## Orchard Testnet

<Warning>
  This network is for development purposes only. Quai tokens on this network
  have no real value.
</Warning>

Orchard Testnet is a public isolated development environment that is designed to be used by both smart contract and tooling developers to test smart-contract deployments and infrastructure upgrades in a production-like environment.

QUAI on this testnet has no real value and thus testing deployments, interactions, and smart contracts are virtually free. As Orchard Testnet QUAI has no value, there are *no markets* to purchase devnet tokens.

### Network Specifications

<CardGroup>
  <Card title="Chain ID" icon="link">
    15000
  </Card>

  <Card title="Genesis Nonce" icon="lock">
    62242624366553750196964614682162313
  </Card>

  <Card title="Faucet" icon="faucet">
    [https://orchard.faucet.quai.network](https://orchard.faucet.quai.network)
  </Card>

  <Card title="Block Explorer" icon="link">
    [https://orchard.quaiscan.io](https://orchard.quaiscan.io)
  </Card>
</CardGroup>

#### RPC Endpoints

| Zone Name | Zone Index | RPC Endpoint (https)                                                                 | RPC Endpoint (wss)                      | GraphQL Endpoint                                                         |
| --------- | ---------- | ------------------------------------------------------------------------------------ | --------------------------------------- | ------------------------------------------------------------------------ |
| cyprus    | \[0 0]     | [https://orchard.rpc.quai.network/cyprus1](https://orchard.rpc.quai.network/cyprus1) | wss\://orchard.rpc.quai.network/cyprus1 | [https://orchard.graph.quai.network](https://orchard.graph.quai.network) |

## Local Network

A local instance of Quai Network is an isolated development environment that can be spun up on a single machine. This private network offers faster block times, lower block difficulties with the full range of Quai Network capabilities.

Using a local network allows developers looking to launch applications to work faster and with better privacy than on a public testnet. They also provide the ability to easily control a network environment and develop privately.

You can easily spin up a pre-configured development environment using the [Local Node Runner](/guides/client/local-node) and [Docker compose](https://docs.docker.com/compose/). The Local Node Runner spins up a containerized local Quai environment complete with multiple shards, CPU miner, and accounts pre-loaded with Quai and Qi tokens.

### Network Specifications

<CardGroup>
  <Card title="Chain ID" icon="link">
    1337
  </Card>
</CardGroup>

### Networking Information

<Warning>
  Do not publically expose these HTTP ports for any reason. You will be putting
  your local network security at risk.
</Warning>

| Chain Name | Chain Index | HTTP Port | WS Port |
| ---------- | ----------- | --------- | ------- |
| Prime      |             | 9000      | 8000    |
| Cyprus     |             | 9001      | 8001    |
| Paxos      |             | 9002      | 8002    |
| Hydra      |             | 9003      | 8003    |
| Cyprus1    | \[0 0]      | 9200      | 8200    |
| Cyprus2    | \[0 1]      | 9201      | 8201    |
| Cyprus3    | \[0 2]      | 9202      | 8202    |
| Paxos1     | \[1 0]      | 9220      | 8220    |
| Paxos2     | \[1 1]      | 9221      | 8221    |
| Paxos3     | \[1 2]      | 9222      | 8222    |
| Hydra1     | \[2 0]      | 9240      | 8240    |
| Hydra2     | \[2 1]      | 9241      | 8241    |
| Hydra3     | \[2 2]      | 9242      | 8242    |

## Golden Age Testnet

<Warning>
  This network has concluded as of January 2025. Data from this network is
  archived and only being used for the claims process.
</Warning>


# getBalance
Source: https://docs.qu.ai/build/playground/addresses/getBalance

openapi-getBalance POST /
Returns the balance of the specified address.



# getCode
Source: https://docs.qu.ai/build/playground/addresses/getCode

openapi-getCode POST /
Returns the code stored at a given address.



# getOutpointsByAddressAndRange
Source: https://docs.qu.ai/build/playground/addresses/getOutpointsByAddressAndRange

openapi-getOutpointsByAddressAndRange POST /
Returns the outpoints for a given address and block range.



# getProof
Source: https://docs.qu.ai/build/playground/addresses/getProof

openapi-getProof POST /
Returns the Merkle-Proof for a given account and optional storage keys.



# getStorageAt
Source: https://docs.qu.ai/build/playground/addresses/getStorageAt

openapi-getStorageAt POST /
Returns the value from a storage position at a given address.



# getTransactionCount
Source: https://docs.qu.ai/build/playground/addresses/getTransactionCount

openapi-getTransactionCount POST /
Returns the total transaction count for a given address.



# blockNumber
Source: https://docs.qu.ai/build/playground/blocks/blockNumber

openapi-blockNumber POST /
Returns the current block number.



# getBlockByHash
Source: https://docs.qu.ai/build/playground/blocks/getBlockByHash

openapi-getBlockByHash POST /
Returns block data for a given block hash.



# getBlockByNumber
Source: https://docs.qu.ai/build/playground/blocks/getBlockByNumber

openapi-getBlockByNumber POST /
Returns block data for a given block number.



# getBlockOrCandidateByHash
Source: https://docs.qu.ai/build/playground/blocks/getBlockOrCandidateByHash

openapi-getBlockOrCandidateByHash POST /
Returns block or candidate block data for a given hash.



# getHeaderByHash
Source: https://docs.qu.ai/build/playground/blocks/getHeaderByHash

openapi-getHeaderByHash POST /
Returns the header for a given block hash.



# getHeaderByNumber
Source: https://docs.qu.ai/build/playground/blocks/getHeaderByNumber

openapi-getHeaderByNumber POST /
Returns the header for a given block number.



# getHeaderhashByNumber
Source: https://docs.qu.ai/build/playground/blocks/getHeaderHashByNumber

openapi-getHeaderHashByNumber POST /
Returns the hash of the block header for a specific block number.



# getPendingHeader
Source: https://docs.qu.ai/build/playground/blocks/getPendingHeader

openapi-getPendingHeader POST /
Returns the current pending block header.



# uncleByHashAndIndex
Source: https://docs.qu.ai/build/playground/blocks/getUncleByBlockHashAndIndex

openapi-getUncleByBlockHashAndIndex POST /
Returns the uncle block for a given block hash and index.



# uncleByNumberAndIndex
Source: https://docs.qu.ai/build/playground/blocks/getUncleByBlockNumberAndIndex

openapi-getUncleByBlockNumberAndIndex POST /
Returns the uncle block for a given block number and index.



# uncleCountByHash
Source: https://docs.qu.ai/build/playground/blocks/getUncleCountByBlockHash

openapi-getUncleCountByBlockHash POST /
Returns the uncle count for a given block hash.



# uncleCountByNumber
Source: https://docs.qu.ai/build/playground/blocks/getUncleCountByBlockNumber

openapi-getUncleCountByBlockNumber POST /
Returns the uncle count for a given block number.



# calculateConversionAmount
Source: https://docs.qu.ai/build/playground/conversion/calculateConversionAmount

openapi-calculateConversionAmount POST /
Returns the amount of Quai in Wei or Qi in Qits left after converting an amount of Qi in Qits to Quai in Wei at the current block exchange rate and after applying the appropriate slip.



# qiToQuai
Source: https://docs.qu.ai/build/playground/conversion/qiToQuai

openapi-qiToQuai POST /
Returns the rate for converting an amount of Qi in Qits to Quai in Wei at a specific block.



# quaiToQi
Source: https://docs.qu.ai/build/playground/conversion/quaiToQi

openapi-quaiToQi POST /
Returns the rate for converting an amount of Quai in Wei to Qi in Qits at a specific block.



# getBlockRlp
Source: https://docs.qu.ai/build/playground/debug/getBlockRlp

openapi-getBlockRlp POST /
Returns the RLP encoded block given its number.



# printBlock
Source: https://docs.qu.ai/build/playground/debug/printBlock

openapi-printBlock POST /
Returns raw data for a block given its number.



# traceTransaction
Source: https://docs.qu.ai/build/playground/debug/traceTransaction

openapi-traceTransaction POST /
Returns the raw trace for a transaction.



# estimateGas
Source: https://docs.qu.ai/build/playground/gas-and-fee/estimateGas

openapi-estimateGas POST /
Estimates the gas required to execute the given transaction



# feeHistory
Source: https://docs.qu.ai/build/playground/gas-and-fee/feeHistory

openapi-feeHistory POST /
Returns the feeHistory for a given a block range.



# gasPrice
Source: https://docs.qu.ai/build/playground/gas-and-fee/gasPrice

openapi-gasPrice POST /
Returns the current gas price.



# setLockupByte
Source: https://docs.qu.ai/build/playground/miner/setLockupByte

openapi-setLockupByte POST /
Changes the coinbase lockup duration for the miner.



# setMinerPreference
Source: https://docs.qu.ai/build/playground/miner/setMinerPreference

openapi-setMinerPreference POST /
Changes the Quai/Qi block reward preference for the miner.



# listening
Source: https://docs.qu.ai/build/playground/net/listening

openapi-listening POST /
Returns an indicator of whether client is listening for network connections.



# peerCount
Source: https://docs.qu.ai/build/playground/net/peerCount

openapi-peerCount POST /
Returns the number of peers currently connected to the client.



# version
Source: https://docs.qu.ai/build/playground/net/version

openapi-version POST /
Returns the devp2p network ID.



# chainId
Source: https://docs.qu.ai/build/playground/other/chainId

openapi-chainId POST /
Returns the current chain ID.



# getProtocolExpansionNumber
Source: https://docs.qu.ai/build/playground/other/getProtocolExpansionNumber

openapi-getProtocolExpansionNumber POST /
Returns the number of dynamic chain expansions that have occurred since the genesis block.



# listRunningChains
Source: https://docs.qu.ai/build/playground/other/listRunningChains

openapi-listRunningChains POST /
Returns an array representation of the currently running chains sorted by shard index.



# nodeLocation
Source: https://docs.qu.ai/build/playground/other/nodeLocation

openapi-nodeLocation POST /
Returns the current node location or context



# JSON-RPC Overview
Source: https://docs.qu.ai/build/playground/overview

Technical specification of Quai Network JSON-RPC API methods and usage.

## Convenience Libraries

While some developers may opt to interact directly with the JSON-RPC API directly, there are also a number of available convenience libraries designed to make data interaction much easier. Convenience libraries abstract much of the complexity of direct client API calls out into simple one-line methods.

|                                                 |                                                                                  |
| ----------------------------------------------- | -------------------------------------------------------------------------------- |
| [Quais SDK](/sdk/introduction)                  | A complete Quai Network interaction library for JavaScript and TypeScript.       |
| [Quai Postman Collection](/build/apis/postman/) | A collection of API requests for Quai Network that can be imported into Postman. |

## Method Groups

<CardGroup>
  <Card title="Addresses" href="/build/playground/addresses" icon="address-card" />

  <Card title="Blocks" href="/build/playground/blocks" icon="cube" />

  <Card title="Transactions" href="/build/playground/transactions" icon="right-left" />

  <Card title="Conversions" href="/build/playground/conversion" icon="right-left" />

  <Card title="Gas and Fees" href="/build/playground/gas-and-fee" icon="gas-pump" />

  <Card title="Transaction Pool" href="/build/playground/txpool" icon="line-columns" />

  <Card title="debug" href="/build/playground/debug" icon="bug" />

  <Card title="Network" href="/build/playground/net" icon="wifi" />

  <Card title="Other" href="/build/playground/other" icon="screwdriver-wrench" />
</CardGroup>

## Conventions

### Local Chain Data

Each zone chain within Quai Network maintains a unique, local set of data. Each address, contract, and transaction made on the network "lives" in a specific zone chain, or a [sharded state](/learn/advanced-introduction/hierarchical-structure/sharding). A general understanding of this concept is required to effectively use the JSON RPC API to query data and interact with the network.

To query data for a specific address, contract, or transaction, you must send your JSON RPC request to the corresponding zone chain. Each zone chain has a unique RPC endpoint URL or port number to communicate with. For example, the RPC endpoint URL for the Cyprus 1 zone chain is `https://rpc.quai.network/cyprus1`, to which you can query data for all Cyprus 1 addresses, contracts, and more. If you attempt to query a node for data that does not exist on the chain you are requesting to (*i.e. requesting a Paxos 1 node for Cyprus 1 address data*), the request will return an error.

### Protobuf Encoding

Quai Network's transaction encoding format has been transitioned from RLP (Recursive Length Prefix) to Protobuf (Protocol Buffers). Protobuf is a language-neutral, platform-neutral, extensible mechanism for serializing structured data, developed by Google. It offers several advantages over RLP, including more efficient serialization, easier backward and forward compatibility, and better support for complex data structures.

This transition **only affects JSON RPC API methods related to sending transactions**. All other methods are unaffected by this change. This allows for ensuring a more robust and streamlined process for sending and signing transactions. The process for composing, signing, and sending a transaction with Protobuf encoding is as follows:

<Steps>
  <Step title="Compose Transaction">Compose the unsigned transaction in JSON format</Step>
  <Step title="Encode Unsigned Transaction">Encode the unsigned transaction in Protobuf</Step>
  <Step title="Sign Transaction">Sign the encoded transaction</Step>
  <Step title="Encode Signed Transaction">Add the signature to the unsigned transaction and encode using Protobuf</Step>
  <Step title="Send Transaction">Send the encoded signed transaction</Step>
</Steps>

### Hexadecimal Encoding

When making calls to a node, data can be passed or returned in two types via JSON. These types are quantities and unformatted byte arrays. Both utilize hex encoding for compact representation but have slightly different formatting requirements.

#### Quantities

When encoding quantities like numbers and integers, use the following format:

* Encode as a hexadecimal
* Prefix all data with "0x"

<Note>*Example*: 21000 in decimal is "0x5208"</Note>

#### Unformatted Data

To encode unformatted data such as addresses, byte arrays, hashes, etc. - use the following format:

* Encode as a hexadecimal
* Prefix with "0x"
* Two hex digits per byte of data, with an even number of digits only

<Note>*Example*: "Hello" is encoded as "0x48656C6C6F"</Note>

### Default Block Parameter

The default block parameter is an extra parameter that can be passed when querying the state of Quai Network. This parameter allows you to specify a specific block or state of Quai that you would like to receive data from. When not passed in a call, this parameter defaults to the height of the most recent block.

Available options for this parameter are:

| Option           | Description                   |
| ---------------- | ----------------------------- |
| `earliest`       | Genesis block                 |
| `latest`         | Most recently mined block     |
| `pending`        | Pending state changes         |
| **Block Number** | Block number to query data at |

The default block parameter can be passed to the following methods:

<CardGroup>
  <Card title="getBalance" href="/build/playground/other/getBalance" />

  <Card title="getProof" href="/build/playground/other/getProof" />

  <Card title="getCode" href="/build/playground/other/getCode" />

  <Card title="getStorageAt" href="/build/playground/other/getStorageAt" />

  <Card title="call" href="/build/playground/other/call" />

  <Card title="estimateGas" href="/build/playground/gas-and-fee/estimateGas" />

  <Card title="getTransactionCount" href="/build/playground/transactions/getTransactionCount" />
</CardGroup>


# call
Source: https://docs.qu.ai/build/playground/transactions/call

openapi-call POST /
Executes a new message call without creating a transaction on chain.



# createAccessList
Source: https://docs.qu.ai/build/playground/transactions/createAccessList

openapi-createAccessList POST /
Creates an access list for the provided transaction.



# blockTxCountByHash
Source: https://docs.qu.ai/build/playground/transactions/getBlockTransactionCountByHash

openapi-getBlockTransactionCountByHash POST /
Returns the transaction count for a block given its hash.



# blockTxCountByNumber
Source: https://docs.qu.ai/build/playground/transactions/getBlockTransactionCountByNumber

openapi-getBlockTransactionCountByNumber POST /
Returns the transaction count for a block given its number.



# rawTxByHashAndIndex
Source: https://docs.qu.ai/build/playground/transactions/getRawTransactionByBlockHashAndIndex

openapi-getRawTransactionByBlockHashAndIndex POST /
Returns the bytecode for a raw transaction given block hash andtransaction index.



# rawTxByNumberAndIndex
Source: https://docs.qu.ai/build/playground/transactions/getRawTransactionByBlockNumberAndIndex

openapi-getRawTransactionByBlockNumberAndIndex POST /
Returns bytecode for a raw transaction given block number and transaction index.



# rawTxByHash
Source: https://docs.qu.ai/build/playground/transactions/getRawTransactionByHash

openapi-getRawTransactionByHash POST /
Returns the bytecode for a raw transaction given its hash.



# txByBlockHashAndIndex
Source: https://docs.qu.ai/build/playground/transactions/getTransactionByBlockHashAndIndex

openapi-getTransactionByBlockHashAndIndex POST /
Returns transaction data given block hash and the transaction index.



# txByBlockAndIndex
Source: https://docs.qu.ai/build/playground/transactions/getTransactionByBlockNumberAndIndex

openapi-getTransactionByBlockNumberAndIndex POST /
Returns transaction data given a block number and the transaction index.



# getTransactionByHash
Source: https://docs.qu.ai/build/playground/transactions/getTransactionByHash

openapi-getTransactionByHash POST /
Returns a transaction and its data for a given transaction hash.



# getTransactionReceipt
Source: https://docs.qu.ai/build/playground/transactions/getTransactionReceipt

openapi-getTransactionReceipt POST /
Returns the receipt of a transaction by transaction hash.



# sendRawTransaction
Source: https://docs.qu.ai/build/playground/transactions/sendRawTransaction

openapi-sendRawTransaction POST /
Creates new message call, transaction, or contract creation for signed transactions.



# content
Source: https://docs.qu.ai/build/playground/txpool/content

openapi-content POST /
Returns the current content of the transaction pool.



# contentFrom
Source: https://docs.qu.ai/build/playground/txpool/contentFrom

openapi-contentFrom POST /
Returns transactions in the txpool from the given address.



# inspect
Source: https://docs.qu.ai/build/playground/txpool/inspect

openapi-inspect POST /
Returns a summarized form of the transaction pool content.



# status
Source: https://docs.qu.ai/build/playground/txpool/status

openapi-status POST /
Returns the current size of the transaction pool.



# Quick Links
Source: https://docs.qu.ai/build/quick-links

Tools and resources for developing on Quai Network.

## Mainnet Infrastructure

|                                                        |                                                                               |
| ------------------------------------------------------ | ----------------------------------------------------------------------------- |
| [Quaiscan Explorer](https://quaiscan.io/)              | The public explorer for Quai Network mainnet.                                 |
| [Quaiscan Documentation](https://docs.quaiscan.io/)    | Documentation for Quaiscan usage, APIs, and more.                             |
| [Network Statistics Page](https://stats.quai.network/) | Mainnet statistics dashboard.                                                 |
| [GraphQL Endpoint](https://graph.quai.network/)        | Mainnet GraphQL endpoint for querying chain data with filters and pagination. |

## Testnet Infrastructure

|                                                         |                                                                     |
| ------------------------------------------------------- | ------------------------------------------------------------------- |
| [Quaiscan Explorer](https://orchard.quaiscan.io/)       | The public explorer for Orchard Testnet.                            |
| [Quaiscan Documentation](https://docs.quaiscan.io/)     | Documentation for Quaiscan usage, APIs, and more.                   |
| [Faucet](https://orchard.faucet.quai.network/)          | The central source for testnet Quai token drips on Orchard Testnet. |
| [GraphQL Endpoint](https://orchard.graph.quai.network/) | Orchard Testnet GraphQL endpoint for querying chain data.           |

## Tooling

|                                                                                              |                                                                          |
| -------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------ |
| [API Playground](/build/playground/overview)                                                 | Playground for interacting with the go-quai JSON-RPC API.                |
| [Local Network Runner](/guides/client/local-node)                                            | A containerized Quai Network instance built for local development.       |
| [Quais SDK](/sdk/introduction.mdx)                                                           | A JavaScript/TypeScript library built for interacting with Quai Network. |
| [Quais SDK npm package](https://www.npmjs.com/package/quais)                                 | The Quais SDK npm package.                                               |
| [Quais + Hardhat](https://github.com/dominant-strategies/hardhat-example/tree/main/Solidity) | Example usage of the Quais SDK with Hardhat.                             |

## Wallets

|                                                                                                                           |                                                                                  |
| ------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------- |
| [Pelagus Website](https://pelaguswallet.io/)                                                                              | The primary wallet for interacting with Quai Network.                            |
| [Pelagus Extension](https://chromewebstore.google.com/detail/pelagus/nhccebmfjcbhghphpclcfdkkekheegop)                    | The most current Pelagus Wallet extension download.                              |
| [Pelagus Extension (Iron Age Version)](https://chromewebstore.google.com/detail/pelagus/gaegollnpijhedifeeeepdoffkgfcmbc) | Older version of Pelagus Wallet that supports the older Iron Age Address format. |
| [Pelagus Docs](https://pelaguswallet.io/docs/)                                                                            | Pelagus Wallet documentation.                                                    |
| [Example Pelagus App](https://github.com/PelagusWallet/pelagus-e2e-dapp)                                                  | Example application using Pelagus Wallet.                                        |

## Smart Contracts

|                                                                                      |                                                                                                 |
| ------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------- |
| [Supported Languages](/build/smart-contracts/languages/)                             | Supported smart contract languages on Quai Network.                                             |
| [Deployment Tutorials](/guides/development/)                                         | Tutorials on how to deploy smart contracts on Quai Network.                                     |
| [Deployment Examples](https://github.com/dominant-strategies/hardhat-example)        | Example repository for deploying smart contracts on Quai Network.                               |
| [quai-hardhat-plugin npm package](https://www.npmjs.com/package/quai-hardhat-plugin) | A plugin built for Hardhat that provides support for deploying smart contracts on Quai Network. |

## Open Source Applications

|                                                                                       |                                                                |
| ------------------------------------------------------------------------------------- | -------------------------------------------------------------- |
| [quai-next-dapp](https://github.com/dominant-strategies/quai-next-dapp)               | Boilerplate application built using Pelagus and Quaiscan APIs. |
| [quai-no-code-deployer](https://github.com/dominant-strategies/quai-no-code-deployer) | No-code smart contract deployment tool for Quai Network.       |
| [pelagus-e2e-dapp](https://github.com/PelagusWallet/pelagus-e2e-dapp)                 | Example application using Pelagus Wallet.                      |


# Deploy
Source: https://docs.qu.ai/build/smart-contracts/deployment

How to deploy a smart contract to the Quai Network.

To deploy a smart contract on Quai Network, you simply send a transaction containing the contract bytecode without specifying a recipient.

Once deployed, your smart contract will be available to any user on the network to interact with.

## How to Deploy a Smart Contract

### Requirements

To deploy a smart contract on Quai, you'll need a few things:

* *QUAI to cover gas*: similar to a normal transaction, you'll need to set your gas limit. Be aware that contract deployment requires significantly more gas than a simple transfer.
* *Contract Bytecode*: generated using a [compiler](https://www.alchemy.com/overviews/solidity-compiler).
* *Deployment script or plugin*
* *Access to a Quai node*: you can do this either by [running your own node](/guides/client/node), [accessing a publicly available node](/build/networks), or through API key via a node service.

### Deployment

Smart contracts on Quai Network can be deployed using a number of different methods. The most straightforward and widely used methods are using deployment tools like Hardhat. Contracts can also be deployed using the quais.js library, which offers increased flexibility and the ability to deploy via frontend or simple script.

Information on how to deploy a simple smart contract with hardhat can be found in the [Solidity Deployment Tutorial](/guides/development/solidity).

## Cross-Chain Smart Contracts

<Warning>
  Documentation for deploying cross-chain smart contracts with SolidityX is
  coming soon. Developers interested in converting their existing contracts to
  be cross-chain compatible in the future should implement upgradeable (proxy)
  patterns.
</Warning>

Contrary to monolithic blockchains, Quai Network's multi-threaded architecture allows for the deployment of cross-chain smart contracts. These are smart contracts present in a single network context that contain references to sister contracts in alternate context(s). Multi-chain referencing smart contracts allow you as a developer to create seamless cross-chain applications that can:

* Asynchronously track the state of contracts within other chains in the network
* Natively transfer value and tokens to different contexts without bridges
* Create a network secured mesh of smart contracts

### Cross-Chain Deployment

Sister contracts are created by deploying contracts across all chains that the project intends to support. After the deployment of these sister contracts, a trust on first-use (TOFU) strategy is used to link the contracts together, allowing each contract to be aware of the state and activities of all of its sisters. Each sister contract contains an objective reference to the public address of every other sister contract.

Contracts intended to function across many chains will contain initially empty slots for the addresses of its sisters. If a contract intends to maintain functionality across the initial network of 9 chains, 8 slots are required for all 8 sister contracts to be referenced.


# Opcode Additions
Source: https://docs.qu.ai/build/smart-contracts/opcode-additions

Specification of the isaddrinternal and etx opcodes additions on Quai Network.

# What Are EVM Opcodes?

Opcodes are the individual low-level instructions that make up a smart contract on the Ethereum Virtual Machine (EVM). Each opcode corresponds to a specific operation that the EVM can perform, such as adding or comparing values in memory, or interacting with the blockchain. Opcodes are executed one at a time in the order they appear in a contract's bytecode. The set of opcodes available on the EVM is fixed and limited, but they provide a powerful set of building blocks for creating complex smart contracts.

## Quai Specific Opcodes

Quai Network's implementation of the EVM introduces two new opcodes for developers to utilize.

<CardGroup>
  <Card title="isaddrinternal" icon="pipe-circle-check">
    Checks if provided address is within smart contract's context.
  </Card>

  <Card title="etx" icon="arrows-cross">
    Emits an external transaction from a smart contract.
  </Card>

  <Card title="convert" icon="arrows-cross">
    Emits an external transaction from a smart contract that converts quai to qi.
  </Card>
</CardGroup>

Each of these opcodes serves a very specific purpose within Quai Network's VM. isaddrinternal allows smart contracts to determine whether a contract interaction can occur entirely within a single context or whether an ETX needs to occur. Based on the boolean response from isaddrinternal, a smart contract can continue on as normal with a local interaction, or can emit an ETX using the etx opcode.

## Assembly Implementation

Solidity does not currently have native compiler support for Quai's additional opcodes that provide cross-chain functionality, but it does have support for [inline assembly usage](https://docs.soliditylang.org/en/latest/assembly.html).

Inline assembly is typically implemented by developers for more fine-grained control over your contract. In the context of Quai, we can use it to directly call opcodes inside of contracts via Yul and Assembly. This allows us to maintain the same general structure as traditional Solidity based contract while implementing simple assembly to provide functionality for Quai specific utilities.

Inline assembly within Solidity is generally straightforward as you can access your contract's variables via normal methods and insert directly into assembly. The syntax for inserting assembly into your contract is as follows:

```solidity theme={null}
function doSomethingWithAssembly() {
    assembly {...}
}
```

More information on case specific syntax, usage and conventions can be found on the Solidity [inline assembly page](https://docs.soliditylang.org/en/latest/assembly.html).

## Examples

<AccordionGroup>
  <Accordion title="isaddrinternal">
    As mentioned above, the `isaddrinternal` opcode is used to verify that an address is within a specific chain's scope. It is most often used in contracts to determine whether the contract should initiate a traditional in-scope transaction or opt for an external transaction.

    Below is a simple implementation of the opcode in a ERC20 smart contract:

    ```solidity theme={null}
    function transfer(address to, uint256 amount) public payable  returns (bool) {
            bool isInternal;
            assembly {
                isInternal := isaddrinternal(to)  // This opcode returns true if an address is internal
            }
            require(isInternal, "Address is external. Use cross-chain transfer function.");
            _transfer(msg.sender, to, amount);
            return true;
        }
    ```

    The `transfer` function handles token transfers between two wallets. Inline assembly and the `isaddrinternal` opcode are used to verify that an address is internal.

    If the check returns true, the function executes the transfer normally. If the check returns false, the transfer is not executed and the user is directed to utilize another function to complete a cross-chain transfer.
  </Accordion>

  <Accordion title="etx">
    External transactions, also called a cross-chain transfers, can be initiated by smart contract via the `etx` opcode.

    A basic example of `etx` implementation in the same ERC20 contract from the isaddrinternal can be seen below. The `crossChainTransfer` function should be called if the check inside of transfer returns false.

    ```solidity theme={null}
    /**
    * This function sends tokens to an address on another chain by creating an external transaction (ETX).
    * This function uses opETX which constructs an external transaction and adds it to the block.
    * The ETX will make its way over to the destination and automatically execute when the given base fee is correct.
    * `to` must be an address on a different chain. The chain of a given address is determined by the first byte of the address.
    * gasLimit, minerTip and basefee are for executing the transaction on the destination chain. Choose these carefully.
    * The base fee and miner tip are in Wei and may not be the same as they are on your current chain.
    * If the base fee or miner tip are too low, the ETX will wait in the destination chain until they are high enough to be added in a block.
    * You must send a value with the function call equal to the following amount: (baseFee + minerTip) * gasLimit
    */
    function crossChainTransfer(address to, uint256 amount, uint256 gasLimit, uint256 minerTip, uint256 baseFee) public payable {
            bool isInternal;
            assembly {
                isInternal := isaddrinternal(to) // This opcode returns true if an address is internal
            }
            require(!isInternal, "Address is not external");

            _burn(msg.sender, amount);
            address toAddr = ApprovedAddresses[getAddressLocation(to)];
            uint totalGas = (baseFee + minerTip) * gasLimit;
            require(msg.value  >= totalGas, string(abi.encodePacked("Not enough gas sent, need at least ", uint2str(totalGas), " wei")));
            bytes memory encoded = abi.encodeWithSignature("incomingTransfer(address,uint256)", to, amount);
            bool success;                                       // this is not used. opETX only returns false if there was an error in creating the ETX, not executing it.
            assembly {
                success := etx(
                    0,                                          // temp variable, can be anything (unused)
                    toAddr,                                     // address to send to
                    0,                                          // amount to send in wei
                    gasLimit,                                     // gas limit (entire gas limit will be consumed and sent to destination)
                    minerTip,                                     // miner tip in wei
                    baseFee,                                      // base fee in wei
                    add(encoded, 0x20),                                          // input offset in memory (the first 32 byte number is just the size of the array)
                    mload(encoded),                                          // input size in memory (loading the first number gives the size)
                    0,                                          // accesslist offset in memory
                    0                                           // accesslist size in memory
                )
            }
            emit ExternalTransfer(msg.sender, to, amount);
    }
    ```

    `crossChainTransfer` utilizes an initial check to ensure that the destination is address is outside of the current context scope. The contract then executes in this fashion:

    <Steps>
      <Step title="Burn">Burns the provided `amount` of tokens on the origin chain.</Step>
      <Step title="Set Destination">Sets the `toAddr` to the public key of a sister contract on the destination chain.</Step>
      <Step title="Calculate Gas">Calculates the `totalGas` provided by the user *and* checks that the provided gas is sufficient to execute the transaction.</Step>
      <Step title="Encode Data">Encodes the transaction data being sent to the destination chain into `encoded`.</Step>
      <Step title="Build the ETX">Constructs the external transaction using the `etx` opcode via inline assembly.</Step>
      <Step title="Send the ETX">Emits the transaction from the contract to be mined on the origin chain and routed to the destination chain.</Step>
    </Steps>
  </Accordion>
</AccordionGroup>

## Conclusion

The `isaddrinternal` and `etx` opcodes provide key cross-chain functionality to
smart contracts deployed on Quai Network. The `convert` opcode provides
functionality to convert tokens from Quai ledger to Qi ledger. They provide the
basis for contracts in different contexts to communicate and interact with each
other in a trustless fashion and allow developers to create multi-chain
applications that span the entire network.


# Solidity
Source: https://docs.qu.ai/build/smart-contracts/solidity

The Solidity smart contract programming language.

## Overview

Solidity is a contract-oriented, high-level programming language for creating smart contracts. It was influenced by C++, Python, and JavaScript and is designed to target the Ethereum Virtual Machine (EVM) environments. Solidity is statically typed, supports inheritance, and libraries. It allows developers to create smart contracts for a wide range of use cases and applications. Key features of Solidity include:

* Complex user-defined types
* Inheritance and complex user-defined contracts
* Error checking, including requirements and assertions
* Support for libraries and user-defined functions
* Strong security features that ensure contract integrity.

<Warning>
  The Quai Network EVM supports Solidity versions up to
  [0.8.19](https://github.com/ethereum/solidity/releases/tag/v0.8.19). Using a
  newer version of Solidity may result in errors when deploying smart contracts.
</Warning>

## Example Contract

The Greeter contract shown below is written with [Solidity v0.8.0](https://docs.soliditylang.org/en/v0.8.0/). Greeter serves two functions:

* Store a greeting on-chain.
* Return the greeting when the contract function is called.

It also contains a function for users to set a new greeting of their choice. While the Greeter contract may be simple, it showcases some of the unique functionality that smart contracts offer.

```solidity Greeter.sol theme={null}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Greeter {
    string private greeting;

    function greet() public view returns (string memory) {
        return greeting;
    }

    function setGreeting(string memory _greeting) public {
        console.log("Changing greeting from '%s' to '%s'", greeting, _greeting);
        greeting = _greeting;
    }
}
```

## Resources

|                                                                              |                                                                      |
| ---------------------------------------------------------------------------- | -------------------------------------------------------------------- |
| [Solidity Homepage](https://soliditylang.org/)                               | The official Solidity homepage.                                      |
| [Solidity Documentation](https://docs.soliditylang.org/en/v0.8.19/)          | The official Solidity documentation.                                 |
| [GitHub](https://github.com/ethereum/solidity)                               | The Solidity GitHub Repository.                                      |
| [Examples](https://docs.soliditylang.org/en/latest/solidity-by-example.html) | Solidity by Example - a collection of example contracts in Solidity. |


# Overview
Source: https://docs.qu.ai/build/transactions/overview

An overview of transactions within Quai Network.

# What Are Transactions?

Transactions are cryptographically signed messages sent to and executed on Zone chains within Quai Network. Regardless of what ledger or chain you are on within the network, every state-changing operation requires a signed transaction.

Transactions are executed independently for each Zone chain and for each ledger (Quai or Qi).

## Transaction Types in Quai Network

Quai Network transactions are split into 3 different types, or categories depending on where they are executed.

<CardGroup>
  <Card title="Type 0: Quai Transaction" icon="list" href="/build/transactions/types#type-0-quai-transaction">
    A transaction executed on the Quai ledger within a single shard.
  </Card>

  <Card title="Type 1: External Transaction" icon="right-left" href="/build/transactions/types#type-1-external-transaction">
    Transactions that cross shards or serve special network functions, such as miner payouts or Quai/Qi conversions.
  </Card>

  <Card title="Type 2: Qi Transaction" icon="sitemap" href="/build/transactions/types#type-2-qi-transaction">
    A transaction executed on the Qi ledger within a single shard.
  </Card>
</CardGroup>


# Types
Source: https://docs.qu.ai/build/transactions/types

Transaction types in Quai Network.

# Overview

Quai Network transactions are split into 3 different types, or categories depending on where they are executed.

* **Type 0: Quai Transaction**: A transaction executed on the Quai ledger within a single shard.
* **Type 1: External Transaction**: Transactions that cross shards or serve special network functions, such as miner payouts or Quai/Qi conversions.
* **Type 2: Qi Transaction**: UTXO style transactions processed on the Qi Ledger.

## Type 0: Quai Transaction

Type 0 transactions are transactions that are executed within a single shard on the Quai ledger. They follow a similar format to traditional EVM transactions and can be used to transfer Quai tokens, interact with a smart contract, or deploy a new smart contract.

### Structure

```json theme={null}
{
	"from": "0x000057fad1aa3fb866a7fbe1f03429dfb1a62456",
	"gas": "0xf618",
	"gasPrice": "0xa410",
	"hash": "0x0002000ff641b8ab3c9f6b356ed2916a77039689d95184635cbfec8ba85b5dbd",
	"input": "0x",
	"nonce": "0x7",
	"to": "0x1228d3ed4aedc881d950726cd9d98d051cc2c643",
	"value": "0x5",
	"type": "0x0",
	"accessList": [],
	"chainId": "0x2328",
	"v": "0x0",
	"r": "0x5b30dbe83dca992a3f9633c305c34a0da4d67a64281c3764fc17a5ecbc9794b7",
	"s": "0x571e56e75b58550c8d9fb64268c4ef53606882155a1a5b73ad344a4605a97a3",
}
```

<Info>For Quai transactions, the `type` field is always `0x0`. </Info>

### Key Properties

* ECDSA signatures (V, R, S)
* Includes `chainID` and `nonce` fields for replay protection
* Support for [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559) style gas pricing
* Includes `accessList` field for [EIP-2930](https://eips.ethereum.org/EIPS/eip-2930) support

## Type 1: External Transaction

Type 1 transactions can be split into 5 sub-types:

* 0  **Cross-Shard Transactions**: Used for transferring value or data between different shards.
* 1  **Coinbase Transactions**: Special transactions that payout block rewards and fees.
* 2  **Conversion Transactions**: Native protocol conversions between Quai and Qi.
* 3  **Coinbase Lockup Transactions**: Used for locking up coinbase rewards on a contract address.
* 4  **Wrapping Qi Transactions**: Used for wrapping Qi tokens on Quai ledger.
* 5  **Conversion Revert Transactions**: Used for conversion etxs that revert and the original amount is refunded.
* 6  **UnWrap Qi Transactions**: Used when Qi is unwrapped from the wrapped qi contract to return the Wrapped Qi back to the Qi ledger.

Type 1 transactions, regardless of subtype, are never directly initiated by a user. They are always intiated directly by the protocol, following either a Type 0 or Type 2 transferring value across shards, a network designated miner payout, or a Quai/Qi conversion also initiated following a Type 0 or Type 2 transaction.

Last 32 bytes of the input field of External Transaction type (Coinbase, Coinbase Lockup) has the workshare hash for which this payment is generated for.

### Structure

```json theme={null}
{
	"originatingTxHash": "0x0002000ff641b8ab3c9f6b356ed2916a77039689d95184635cbfec8ba85b5dbd",
	"etxIndex": "0x3",
	"gas": "0xf618",
	"to": "0x1228d3ed4aedc881d950726cd9d98d051cc2c643",
	"value": "0x5",
	"input": "0x000x0002000ff641b8ab3c9f6b356ed2916a77039689d95184635cbfec8ba85b5dbd",
	"sender": "0x000057fad1aa3fb866a7fbe1f03429dfb1a62456",
	"etxType": "0x0"
}
```

### Key Properties

* Includes `etxType` property to indicate the transaction sub-type. Available subtypes are  `coinbaseLockup`, `wrapQi`, `unwrapQi`, `coinbase`, `conversion`, and `etx`
* Contains the `originatingTxHash` to identify the transaction that initiated the Type 1 transaction
* Includes `ETXIndex` for ordering multiple external transactions from a single origin
* Does not include or require any signatures

## Type 2: Qi Transaction

Type 2 transactions are transactions that are executed within a single shard on the Qi ledger. They follow a similar format to traditional UTXO transactions and can be used to transfer Qi tokens of specific denominations.

Qi Transactions utilize previous unspent outputs of an address as inputs for every transaction.

### Structure

```json theme={null}
{
	"txIns": [
		{
			"PreviousOutPoint": {
				"TxHash": "0x9c26a92ea692273abeaa3a8b0349715938c81bc7a897e496eec1fc3963f4ac32",
				"Index": 0
			},
			"Pubkey": "0x0080017fc240B17F94Ed1a9b7450E9096D43223E"
		}
	],
	"txOuts": [
		{
			"Denomination": 15,
			"Address": "0x1228d3ed4aedc881d950726cd9d98d051cc2c643",
			"Lock": 0
		}
	],
	"txType": 2
}
```

<Info>The `txType` field is always `2` for Qi transactions.</Info>

### Key Properties

* Uses Schnorr and Musig signatures
* UTXO-like input and output transaction structures
* Does not include gas or data related fields


# Lectures & Presentations
Source: https://docs.qu.ai/learn/academic-resources/lectures

A collection of lectures and presentations on the technology powering Quai Network.

## The PoEM Consensus Mechanism: ACSAC 2023 Keynote Presentations

**December 9 2023**

Quai co-founder Dr. K was invited to give a keynote presentation at the 39th Annual Computer Security Applications Conference (ACSAC) in December 2023.

<iframe title="YouTube video player" />

## Mined Transactions: Using PoW to Eliminate MEV

**December 8 2023**

In this recording of Quai University Call #12, Quai co-founder Dr. K explains how Quai Network uses Proof-of-Work to eliminate MEV.

<iframe title="YouTube video player" />

## Intrinsic Value Tokens

**October 16 2023**

In this recording of Quai University Call #11, Quai co-founder Dr. K introduces the concept of "Intrinsic Value Tokens," or tokens derived from real-world assets in a fully decentralized manner.

<iframe title="YouTube video player" />

## Proof-of-Work vs. Proof-of-Stake Consensus

**July 31 2023**

In this recording of Quai University Call #10, Quai co-founder Dr. K explains why Quai Network uses a work-based consensus mechanism (PoEM), rather than a Proof-of-Stake model.

<iframe title="YouTube video player" />

## Eliminating MEV with Mined Transactions

**June 16 2023**

In this recording of Quai University Call #9, Quai co-founder Dr. K details the concept of "mined transactions" for the first time, explaining how they can reduce the impacts of MEV in Quai.

<iframe title="YouTube video player" />

## Sharding in Quai Network

**June 6 2023**

In this recording of Quai University Call #8, Quai co-founder Dr. K explains what kind of sharding is used in Quai Network to achieve infinite scale.

<iframe title="YouTube video player" />

## Subnets in Quai Network

**May 17 2023**

In this recording of Quai University Call #7, Quai co-founder Dr. K dives into subnets: what they are, and how they are used to scale in Quai Network.

<iframe title="YouTube video player" />

## New Technologies Used in Quai

**May 5 2023**

In this recording of Quai University Call #6, Quai co-founder Dr. K goes over the many new technologies that have been implemented to Quai Network.

<iframe title="YouTube video player" />

## PoEM and Perpetual Consensus

**April 26 2023**

In this recording of Quai University Call #5, Quai co-founder Dr. K explains how the Proof-of-Entropy-Minima (PoEM) consensus mechanism enables perpetual consensus amongst Quai nodes.

<iframe title="YouTube video player" />

## An Introduction to Proof-of-Entropy-Minima

**April 10 2023**

In this recording of Quai University Call #4, Quai co-founder Dr. K explains the Proof-of-Entropy-Minima (PoEM) consensus mechanism.

<iframe title="YouTube video player" />

## Security & Interoperability in Disparate Scaling Topologies

**March 22 2023**

With Ethereum adoption the need for scaling solutions to enable high throughput web3 applications is greater than ever. However, current scaling solutions (i.e. optimism, zk-snarks, and rollups) introduce non-obvious security and interoperability challenges that need to be addressed. This talk highlights some of the security and interoperability challenges and proposes a novel mechanism for creating trust-less composable bridges in a multi blockchain environment.

<iframe title="YouTube video player" />

## An Introduction to Multithreaded Execution

**March 10 2023**

Quai Network co-founder Dr. K takes a more advanced look into Quai Network and what sets it apart from other blockchains.

<iframe title="YouTube video player" />

## An Introduction to Cryptocurrency vs. Fiat

**February 6 2023**

Interested in Quai Network and Crypto but don't know where to start? Check out this Quai Network 101 course taught by Dr. K, which also acts as an introduction to why blockchains are important and how Quai Network is taking a revolutionary approach to scaling and security.

<iframe title="YouTube video player" />

## Proof-of-Work vs. Proof-of-Stake Consensus Debate

**November 16 2022**

Texas Blockchain, the undergraduate blockchain organization at the University of Texas at Austin, invited Alan Orwick, co-founder of Quai Network, to join their Layer 1 Consensus debate on November 2nd to advocate on the side of Proof-of-Work. Alan was joined in the debate by representatives from Tron, NEAR, and Hiro.

<iframe title="YouTube video player" />

## BlockReduce: A Method to Scale Blockchain

**December 5 2021**

BlockReduce is the protocol in which Quai Network utilizes to scale blockchains. The BlockReduce began as research at The University of Texas at Austin in 2018. The protocol itself has evolved several times over to where it is now.
This presentation is from the 2018 Texas Blockchain Activities and Research Showcase.

<iframe title="YouTube video player" />


# Whitepapers
Source: https://docs.qu.ai/learn/academic-resources/whitepapers

Research papers and whitepapers that detail fundamental aspects of the Quai protocol.

## Quai Network: Reignite The Crypto Revolution (Litepaper)

**Published 10 October 2024**

A highlevel overview of the first decentralized energy dollar on the only scalable and programmable Proof-of-Work blockchain.

Read the full litepaper on [qu.ai](https://qu.ai/litepaper)

## Optimal Reward Allocation via Proportional Splitting

**Published 13 March 2025**

Following the publication of Bitcoin's arguably most famous attack, selfish mining, various works have introduced mechanisms to enhance blockchain systems' game theoretic resilience. Some reward mechanisms, like FruitChains, have been shown to be equilibria in theory. However, their guarantees assume non-realistic parameters and their performance degrades significantly in a practical deployment setting. In this work we introduce a reward allocation mechanism, called Proportional Splitting (PRS), which outperforms existing state of the art. We show that, for large enough parameters, PRS is an equilibrium, offering the same theoretical guarantees as the state of the art. In addition, for practical, realistically small, parameters, PRS outperforms all existing reward mechanisms across an array of metrics. We implement PRS on top of a variant of PoEM, a Proof-of-Work (PoW) protocol that enables a more accurate estimation of each party's mining power compared to e.g., Bitcoin. We then evaluate PRS both theoretically and in practice. On the theoretical side, we show that our protocol combined with PRS is an equilibrium and guarantees fairness, similar to FruitChains. In practice, we compare PRS with an array of existing reward mechanisms and show that, assuming an accurate estimation of the mining power distribution, it outperforms them across various well-established metrics. Finally, we realize this assumption by approximating the power distribution via low-work objects called "workshares" and quantify the tradeoff between the approximation's accuracy and storage overhead.

Read the full paper on [arxiv.org](https://arxiv.org/abs/2503.10185).

## A Better Proof-of-Work Fork Choice Rule

**Published 9 February 2024**

We propose a modification to the fork choice rule of proof-of-work blockchains. Instead of choosing the heaviest chain, we choose the chain with the most intrinsic work. The intrinsic work of a block is roughly the number of zeroes at the front of its hash. This modification allows us to safely decrease the confirmations required, yielding a 28.5% improvement in confirmation delay or, dually, safely increase the block production rate, yielding a 16.3% improvement in throughput, as compared to the vanilla Bitcoin proof-of-work fork choice rule. Our modification is at the level of the proof-of-work inequality, and thus can be composed with any other methods to improve latency or throughput that have been proposed in the literature. We report the experimental findings by measuring them on a production-grade implementation of our system, whose testnet is already deployed in the wild. Lastly, we formally prove the security of our new protocol in the Bitcoin Backbone model.

Read the full paper on [iacr.org](https://eprint.iacr.org/2024/200).

## PoEM: Proof-of-Entropy-Minima

**Published 8 March 2023**

Nakamoto consensus has been incredibly influential in enabling robust blockchain systems, and one of its components is the so-called heaviest chain rule (HCR). Within this rule, the calculation of the weight of the chain tip is performed by adding the difficulty threshold value to the previous total difficulty. Current difficulty based weighting systems do not take the intrinsic block weight into account. This paper proposes a new mechanism based on entropy differences, named proof of entropy minima (POEM), which incorporates the intrinsic block weight in a manner that significantly reduces the orphan rate of the blockchain while simultaneously accelerating finalization. Finally, POEM helps to understand blockchain as a static time-independent sequence of committed events.

Read the full paper on [arxiv.org](https://arxiv.org/abs/2303.04305).

## Scalable Multi-Chain Coordination via the Hierarchical Longest Chain Rule

**Published in 2022 IEEE International Conference on Blockchain (Blockchain)**

This paper introduces BlockReduce, a Proof-of-Work based blockchain system which achieves high transaction throughput by means of a hierarchy of merged mined blockchains, each operating in parallel on a partition of the overall application state. Most notably, the full PoW available within the network is applied to all blockchains in BlockReduce, and cross-blockchain state transitions are enabled seamlessly within the core protocol. This paper shows that, given a hierarchy of blockchains and its associated security model, BlockReduce scales super-linearly in transaction throughput with the number of blockchains operated by the protocol. BlockReduce utilizes a novel consensus rule to select the canonical chain—i.e., the chain of blocks referencing state updates to be applied—for each blockchain. In Bitcoin and other more traditional systems, the Longest Chain Rule (LCR) stipulates that the canonical chain is the sequence of valid blocks with the most work (often referred to as the longest chain or, more accurately, the heaviest chain). BlockReduce follows a similar rule but must also account for the existence of coincident blocks within the hierarchy.

Read the full paper on [ieee.org](https://ieeexplore.ieee.org/document/9881846).

## Hashcore: Proof-of-Work Functions for General Purpose Processors

**Published in 2019 IEEE 39th International Conference on Distributed Computing Systems (ICDCS)**

Over the past five years, the rewards associated with mining Proof-of-Work blockchains have increased substantially. As a result, miners are heavily incentivized to design and utilize Application Specific Integrated Circuits (ASICs) that can compute hashes far more efficiently than existing general purpose hardware. Currently, it is difficult for most users to purchase and operate ASICs due to pricing and availability constraints, resulting in a relatively small number of miners with respect to total user base for most popular cryptocurrencies. In this work, we aim to invert the problem of ASIC development by constructing a Proof-of-Work function for which an existing general purpose processor (GPP, such as an x86 IC) is already an optimized ASIC. In doing so, we will ensure that any would-be miner either already owns an ASIC for the Proof-of-Work system they wish to participate in or can attain one at a competitive price with relative ease. In order to achieve this, we present HashCore, a Proof-of-Work function composed of "widgets" generated pseudo-randomly at runtime that each execute a sequence of general purpose processor instructions designed to stress the computational resources of such a GPP. The widgets will be modeled after workloads that GPPs have been optimized for, for example, the SPEC CPU 2017 benchmark suite for x86 ICs, in a technique we refer to as inverted benchmarking. We provide a proof that HashCore is collision-resistant regardless of how the widgets are implemented. We observe that GPP designers/developers essentially create an ASIC for benchmarks such as SPEC CPU 2017. By modeling HashCore after such benchmarks, we create a Proof-of-Work function that can be run most efficiently on a GPP, resulting in a more accessible, competitive, and balanced mining market.
Read the full paper on [ieee.org](https://ieeexplore.ieee.org/document/8884814).

## BlockReduce: Scaling Blockchain to Human Commerce

**Published 31 October 2018**

This paper introduces BlockReduce, a Proof-of-Work (PoW) based blockchain system which achieves high transaction throughput through a hierarchy of merged mined blockchains, each operating in parallel on a partition the overall application state. Most notably, the full PoW available within the network is applied to all blockchains in BlockReduce, and cross-blockchain state transitions are enabled seamlessly within the core protocol. This paper shows that, given a hierarchy of blockchains and its associated security model, the protocol scales super-linearly in transaction throughput with the number of blockchains operated by the protocol.

Read the full paper on [arxiv.org](https://arxiv.org/abs/1811.00125).


# Hierarchical Structure
Source: https://docs.qu.ai/learn/advanced-introduction/hierarchical-structure/hierarchical-structure

Detailed specification of Quai Network's hierarchical structure.

## The Scaling Challenge

Traditional blockchains face an impossible choice: stay small and secure, or grow large and vulnerable. Quai's hierarchical structure breaks this limitation.

**The Innovation:**
Imagine a tree where every branch processes transactions independently, but the trunk ensures all branches stay secure. That's Quai's hierarchical structure - multiple blockchain "branches" working in parallel while sharing the security of the entire "tree."

## How It Works

**Three Levels of Organization:**

1. **Prime Chain** (The Trunk): Coordinates the entire network
2. **Region Chains** (Main Branches): Organize geographical areas
3. **Zone Chains** (Leaves): Process your actual transactions

**The Key Breakthrough:**

* **Traditional sharding**: Splits security (dangerous)
* **Quai's approach**: Splits only workload (safe)

Each zone processes transactions independently while maintaining the full security of the entire network through [merged mining](/learn/advanced-introduction/merged-mining/overview).

## Why This Matters

**For Users:**

* **50,000+ TPS**: Process more transactions than Visa
* **Sub-penny fees**: Sustainable even at massive scale
* **5-second blocks**: Near-instant transaction confirmation
* **Global scale**: Ready for billions of users

**For the Network:**

* **Unlimited growth**: Add new zones as demand increases
* **Maintained security**: Every zone has full network protection
* **Optimized performance**: Miners self-organize for best efficiency

## The Security Innovation

**Traditional Sharding Problem:**
When blockchains split into shards, each shard typically gets only a fraction of the security. A network with 10 shards might give each shard only 10% of total security - making them vulnerable to attacks.

**Quai's Solution:**
Through [merged mining](/learn/advanced-introduction/merged-mining/overview), every transaction in every zone receives 100% of the network's security. This maintains the full hash-based security guarantees while allowing unlimited parallel processing.

## Self-Optimizing Performance

**The Latency Problem:**
[Network latency](/learn/advanced-introduction/hierarchical-structure/latency) - the time it takes for data to travel between nodes - is the primary bottleneck in blockchain performance.

**Quai's Unique Solution:**
Miners naturally organize themselves for optimal performance because:

1. **Higher latency = Lower profits** (more uncle blocks)
2. **Miners choose their zone** based on best connection
3. **Result**: Geographic self-organization without central planning

**The Math Behind the Improvement:**

This relationship is described by t = p*n*log\_m(n) where:

* **t** = time to propagation
* **p** = ping time between nodes
* **n** = number of nodes in the network
* **m** = average number of connected peers

**Real-World Example:**

* **Bitcoin**: 8 hops × 100ms ping = 800ms total propagation time
* **Quai zones**: 3 hops × 10ms ping = 30ms total propagation time
* **Improvement**: 25x faster data propagation

This self-organizing system creates naturally optimized regional networks without any central coordination.

## Parallel Processing Power

Think of Quai as a [multi-core processor for blockchains](/learn/advanced-introduction/multithreaded-execution). Each zone chain operates like an independent CPU core, processing transactions in parallel while staying perfectly synchronized.

**How Chains Work Together:**

* **Independent operation**: Each zone produces blocks on its own schedule
* **Perfect coordination**: [Hash linked references](/learn/advanced-introduction/merged-mining/coincident-blocks) keep all chains in sync
* **Atomic operations**: Cross-chain transactions either complete fully or not at all

**The Three-Tier Architecture:**

| Chain Type | Level in Hierarchy | % of Network Hashrate | Block Time† |
| ---------- | ------------------ | --------------------- | ----------- |
| Prime      | 1 (top)            | 100%                  | \~20s       |
| Region     | 2 (middle)         | \~33%                 | \~10s       |
| Zone       | 3 (bottom)         | \~11%                 | \~5s        |

† *Block production in Quai Network is a stochastic process, meaning that real-world block times will have minor variance. These times are calculated for a 2×2 network configuration (2 regions, 2 zones per region, 4 total zones).*

### Starting Simple: Single Shard Launch

**Why Start with One?**
Quai Network launches with a single zone chain because adding unnecessary shards would:

* **Reduce aggregate security**: Splitting hashrate when not needed
* **Increase settlement times**: More complexity without benefit
* **Waste resources**: Running infrastructure for unused capacity

**Automatic Expansion Trigger:**
When sustained demand causes the uncle rate to exceed 20% for an extended period, the network automatically expands by adding new shards. This ensures optimal security and performance at every stage of growth.

### Prime Chain: The Global Coordinator

**Purpose**: Acts as the network's backbone, ensuring all regions stay synchronized (when multiple exist)

* **Security**: Mined by 100% of network hashrate for maximum security
* **Function**: Pure coordination - no transactions or accounts
* **Role**: Becomes active when network expands beyond single shard

### Region Chains: Geographic Organization

**Purpose**: Organize zones within geographical areas for optimal performance (activated during expansion)

* **Security**: Each region gets \~1/N of total hashrate (where N = number of regions)
* **Function**: Coordinate zone chains within their region
* **Activation**: Created when network demand triggers expansion

### Zone Chains: Where Transactions Happen

**Purpose**: The actual workhorses - processing all user transactions

* **Speed**: 5-second average block times for near-instant confirmations
* **Function**: The only chains that store accounts and process transactions
* **Initial state**: Network launches with one zone chain
* **Expansion**: Additional zones added based on demand

Each zone operates as an independent execution thread. As the network grows, this creates a truly [multithreaded blockchain environment](/learn/advanced-introduction/multithreaded-execution).

## Cross-Chain Communication

**The Innovation:**
Through [coincident blocks](/learn/advanced-introduction/merged-mining/coincident-blocks), Quai creates natural bridges between all chains in the network. These hash linked references enable trustless cross-chain transactions without any additional infrastructure.

**How It Works:**

* **Automatic creation**: Merged mining naturally produces these connections
* **Zero overhead**: No extra work required from miners
* **Trustless transfers**: Move assets between chains without intermediaries
* **Atomic operations**: Cross-chain transactions complete fully or not at all

This represents the first truly decentralized bridge between hash-based blockchains, enabling seamless interoperability across the entire network.


# Latency
Source: https://docs.qu.ai/learn/advanced-introduction/hierarchical-structure/latency

How Quai Network optimizes geographical latency in order to scale.

## Why Latency Matters

**The Bottleneck:**
Latency - the time it takes for data to travel across the network - is the #1 factor limiting blockchain scalability. Even with powerful computers, if messages take too long to reach all nodes, the entire network slows down.

**Real-World Impact:**
Think of it like a conference call with participants worldwide:

* **High latency**: Everyone talks over each other, confusion reigns
* **Low latency**: Smooth conversation, everyone stays synchronized

**The Economic Cost:**
In blockchain mining, high latency literally costs money:

1. **Slow miners** find out about new blocks late
2. **Wasted work** on already-solved blocks (uncle blocks)
3. **Lost revenue** from energy spent on invalid blocks

## Three Types of Latency

Quai optimizes all three components that affect overall network speed:

### 1. Network Latency (Biggest Impact)

**What It Is:** Time for data to travel between nodes across the internet

**The Challenge:**

* More nodes = more hops = slower propagation
* Global networks face physical distance limitations
* Traditional blockchains treat this as unsolvable

**Quai's Solution: Economic Self-Organization**

* **Profit motive**: Lower latency to peers = higher mining profits
* **Natural result**: Miners gravitate to their optimal geographic zone
* **No central planning**: Market incentives create perfect organization

**How Miners Self-Organize:**

1. Miner in Asia tries mining US zone → high latency → more uncle blocks → less profit
2. Same miner switches to Asia zone → low latency → fewer uncles → more profit
3. Result: Geographic optimization without any central coordination

<Frame>
  <img />
</Frame>

**PoEM's Additional Advantage:**

* **Single proof consensus**: Only one message needed to reach agreement
* **PoW comparison**: Requires multiple proofs during forks
* **PoS comparison**: Needs multiple rounds of voting
* **Result**: Fastest possible consensus mechanism

### 2. I/O Latency

**What It Is:** Time to read/write data from storage

**The Speed Difference:**

* **RAM access**: \~100 nanoseconds (lightning fast)
* **SSD access**: \~100 microseconds (1000x slower)
* **Impact**: Every disk read slows down block processing

**Quai's Optimizations:**

1. **State trimming**: Keep only essential data to minimize storage needs
2. **RAM optimization**: Cache frequently accessed data in memory
3. **Smart architecture**: Zone isolation prevents state bloat

### 3. Computation Latency

**What It Is:** Time to process and validate transactions

**Quai's Approach:**

* Parallel processing across zones
* Optimized validation algorithms
* Efficient state management

Each optimization compounds, creating a network capable of sustained high performance.

## The Combined Result

**Total Impact:**
By optimizing all three types of latency simultaneously, Quai achieves:

* **50,000+ TPS**: More throughput than major payment networks
* **5-second blocks**: Near-instant transaction confirmation
* **Global scale**: Maintains speed even with worldwide distribution

**The Key Insight:**
Latency optimization isn't just about speed - it's about creating a self-organizing system where economic incentives naturally produce optimal network topology. This makes Quai the first blockchain that gets faster and more efficient as it grows.


# Sharding
Source: https://docs.qu.ai/learn/advanced-introduction/hierarchical-structure/sharding

How sharding is implemented and used to scale in Quai Network.

## Making Blockchains Work Like Modern Databases

Traditional databases solved the scaling problem decades ago through sharding - splitting data across multiple servers. Quai brings this proven approach to blockchain, but with a crucial innovation: maintaining full security across all shards.

## What is Sharding?

**Database Sharding (Traditional):**
Imagine a library that gets too big for one building:

* **Solution**: Split books across multiple buildings (shards)
* **Benefit**: More librarians can help visitors simultaneously
* **Challenge**: Need a system to know which building has which book

**Blockchain Sharding:**
The same concept, but for decentralized networks:

* **Traditional approach**: Split both data AND security (dangerous)
* **Quai's approach**: Split only data, keep security unified (safe)

## How Quai Implements Sharding

**Key Benefits:**

1. **Parallel Processing**
   * Each shard processes transactions independently
   * Like having multiple checkout lines instead of one
   * Result: 50,000+ TPS capacity

2. **Lower Node Requirements**
   * Nodes can choose to track only specific shards
   * Reduces hardware requirements for participation
   * More accessible = more decentralized

3. **Geographic Optimization**
   * Shards naturally organize by region
   * Minimizes latency within each shard
   * Better performance worldwide

## Smart Address System

**The Problem:** How do you know which shard handles which transaction?

**Quai's Solution:** Addresses contain built-in routing information - like ZIP codes for blockchain.

**How It Works:**
Every Quai address has a 9-bit prefix that acts like a postal code:

* **First 4 bits**: Region identifier (like country)
* **Next 4 bits**: Zone within region (like city)
* **Last bit**: Currency type (Quai or Qi)

#### Formatting

The table below specifies the format for each bit in the shard identifier.

| bits 0-3      | bits 4-7    | bit 8             |
| ------------- | ----------- | ----------------- |
| region number | zone number | ledger identifier |

### Simple Examples

| Example Address (shortened) | Location          | Currency |
| --------------------------- | ----------------- | -------- |
| 0x000...                    | Region 0, Zone 0  | Quai     |
| 0x2A4...                    | Region 2, Zone 10 | Quai     |
| 0x008...                    | Region 0, Zone 0  | Qi       |

**Benefits:**

* **Instant routing**: Nodes immediately know where to send transactions
* **No lookups needed**: Address itself contains all routing info
* **Efficient processing**: Eliminates cross-shard confusion

For technical details, see [QIP-2](https://github.com/quai-network/qips/blob/master/qip-0002.md).

## The Security Breakthrough

**Traditional Sharding's Fatal Flaw:**

* 10 shards = each gets 1/10th of security
* Attackers can focus on the weakest shard
* Like having 10 weak locks instead of one strong lock

**Quai's Innovation:**
Through [coincident blocks](/learn/advanced-introduction/merged-mining/coincident-blocks) and merged mining:

* Every shard maintains 100% network security
* Attacking one shard requires attacking the entire network
* Like having the same unbreakable lock protecting every door

**How It Works:**

1. **Hierarchical structure** organizes all shards
2. **Hash linked references** connect every chain
3. **Atomic operations** ensure all shards advance together
4. **Result**: Unlimited shards, uncompromised security

## Legacy Testnet Mappings

Early testnets use a lighter 9-shard hierarchy. It has already been concluded that the mainnet should accommodate more than 9 shards, so this mapping is no longer recommended. We make note of it here for wallet compatibility with early testnets.

To find the address shard specification in detail please visit [QIP-4](https://github.com/quai-network/qips/blob/master/qip-0004.md).


# External Transactions (ETXs)
Source: https://docs.qu.ai/learn/advanced-introduction/interoperability/etxs

How cross-chain transactions are processed in Quai Network.

## Understanding External Transactions

In most blockchain networks, moving assets between chains is a complex process involving wrapped tokens, bridge operators, and significant trust assumptions. Users often lose funds to bridge hacks, experience long delays, or pay excessive fees. External Transactions (ETXs) in Quai Network represent a fundamental reimagining of how blockchains can communicate.

An ETX is a native cross-chain transaction that moves value between Quai zones without any external dependencies. These transactions leverage the same hash-linked references that keep all chains synchronized, making them as secure as regular on-chain transfers. No bridge operators, no wrapped tokens, no trust assumptions - just pure cryptographic guarantees.

**The Journey of an ETX:**
Every ETX follows a deterministic path through Quai's hierarchy. Like water flowing through a river system, transactions always flow up to a confluence point (dominant chain) before flowing back down to their destination. This predictable routing ensures security while maintaining efficiency.

ETXs always pass through a dominant chain in the hierarchy, whether it be a Region chain or the Prime chain. The following diagrams illustrate these two routing patterns:

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

## How ETXs Navigate the Network

Understanding how ETXs move through Quai's hierarchy is crucial for developers and users alike. The system is designed to be both secure and efficient, ensuring that cross-chain transfers complete reliably without creating bottlenecks in the network.

Each ETX begins its journey on what we call the "origin chain" - the zone where the transaction is initiated. The final destination is appropriately called the "destination chain." Between these two points, the transaction follows a specific path: up through the hierarchy to a shared dominant chain, then back down to the destination. This routing happens automatically based on the destination address.

**Two Types of Cross-Chain Operations:**
Quai supports two distinct types of ETXs, each serving different use cases:

1. **Account-initiated ETXs**: Regular users sending assets between zones
2. **Contract-initiated ETXs**: Smart contracts triggering cross-chain operations programmatically

**Efficiency Through Innovation:**
Traditional cross-chain systems process each transaction individually, creating significant overhead. Quai implements an innovative rollup mechanism that batches ETX data in block headers. This forward propagation system reduces processing requirements by more than 30x, enabling the network to handle massive cross-chain volume without congestion. Think of it like a cargo ship carrying many packages instead of sending individual boats for each delivery.

## Account-Initiated ETXs: User Transfers

Account-initiated ETXs represent the most common type of cross-chain transaction - users moving their assets between zones. These transactions follow a predictable two-phase process that ensures security while maintaining reasonable speed. Understanding this process helps users set appropriate expectations for cross-chain transfers.

The journey begins when a user initiates a transfer to an address on a different zone. The network automatically recognizes this as a cross-chain operation based on the destination address format and begins the ETX process. From the user's perspective, they simply specify the recipient address and amount - the complexity is handled entirely by the protocol.

### Phase 1: Moving Up the Hierarchy

The first phase involves moving the transaction data up through the network hierarchy until it reaches a chain that can coordinate with the destination zone. This upward propagation follows these steps:

1. **Initial broadcast**: The transaction is submitted to the origin zone as a standard internal transaction
2. **Local processing**: Miners on the origin zone include the transaction in a block, removing the balance from the sender and creating one or more ETXs
3. **Upward propagation**: The ETX data is forwarded to dominant chains in the hierarchy
4. **Coincident block collection**: When coincident blocks occur, dominant chains collect all pending ETXs from their subordinate zones
5. **Continued escalation**: If the destination requires coordination through an even higher chain (like Prime), the process repeats upward

### Phase 2: Objective Canonicalization and Delivery

Once the ETX reaches the coordination point, the critical process of objective canonicalization begins. This phase leverages Quai's hash-linked reference system to ensure that only valid, canonical ETXs are executed:

1. **Hash-linked reference creation**: When coincident blocks are found, pending ETXs are collected from each hash in the subordinate manifest of each block since the last coincident block from the same location
2. **Objective canonicalization**: All ETXs destined for the current chain or subordinate chains are identified and become referenceable through these objective hash-linked proofs
3. **Precomputed state propagation**: The canonicalized ETXs are propagated to the destination chain, where they're added to the pending ETX set and become available for mining
4. **Final execution with proof**: The ETX is included in a block on the destination chain only after the objective hash reference proves the canonicalization of the emitted ETX, adding the balance to the receiving address

This process ensures that every cross-chain transfer maintains the same security guarantees as local transactions, with mathematical proof of validity rather than trust-based assumptions. The entire process typically completes within minutes while providing cryptographic certainty.

## Contract-Initiated ETXs: Smart Contract Interactions

Contract-initiated ETXs enable smart contracts to trigger cross-chain operations programmatically, unlocking sophisticated multi-chain applications. The process leverages the same objective hash-linked reference system that ensures security, but adds smart contract logic to determine when cross-chain operations are needed.

### Phase 1: Smart Contract Logic and Upward Propagation

Smart contracts use specialized opcodes to make cross-chain decisions and emit ETXs when necessary:

1. **Contract interaction initiation**: A user calls a contract function, potentially triggering the ISADDRINTERNAL convenience opcode to check address locality
2. **Cross-chain decision**: If ISADDRINTERNAL returns FALSE (indicating a cross-chain address) or other contract logic is triggered, the contract emits ETXs using OP\_ETX
3. **Hierarchical propagation**: The ETX(s) are propagated to dominant peers in the hierarchy
4. **Coincident block collection**: When coincident blocks are found, dominant peers collect all pending ETXs through the subordinate manifest linkage
5. **Continued escalation**: If the destination chain has a dominant chain (i.e., is a region chain), steps 3 and 4 repeat upward

### Phase 2: Objective Canonicalization and Execution

The downward phase relies on Quai's unique system of objective hash references to ensure ETX validity:

1. **Hash-linked reference creation**: When coincident blocks occur, pending ETXs are collected from each hash in the subordinate manifest of each block since the last coincident block
2. **Objective canonicalization**: ETXs destined for the current chain or subordinate chains are identified and become referenceable through these hash-linked proofs
3. **Precomputed state availability**: The pending ETXs are propagated to the destination chain and added to the pending ETX set, available for mining
4. **Final execution with proof**: The ETX is included in a destination chain block only after the objective hash reference proves the canonicalization of the emitted ETX

This system ensures that contract-initiated cross-chain operations maintain the same security guarantees as local transactions while enabling complex multi-chain application logic.

## Forward Propagation of ETX Rollups

One of Quai's key innovations is its efficiency in handling large volumes of cross-chain transactions. Traditional systems process each cross-chain operation individually, creating significant computational overhead. Quai implements a sophisticated rollup mechanism that batches and pre-processes ETX data, reducing computational requirements by more than 30x while maintaining security.

**Block Header Data Fields:**
Each Quai block header contains two specialized fields for ETX management:

* **etxTransactions**: A list of hashes, where each hash represents a unique ETX emitted from that specific block
* **etxRollupRoot**: A single hash representing a cumulative rollup of all ETXs emitted since the previous coincident block

**Precomputed State Transitions:**
The etxRollupRoot field is propagated to coordinate blockchains at each point of local consensus, enabling destination chains to precompute state transitions before the ETX is canonicalized. This preparation dramatically reduces processing time when the ETX eventually arrives for execution.

**Critical Security Constraint:**
It is essential to understand that precomputed state transitions are not referenceable or canonicalized until an objective hash-linked reference between the origin and destination chain is provided. This ensures that only canonical ETXs can affect chain state, preventing any possibility of invalid or fraudulent cross-chain operations.

**The Subordinate Block Manifest:**
Hash-linked references are created through a specialized data field called the subordinate block manifest (subManifest). This field remains empty in regular blocks but becomes crucial in coincident blocks, where it contains a complete list of all subordinate block hashes produced since the prior coincident block. This creates direct, objective references to all subordinate blocks within each dominant blockchain, establishing the hash-linked references that secure the entire Quai Network.

The moment a hash-linked reference is provided to a coordinate context that has received a precomputed transition set, the ETX becomes canonically verifiable and the state transition becomes referenceable and executable. This system provides the perfect balance of efficiency and security for cross-chain operations.


# Overview
Source: https://docs.qu.ai/learn/advanced-introduction/interoperability/overview

Specifications of Quai Network's interoperability between shards.

## One Network, Many Chains

In traditional blockchain systems, moving assets between chains requires complex bridges, trusted intermediaries, and significant risk. Users often wait hours or days for cross-chain transfers, paying high fees while hoping their funds don't get stuck or lost. Quai Network fundamentally reimagines how blockchains communicate with each other.

Imagine having bank accounts in different countries but being able to instantly transfer money between them without any intermediaries, exchange desks, or wire transfer delays. That's what Quai's native interoperability enables - every zone can seamlessly communicate with every other zone as if they were all part of the same system (because they are).

**The Problem with Traditional Multi-Chain:**
Traditional blockchain networks operate as isolated islands. When you need to move assets between chains, you typically rely on:

* Third-party bridges with trusted operators
* Wrapped tokens that can lose their peg
* Complex multi-signature schemes
* Slow confirmation times across multiple networks

**Quai's Native Solution:**
Quai doesn't bolt on interoperability as an afterthought - it's built into the core protocol. Through [External Transactions (ETXs)](/learn/advanced-introduction/interoperability/etxs), assets move between zones using the same [hash linked references](/learn/advanced-introduction/merged-mining/coincident-blocks) that keep all chains synchronized. This means cross-chain transfers are as secure and reliable as regular transactions.

**Real-World Benefits:**

* **No bridge risk**: Pure mathematics ensures security, not committees or validators
* **Atomic transfers**: Transactions either complete fully or not at all - funds never get stuck
* **Native speed**: Cross-chain transfers complete in minutes, not hours or days
* **Universal applications**: Smart contracts can operate across all zones seamlessly

**Built-In Security:**
The hierarchical structure ensures complete consistency across all chains. If any chain experiences a reorganization (extremely rare), all subordinate chains automatically adjust to maintain network-wide consensus. This atomic behavior makes double-spend attacks impossible, even across chains.

## External Transactions (ETXs)

External Transactions represent a breakthrough in blockchain interoperability. Unlike traditional cross-chain methods that rely on external validators, oracles, or bridge operators, ETXs use the same mining process that secures the network to also facilitate cross-chain transfers. This elegant solution eliminates the need for any trusted third parties.

Think of ETXs like sending a package through a postal system with perfect tracking. Your package (transaction) travels from your local post office (origin zone) up to a regional hub (dominant chain), then back down to the recipient's local office (destination zone). The difference is that this entire journey is cryptographically guaranteed and happens in minutes, not days.

**How ETXs Work:**
Every ETX follows a predictable path through Quai's hierarchy. The transaction starts in the origin zone, travels up to a shared dominant chain (either a region or prime chain), then descends to the destination zone. This routing is automatic and requires no user intervention - you simply specify the destination address, and the network handles the rest.

**Two Types of ETXs:**

1. **Account-initiated**: Regular users sending assets across chains
2. **Contract-initiated**: Smart contracts triggering cross-chain operations

The addition of [new EVM opcodes](/build/smart-contracts/opcode-additions) enables smart contracts to seamlessly interact across chains, opening possibilities for truly distributed applications that aren't confined to a single zone.

## Multi-Chain Contracts

Traditional blockchain applications are trapped on single chains, forcing users to bridge assets just to interact with different protocols. This fragmentation creates a poor user experience and limits the potential of decentralized applications. Quai's multi-chain contract system changes this paradigm entirely.

Imagine a decentralized exchange that isn't confined to one blockchain but operates seamlessly across an entire network. Users in any zone can trade with liquidity from any other zone, all through the same interface. This isn't science fiction - it's what Quai's architecture enables today.

**How Multi-Chain Contracts Work:**
Contracts deployed on different Quai chains can be interlinked to share state and functionality. This creates a unified application layer that spans the entire network. Projects no longer need to choose which chain to deploy on or maintain separate deployments - they can create truly global applications accessible from anywhere in the network.

**Real Example:**
A user in Cyprus-1 can directly call a function on a contract deployed in Paxos-2. If this is a token minting function, the newly minted tokens can be automatically sent back to the user's Cyprus-1 address. The entire interaction happens seamlessly, as if both the user and contract were on the same chain.

**Benefits for Developers:**

* Deploy once, accessible everywhere
* Unified liquidity across all zones
* No need to maintain multiple deployments
* Reduced complexity and operational overhead

## Atomicity

In traditional cross-chain systems, transactions can fail halfway through, leaving funds stuck in limbo or creating inconsistent states across chains. This partial failure problem has plagued blockchain interoperability since its inception. Quai solves this fundamental issue through guaranteed atomicity.

Atomicity is a key tenet of Quai's interoperability. An atomic process is one that either fully completes or doesn't occur at all - there's no in-between state. Think of it like a vending machine: either you get your snack and the machine takes your money, or nothing happens. You never end up with the machine keeping your money without giving you the product.

**How Atomicity Works in Quai:**
The PoEM consensus mechanism ensures that all chains in the network move forward (and if necessary, roll back) in perfect coordination. This means that even complex cross-chain operations maintain atomicity. If any part of a multi-chain transaction fails, the entire operation is reversed across all affected chains.

**Why This Matters:**

* **No stuck funds**: Transactions either complete or funds return to sender
* **Consistent state**: All chains always agree on the current state
* **Trustless operations**: No need to trust that a bridge will complete your transfer
* **Simplified development**: Developers can build complex cross-chain logic without worrying about partial failures

This atomic guarantee extends to everything in Quai - simple transfers, complex smart contract interactions, and even multi-chain contract calls. It's the foundation that makes Quai's interoperability truly reliable.


# Liquid Mining Tokens & Locked Mining Rewards
Source: https://docs.qu.ai/learn/advanced-introduction/liquid-mining-tokens

How Quai Network enhances mining incentives and network security through innovative reward mechanisms.

## Two Innovations for Mining Economics

Quai introduces two complementary systems that revolutionize mining economics: Locked Mining Rewards (LMR) and Liquid Mining Tokens (LMT). Together, they solve a fundamental challenge in GPU mining networks - creating long-term miner commitment similar to ASIC networks while maintaining capital flexibility.

**The GPU Mining Challenge:**
GPU miners can easily switch between networks, creating security vulnerabilities. Unlike ASIC miners who invest in network-specific hardware, GPU miners have no long-term capital commitment. This makes GPU networks more vulnerable to attacks from rental hashrate or opportunistic miners.

**Quai's Dual Solution:**

1. **Locked Mining Rewards (LMR)**: Incentivizes long-term commitment through enhanced yields
2. **Liquid Mining Tokens (LMT)**: Provides liquidity for miners who need immediate capital

This combination creates ASIC-like security commitment in a GPU-friendly network.

<Frame>
  <img />
</Frame>

## Locked Mining Rewards (LMR): Building Long-Term Security

Locked Mining Rewards allow miners to voluntarily lock their block rewards (coinbase) for extended periods in exchange for significantly higher yields. This creates the economic commitment that GPU networks traditionally lack.

**How LMR Works:**
When a miner successfully mines a block, they can choose to:

* **Standard maturity**: Receive rewards after 2 weeks (no bonus)
* **3-month lock**: Earn enhanced rewards with longer commitment
* **6-month lock**: Earn even higher rewards for extended commitment
* **12-month lock**: Maximize rewards with up to 25% APY for full-year commitment

**Security Benefits:**
LMR creates ASIC-like network security without specialized hardware:

* **Capital commitment**: Miners have real economic stake in network's future
* **Attack resistance**: Locked rewards make hit-and-run attacks unprofitable
* **Hashrate stability**: Long-term commitments reduce mining volatility
* **Aligned incentives**: Miners benefit from network growth over lock period

The longer lock periods and higher rewards create a powerful incentive for miners to commit to Quai's long-term success, dramatically improving network security compared to traditional GPU mining.

## Liquid Mining Tokens (LMT): Maintaining Capital Efficiency

While LMR creates security through commitment, many miners can't afford to lock capital for months. Liquid Mining Tokens solve this by creating a secondary market for locked rewards.

**How LMT Works:**

1. **Miner locks rewards**: Chooses LMR for higher yields
2. **Receives LMT tokens**: Wrapped version of their locked rewards
3. **Can trade immediately**: Sell LMTs on markets for immediate liquidity
4. **Market pricing**: LMTs trade based on time to maturity and yield

**Capital Benefits:**

* **Immediate liquidity**: Miners can access capital without waiting
* **Competitive pricing**: Market forces ensure fair value discovery
* **Operational flexibility**: Pay bills while earning enhanced yields
* **Risk management**: Option to hold or sell based on market conditions

This system allows miners with different capital positions to participate optimally - well-capitalized miners can hold for full yields, while others can trade LMTs for immediate cash flow.

## LMR Reward Schedule: Incentivizing Commitment

The reward multipliers are carefully designed to balance miner incentives with network sustainability. Early miners receive the highest bonuses, encouraging early adoption and long-term commitment when the network needs it most.

| Lock Duration | Year 1    | Year 2    | Year 3    | Year 4    | Year 5+   |
| ------------- | --------- | --------- | --------- | --------- | --------- |
| 2 weeks\*     | 1.000000x | 1.000000x | 1.000000x | 1.000000x | 1.000000x |
| 3 months      | 1.035000x | 1.017500x | 1.008750x | 1.004375x | 1.002188x |
| 6 months      | 1.100000x | 1.050000x | 1.025000x | 1.012500x | 1.006250x |
| 12 months     | 1.250000x | 1.125000x | 1.062500x | 1.031250x | 1.015625x |

\*Standard 2-week maturity period with no lock bonus

**Key Insights:**

* **Year 1 advantage**: Up to 25% APY rewards early network supporters
* **Gradual reduction**: Multipliers decrease as network matures
* **Long-term sustainability**: Ensures viable economics throughout network lifecycle
* **Clear incentives**: Longer locks always yield higher rewards

This structure creates powerful early incentives while ensuring the network remains economically sustainable as it grows.

## DeFi Integration: Creating a Mining Finance Ecosystem

The LMT system opens up entirely new DeFi possibilities. Since LMTs are standardized tokens representing future mining yields with specific maturity dates, they become building blocks for sophisticated financial products.

**Potential DeFi Applications:**

**1. LMT Trading Markets:**

* **Spot markets**: Direct buying/selling of LMTs
* **Time-based pricing**: Different prices for different maturities
* **Arbitrage opportunities**: Between lock durations and yields
* **Price discovery**: Market determines fair value of future rewards

**2. Lending & Borrowing:**

* **Collateralized loans**: Use LMTs as collateral for immediate liquidity
* **Yield optimization**: Borrow against LMTs at rates lower than lock bonus
* **Risk management**: Hedge mining operation costs

**3. Structured Products:**

* **LMT bundles**: Diversified portfolios of different maturities
* **Yield ladders**: Staggered maturity dates for consistent cash flow
* **Mining funds**: Professional management of LMT portfolios

**The Bigger Picture:**
This creates a complete mining finance ecosystem where:

* Small miners can access capital markets efficiently
* Large operations can optimize their treasury management
* DeFi protocols gain access to real yield from mining
* The entire network benefits from improved capital allocation

The LMR/LMT system transforms mining from a simple block reward system into a sophisticated financial ecosystem that benefits all participants.


# Coincident Blocks
Source: https://docs.qu.ai/learn/advanced-introduction/merged-mining/coincident-blocks

How merge-mined blocks are used to transfer state across blockchains in Quai Network.

## The Natural Bridges Between Chains

Imagine rolling dice and occasionally getting lucky enough to win multiple games at once. That's essentially what coincident blocks are - mining solutions that satisfy multiple blockchain requirements simultaneously.

**What Makes Them Special:**

* **No extra work required**: They occur naturally through normal mining
* **Mathematically guaranteed**: Not reliant on validators or committees
* **Perfect synchronization**: Chains stay connected through pure probability

**How They Enable Cross-Chain Transactions:**
When a coincident block occurs, it creates an unbreakable mathematical link between chains. This link serves as a trustless bridge, allowing assets and data to move between chains without any intermediary.

## The Mathematics of Luck

**Simple Analogy:**

* Zone difficulty: Need to roll a 6
* Region difficulty: Need to roll two 6s
* Prime difficulty: Need to roll three 6s

Sometimes you roll three 6s when you only needed one - that's a coincident block!

**Probability Table:**

| How "Lucky" Was the Block?      | Chance of Occurrence |
| ------------------------------- | -------------------- |
| Slightly lucky (1 extra zero)   | 50%                  |
| Pretty lucky (2 extra zeros)    | 25%                  |
| Very lucky (3 extra zeros)      | 12.5%                |
| Extremely lucky (4 extra zeros) | 6.25%                |

**Why This Matters:**
Unlike other multi-chain systems that rely on committees, validators, or complex protocols, Quai's cross-chain bridges are created by pure mathematics. No trust required - just probability.

## How Coincident Blocks Work

**Key Principles:**

1. **Hierarchy matters**: Prime blocks are always coincident (they satisfy all chains)
2. **Independence preserved**: Zones can produce blocks without waiting
3. **Atomic validity**: A block must be valid everywhere or nowhere
4. **Perfect synchronization**: All chains append coincident blocks simultaneously

**The Chain Hierarchy:**

* **Prime blocks**: Always coincident (like a master key opening all locks)
* **Region blocks**: Coincident with their zones
* **Zone blocks**: Usually independent, occasionally coincident

**Why Different Block Times?**

* Prime: \~20 seconds (slow but ultra-secure)
* Region: \~10 seconds (balanced)
* Zone: \~5 seconds (fast for users)

This design ensures zones can operate quickly while still maintaining periodic synchronization through coincident blocks.

## Running a Node

**Minimum Requirement - A "Slice":**
The smallest node a miner can run is a slice node. To participate trustlessly, you need:

* The prime chain (global coordination)
* One region chain (regional coordination)
* One zone chain (where transactions happen)

This "slice" gives you everything needed to verify transactions without trusting anyone else.

**The Beauty of the System:**
Coincident blocks create a trustless, automatic, and mathematically guaranteed way for multiple blockchains to stay synchronized and share security - all through the natural randomness of mining.


# Energy Efficiency
Source: https://docs.qu.ai/learn/advanced-introduction/merged-mining/energy-efficiency

How Quai Network efficiently uses energy compared to other consensus mechanisms.

## 10,000x More Efficient Than Bitcoin

**The Simple Math:**

* **Bitcoin**: 1 computer → 1 chain → 5 transactions per second
* **Quai**: 1 computer → 3 chains → 50,000 transactions per second

Same energy input, 10,000x more useful output. That's the power of merged mining combined with sharding.

**Your Impact:**

* **Bitcoin transaction**: \~487 kWh (powers a home for 2 weeks)
* **Quai transaction**: \~0.05 kWh (charges your phone twice)

## How We Achieved This

**Three Innovations Working Together:**

1. **Merged mining**: Mine 3 chains with one computation
2. **Sharding**: Process transactions in parallel
3. **PoEM consensus**: Eliminate wasted work from forks

**The Result:**
The most energy-efficient Proof-of-Work blockchain ever created, without sacrificing security.

## Why Energy Matters

Energy expenditure is the only known objectively verifiable mechanism to link the security and scarcity of a currency to the
constraints of the physical world. The scarcity of rare Earth metals is protected only by the limited profitability of expending energy
to physically extract those metals from the Earth or space. The scarcity of fiat currencies is ensured by indirect energy spends in the
form of politics, bureaucracies, and armed conflict.

**The Physics of Value:**
Everything valuable requires energy to create or protect:

* **Gold**: Energy to mine and refine
* **Fiat currency**: Energy spent on politics, bureaucracies, and armed conflict
* **Bitcoin**: Energy to compute and secure

Energy expenditure is the only objectively verifiable mechanism to link security and scarcity to the physical world.

**Quai's Philosophy:**
We don't try to eliminate the energy-value connection (that's impossible). Instead, we optimize it to get maximum utility from every joule spent.

**Efficiency Gains:**

1. **Hash reuse**: Every computation checks 3 difficulty levels
2. **Fork elimination**: No energy wasted on orphaned blocks
3. **Optimized routing**: Miners self-organize for minimal latency
4. **Result**: Same security, fraction of the energy per transaction

## Environmental Benefits of Proof-of-Work

Proof-of-Work creates strong incentives that align miners and the global environment. This relationship is commonly misunderstood - PoW mining actually drives renewable energy adoption because miners need the cheapest possible energy, which increasingly means renewables.

Unlike data centers or factories that require constant, reliable power, miners can operate with intermittent energy. This unique flexibility makes them perfect partners for renewable energy grids.

### Renewable Energy Partnership

The integration of renewable energy into electrical grids creates a challenge: solar panels produce energy when the sun shines (not always when needed) and wind turbines generate power when wind blows (unpredictable). Grids must maintain perfect balance between supply and demand or risk blackouts.

Mining provides an elegant solution by offering flexible demand that can instantly adjust to energy availability. Miners can consume excess renewable energy that would otherwise be wasted and can reduce consumption during peak demand. In Texas (July 2022), Bitcoin miners using 1 GW of power instantly reduced consumption during a heat wave, helping prevent grid failure and demonstrating mining's value as a grid stabilization tool.

### Stranded Energy Recovery

Proof-of-Work mining provides a unique solution for stranded energy - energy resources that cannot be economically utilized due to lack of infrastructure. Examples include methane flaring at remote oil wells, isolated hydroelectric dams without transmission lines, and landfill gas emissions.

Currently, regulatory agencies require venting or flaring of stranded methane to reduce environmental impact, but this still creates significant emissions. The Department of Energy has specifically called for "modular technologies that are inexpensive to build and can be easily moved" to convert stranded gas into value.

Mining operations offer exactly this solution: portable, modular containers that can profitably consume stranded energy anywhere. Instead of flaring methane into the atmosphere, mining converts it into computational work and economic value, significantly reducing environmental impact while creating economic incentives for capture rather than release.

### Driving Energy Innovation

The competitive nature of mining creates a powerful incentive for energy innovation. Miners constantly seek the most efficient energy sources to maintain profitability, creating a natural selection pressure favoring renewable energy development.

This dynamic is already visible in practice. University of Cambridge research found that 39% of Bitcoin mining uses renewable energy, primarily hydroelectric. By 2021, the Bitcoin Mining Council reported this figure had risen to 57% - achieved without any regulatory mandates, purely through economic incentives.

As renewable energy costs continue to decline relative to fossil fuels, this trend accelerates. Miners' relentless pursuit of cheaper energy directly funds and incentivizes renewable energy development, creating a positive feedback loop that benefits both the mining industry and global sustainability efforts.

## The 10,000x Calculation

**Assumptions:**

1. Equal total energy usage between Bitcoin and Quai networks
2. Both networks operating at maximum capacity

**Bitcoin:**

* Maximum throughput: 5 transactions per second
* Annual transactions: 157.7 million
* Energy per transaction: **486.62 kWh**

**Quai:**

* Maximum throughput: 50,000 transactions per second
* Annual transactions: 1.58 trillion
* Energy per transaction: **0.05 kWh**

**Result:** Quai is 9,732x more energy efficient per transaction than Bitcoin


# Overview
Source: https://docs.qu.ai/learn/advanced-introduction/merged-mining/overview

How merged mining has been adapted and used to scale in Quai Network.

## Mining Multiple Chains with One Computer

Imagine if you could solve three different puzzles with a single guess - that's merged mining. Invented by [Satoshi Nakamoto in 2010](https://bitcointalk.org/index.php?topic=1790.msg28696#msg28696), Quai has revolutionized this concept to create the most efficient blockchain network ever built.

**The Innovation:**

* **Traditional mining**: One computer, one chain, limited throughput
* **Quai merged mining**: One computer, three chains, 10,000x more efficient than Bitcoin\*

**Key Benefits:**

1. **Shared security**: All chains protected by full network hashrate
2. **Automatic bridges**: Cross-chain transactions without intermediaries
3. **Maximum efficiency**: [10,000x better energy usage](/learn/advanced-introduction/merged-mining/energy-efficiency) per transaction

## How It Works

**Simple Explanation:**
When a miner generates a potential solution (nonce), they check it against three different difficulty levels:

1. **Prime chain**: Hardest difficulty (like rolling three sixes)
2. **Region chain**: Medium difficulty (like rolling two sixes)
3. **Zone chain**: Easiest difficulty (like rolling one six)

**The Magic:**

* Same computation, triple the results
* No extra energy needed
* All chains stay perfectly synchronized

**Technical Note:**
All Quai chains use the [ProgPoW algorithm](/client/miner#progpow-hashing-algorithm) - GPU-friendly and ASIC-resistant.

## Natural Cross-Chain Bridges

**What are [Coincident Blocks](/learn/advanced-introduction/merged-mining/coincident-blocks)?**
Sometimes a miner gets lucky and finds a solution that works for multiple chains at once - like winning multiple lottery tickets with one number.

**Why This Matters:**

* **Automatic bridges**: No need for complex bridging protocols
* **Zero trust required**: Pure math ensures security
* **Natural occurrence**: Happens automatically through mining

These coincident blocks create unbreakable links between chains, enabling seamless cross-chain transactions without any additional infrastructure.

## Revolutionary Energy Efficiency

**The Math is Simple:**

* **Same energy input**: One mining operation
* **3x more blockchains**: Prime, region, and zone
* **10,000x more transactions**: Through parallel processing

**Real Impact:**

* Bitcoin: \~487 kWh per transaction
* Quai: \~0.05 kWh per transaction
* **Your transaction uses less energy than boiling a kettle**

Learn more about [Quai's environmental benefits](/learn/advanced-introduction/merged-mining/energy-efficiency).

## The Bottom Line

Merged mining transforms Proof-of-Work from an energy-intensive necessity into an optimized engine for global-scale blockchain infrastructure. By mining three chains with every computation, Quai achieves unprecedented efficiency while maintaining the unmatched security guarantees of PoW.

\*Per transaction, assuming full load and equal mining power between networks.


# Multithreaded Execution
Source: https://docs.qu.ai/learn/advanced-introduction/multithreaded-execution

How Quai Network processes transactions in parallel.

## From Single-Core to Multi-Core Blockchains

In the early days of computing, processors could only handle one task at a time. Everything had to wait in line, creating bottlenecks that limited performance. The invention of multi-core CPUs changed everything - suddenly computers could process multiple tasks simultaneously, unlocking massive performance gains. Quai brings this same revolution to blockchain technology.

Traditional blockchains operate like single-core processors. Every transaction must queue up and wait its turn through one processing channel. During busy periods, this creates massive congestion - like trying to funnel an entire city's traffic through a single lane. Users experience high fees, long wait times, and failed transactions.

**The Multi-Core Solution:**
Quai's multithreaded execution allows multiple blockchain threads to process transactions in parallel, just like a modern CPU handles multiple tasks simultaneously. Each zone chain operates as an independent execution thread, processing its own transactions while staying synchronized with the broader network.

**How Quai Achieves This:**
The breakthrough comes from separating two concepts that traditional blockchains tightly couple: local consistency (everyone in a zone agrees) and global consensus (the entire network agrees). In Quai:

* Zones achieve local consensus immediately for their transactions
* Global consensus happens gradually as blocks are woven into the hierarchy
* Users get fast confirmations while maintaining network-wide security

This architecture enables true parallel processing - multiple zones can produce blocks simultaneously without waiting for each other, dramatically increasing overall throughput.

<Frame>
  <img />
</Frame>

## Decoupling Consistency & Global Consensus

To understand Quai's breakthrough, we need to distinguish between two concepts that traditional blockchains conflate. Consistency means all nodes have the same data - like everyone having the same version of a shared document. Consensus means everyone agrees that version is correct - like getting everyone to sign off on that document.

Traditional blockchains force these to happen together. Imagine if every time you wanted to save a document, you had to wait for everyone in your company to review and approve it. That's how Bitcoin and Ethereum work - nothing can be consistent until everyone agrees, creating massive delays.

**The Traditional Problem:**
In single-threaded blockchains, this coupling creates a vicious cycle:

1. New block is proposed
2. Network must reach consensus before data becomes consistent
3. Nodes scramble to sync data during consensus process
4. Latency delays compound at each step
5. Result: Slow confirmations and limited throughput

**Quai's Innovation:**
Quai separates these processes through its hierarchical structure:

* **Local consistency**: Zones can immediately agree on their own transactions
* **Progressive consensus**: Agreement expands from local to regional to global
* **No waiting**: Users get instant local confirmation while global consensus happens in background

**Security Guarantee:**
This separation doesn't compromise security. Quai maintains atomic rollbacks - if global consensus ever rejects a zone's state (extremely rare), all affected transactions reverse together. This prevents any possibility of double-spends while enabling massive performance gains.

The result is a system where transactions can be processed and confirmed locally in seconds, while still maintaining the security guarantees of global consensus. It's like having a fast local cache that's guaranteed to sync with the global state.

## Segmented State: Divide and Conquer

Traditional blockchains require every node to store everything - every transaction, every account balance, every smart contract. It's like requiring every library branch to stock every book in the entire library system. This creates massive inefficiency and limits scalability. Quai's segmented state architecture changes this paradigm entirely.

Each zone maintains only its own slice of the global state. Think of it like specialized departments in a company - accounting doesn't need to store engineering files, and vice versa. This specialization dramatically reduces requirements while maintaining the ability to coordinate when needed.

**Storage Efficiency:**
In a network with N zones:

* Traditional approach: Every node stores 100% of global state
* Quai approach: Each zone node stores only \~1/N of global state
* Slice nodes: Can choose to run P zones, storing only P/N of total state

This means a node operator can participate in the network with dramatically lower hardware requirements, improving decentralization.

**Bandwidth Optimization:**
Segmented state also revolutionizes network efficiency:

* **Local transactions**: Stay within their zone, no global broadcast needed
* **Smart routing**: Data only travels where it's needed
* **Reduced congestion**: Each zone handles its own traffic independently

Imagine if every email in a company had to be sent to every employee. That's how traditional blockchains work. Quai's approach is like having departmental email lists - messages go only where they're relevant.

**Rapid Consistency:**
The segmented approach enables lightning-fast local consistency:

1. Zone transactions achieve immediate local consensus
2. Hash-linked references gradually expand consensus scope
3. Global consensus occurs without disrupting local operations
4. Users experience instant confirmations with eventual global finality

This architecture allows Quai to process 50,000+ TPS by eliminating the bottlenecks that plague monolithic blockchain designs.

## Parallel Processing: The Performance Multiplier

The true power of multithreaded execution becomes apparent when you see it in action. While traditional blockchains process transactions sequentially - one after another in a single line - Quai processes them in parallel across multiple zones. It's the difference between a single cashier at a store versus multiple checkout lanes operating simultaneously.

**Technical Implementation:**
Quai achieves true parallel processing by giving each zone its own independent write locks and computation resources. This means:

* Zone A can process a DeFi swap
* While Zone B handles an NFT mint
* While Zone C executes a gaming transaction
* All happening simultaneously without interference

**Asynchronous Block Production:**
Each zone produces blocks on its own schedule, without waiting for others:

* No global synchronization delays
* No cross-zone bottlenecks
* Maximum utilization of computational resources

**The 50,000 TPS Reality:**
This parallel architecture enables Quai to achieve over 50,000 transactions per second across the network. But unlike other high-TPS claims that sacrifice security or decentralization, Quai maintains:

* Full atomicity through [PoEM consensus](/learn/advanced-introduction/poem/poem)
* Complete security across all zones
* True decentralization with accessible node requirements

**Coordinated Independence:**
The genius of the system is that while zones operate independently for performance, they remain coordinated for security. If any issue arises (extremely rare), the PoEM consensus ensures all affected zones roll back together, maintaining consistency across the entire network.

This is multithreaded blockchain execution at its finest - the performance of parallel processing with the security of unified consensus.


# Faster Finality
Source: https://docs.qu.ai/learn/advanced-introduction/poem/finality/finality

How transactions achieve finality in Quai Network.

## What is Finality?

When you send a transaction, how long do you have to wait before you're confident it can't be reversed? This waiting time is called **finality**.

**Two Types of Finality:**

1. **Statistical Finality**: Mathematical certainty your transaction is permanent (barring a 51% attack)
2. **Economic Finality**: The cost to reverse your transaction exceeds any attacker's benefit

**Why Faster Finality Matters:**

* **Better user experience**: No waiting 10+ minutes for Bitcoin confirmations
* **Enables commerce**: Merchants can accept payments instantly
* **Reduces uncertainty**: Clear when transactions are truly final

## The Challenge: Quai's Multi-Chain Architecture

Quai Network uses a hierarchy of blockchains:

* **Prime chains**: Main coordination chains (slower, more secure)
* **Region chains**: Regional coordination chains
* **Zone chains**: Individual transaction chains (faster, where users interact)

**The Problem**: In traditional systems, transactions on fast chains (zones) aren't final until confirmed by slow chains (prime). This creates uncertainty.

## The Withholding Attack Problem

**What's a Withholding Attack?**
Imagine a miner finds a valid block but doesn't immediately broadcast it. Instead, they hold it back while other miners waste energy mining the previous block.

**In Single Chains (like Bitcoin):**

* Attacker holds back a block for \~10 minutes
* Minimal impact since no transactions process between blocks
* Eventually another miner finds a block, making the withheld block worthless

**In Multi-Chain Systems (Traditional Approach):**

* Zone chains process transactions continuously
* But those transactions aren't final until prime chain confirms
* Attacker could hold back a prime block, keeping zone transactions uncertain
* Much more disruptive than single-chain attacks

## PoEM's Solution: Bottom-Up Finality

**Traditional Hierarchy (Top-Down):**

* Prime chains lead, zone chains follow
* Zone transactions wait for prime confirmation
* Vulnerable to prime chain withholding attacks

**PoEM Hierarchy (Bottom-Up):**

* Zone chains can achieve finality independently
* Prime chains follow zone chain entropy accumulation
* Withholding attacks become ineffective

**How This Works:**

* Zone chains remove entropy faster than prime chains (due to higher frequency)
* Even the "luckiest" possible prime block can't outweigh zone chain accumulation for long
* Transactions achieve finality in seconds, not minutes

## Finality Comparison

| System        | Statistical Finality Time  | Method                           |
| ------------- | -------------------------- | -------------------------------- |
| **Bitcoin**   | 10+ minutes (1 block)      | Wait for longest chain           |
| **Ethereum**  | 12+ minutes (2 epochs)     | Wait for 2/3 validator approval  |
| **Quai PoEM** | \~5 seconds (1 zone block) | Entropy accumulation measurement |

**Why PoEM is Faster:**

* **Objective measurement**: Entropy is mathematically scarce, not subjective
* **Independent chains**: Zone finality doesn't depend on prime blocks
* **Precise calculation**: Measures exact work, not arbitrary thresholds

Learn more about the [mathematical details](/learn/advanced-introduction/poem/finality/statistical-finality) of this calculation.

<Frame>
  <img />
</Frame>

## Economic Finality: Real-World Security

**What is Economic Finality?**
The point where reversing your transaction would cost an attacker more than they could possibly gain.

**Real-World Examples:**

* **Coffee purchase (\$5)**: Economically final almost instantly
* **Car purchase (\$50,000)**: May need 30+ minutes for full economic security
* **House purchase (\$500,000)**: Could require hours of confirmations

**Factors Affecting Economic Finality:**

* **Transaction value**: Higher value = longer wait time needed
* **Network hashrate**: More miners = better security = faster finality
* **Pending transactions**: Network congestion affects attack costs
* **Market conditions**: Token price volatility impacts attack economics

## Built-in Economic Finality Tool

Quai Network includes a smart finality calculator that:

**Analyzes Network Conditions:**

* Current hashrate and mining distribution
* Pending transaction volumes and fees
* Historical attack costs and patterns

**Provides Custom Recommendations:**

* Instant decisions for small transactions
* Precise wait times for large transfers
* Real-time updates as conditions change

**Use Cases:**

* **Merchants**: Know exactly when payments are safe
* **Exchanges**: Minimize deposit wait times while maintaining security
* **Users**: Understand the security level of their transactions

<Note>
  Economic finality is dynamic - the same transaction might need different wait times depending on current network conditions and market factors.
</Note>


# Statistical Finality
Source: https://docs.qu.ai/learn/advanced-introduction/poem/finality/statistical-finality

How Quai Network achieves faster statistical finality.

## What is Statistical Finality?

**Statistical finality** is mathematical certainty that your transaction is permanently recorded on the blockchain (assuming no 51% attack occurs).

**Key Insight**: In Quai Network, zone chain transactions can achieve statistical finality **independently** of prime chain confirmations. This is revolutionary.

**Traditional Systems**:

* Zone transaction occurs
* Must wait for prime chain confirmation
* Uncertainty period = minutes to hours

**Quai PoEM System**:

* Zone transaction occurs
* Achieves finality through entropy accumulation
* Certainty period = seconds

## Why Independence Matters

**The Problem with Dependencies:**

* If zone finality depends on prime blocks, attackers can target prime chains
* Withholding a single prime block affects thousands of zone transactions
* Creates systemic vulnerability

**PoEM's Solution:**

* Zone chains accumulate entropy faster than any single prime block can provide
* Even the "luckiest" prime block can't overcome zone chain entropy accumulation
* Each zone operates with autonomous security

## The Math: Maximum Withholding Attack Duration

**The Question**: What's the longest time an attacker could delay finality by withholding a prime block?

**The Setup**:
Imagine an attacker finds the "luckiest" possible prime block - a hash with 63 leading zeros followed by a 1. This is incredibly rare and removes maximum entropy from the system.

**The Calculation**:

```
Maximum Attack Duration = Hash Field Size / Zone Threshold
k < 256 / 25 = ~10 zone blocks
```

**Real-World Numbers**:

* **Zone block time**: 10 seconds
* **Maximum attack duration**: 10 blocks × 10 seconds = **100 seconds**
* **Typical finality**: 1 block × 10 seconds = **10 seconds**

**What This Means**:
Even with the most extreme possible luck, an attacker can only delay finality by about 100 seconds. In practice, most withholding attacks would be much shorter because finding such a "perfect" block is astronomically unlikely.

## Why Attacks Are Even Shorter in Practice

**Perfect Storm Requirements:**
The 100-second maximum assumes the attacker gets extremely lucky AND zone blocks are extremely unlucky:

* **Attacker luck**: Finds a near-perfect prime block (1 in trillions chance)
* **Zone unluckiness**: Zone blocks remove minimum entropy for 10 consecutive blocks

**Reality Check:**

* Zone blocks typically exceed minimum entropy requirements
* This further shortens any possible attack duration
* Most withholding attempts would fail within 1-2 zone blocks

## The Bottom Line: Geometric vs Linear Security

**Traditional PoW (Linear)**:

* Work accumulates by addition: 10 + 10 + 10 = 30
* Single powerful block can overcome multiple weak blocks
* Enables longer withholding attacks

**PoEM (Geometric)**:

* Entropy accumulates by multiplication: 1/1000 × 1/1000 × 1/1000 = 1/billion
* Multiple blocks quickly become impossible to overcome
* Practically eliminates withholding attacks

## Extreme Rarity of Successful Attacks

**Statistical Reality:**
Only 1 in 2^40 blocks (about 1 trillion) removes enough entropy to enable even a single-block withholding attack.

**Time Scale:**
With 10-second zone blocks, this means successful single-block withholding attacks occur approximately **once every 350,000 years**.

**Practical Security:**
For everyday users, withholding attacks are not a meaningful concern. Your transaction finality is mathematically guaranteed within seconds, regardless of what attackers attempt.

<Note>
  **Key Takeaway**: PoEM's geometric entropy accumulation makes withholding attacks not just impractical, but mathematically negligible for real-world use.
</Note>


# Calculating Total Entropy
Source: https://docs.qu.ai/learn/advanced-introduction/poem/fork-choice/calc-total-entropy

How total entropy accumulates in Quai Network.

## From Single Blocks to Entire Chains

We've seen how PoEM measures the exact work in a [single block](/learn/advanced-introduction/poem/fork-choice/intrinsic-block-weight). But how do we compare entire blockchains? This is where **total entropy** comes in.

Think of it like this:

* **Single block**: "How hard was this math problem?"
* **Entire blockchain**: "How hard was this entire series of math problems?"

## Why Entropy Instead of "Work"?

**Entropy** is a physics concept that measures randomness or disorder. When miners find a block, they're essentially **reducing randomness** by finding a very specific, ordered hash.

**The Key Insight**: The amount of randomness removed (entropy reduced) directly corresponds to the energy spent creating that order.

**Real-world analogy**:

* Messy room (high entropy) → Clean room (low entropy)
* Energy required to organize = Entropy reduced
* More organized = More energy spent = Lower entropy

## Geometric vs Linear: Why It Matters

**Traditional PoW (Linear Addition):**

* Block 1: 16 difficulty points
* Block 2: 16 difficulty points
* Block 3: 16 difficulty points
* **Total**: 16 + 16 + 16 = 48 points

**PoEM (Geometric Multiplication):**

* Block 1: Removes 1/65536 of possible states
* Block 2: Removes 1/65536 of remaining states
* Block 3: Removes 1/65536 of remaining states
* **Total**: (1/65536) × (1/65536) × (1/65536) = Much more security

**Why Multiplication is Better:**

* **Exponential security**: Each block makes the chain exponentially harder to recreate
* **Real probability**: Reflects the actual odds of recreating the work
* **Better comparison**: More accurately measures which chain required more total energy

<Note>
  Think of it like compound interest: adding 10% three times gives you 130%, but compounding 10% three times gives you 133.1%. The difference becomes massive over many blocks.
</Note>

<Frame>
  <img />
</Frame>

## Step-by-Step Calculation

### Step 1: Calculate Single Block Entropy

For each block, we calculate how much randomness it removed:

**Simple Version**: More leading zeros = more randomness removed

**Precise Formula**:

```
Block Entropy = 1 / (2^leading_zeros)
```

**Example**:

* Block with 16 leading zeros: 1/65,536 states removed
* Block with 17 leading zeros: 1/131,072 states removed (twice as rare!)

### Step 2: Calculate Chain Total

For an entire blockchain, we multiply all the individual block entropies together:

**Formula**:

```
Total Chain Entropy = Block1 × Block2 × Block3 × ...
```

**Example 3-Block Chain**:

* Block 1: 1/65,536
* Block 2: 1/65,536
* Block 3: 1/131,072
* **Total**: (1/65,536) × (1/65,536) × (1/131,072) = 1 in 563 trillion

This means recreating this 3-block chain would require, on average, 563 trillion attempts!

## Practical Implementation: Using Logarithms

**The Problem**: Those numbers get huge fast! After just 10 blocks, we'd be dealing with numbers so large they're impossible to store efficiently.

**The Solution**: Instead of storing the actual multiplication results, we use logarithms to convert multiplication into addition.

**How It Works**:

* **Traditional storage**: 1/65,536 × 1/65,536 × 1/131,072 = 0.000000000000234
* **Logarithmic storage**: 16 + 16 + 17 = 49 bits of entropy

**Benefits**:

* **Manageable numbers**: Addition instead of astronomical multiplication
* **Exact precision**: No loss of accuracy in comparisons
* **Efficient storage**: Quai uses 64 bits to store total entropy per chain
* **Easy comparison**: Higher entropy number = more secure chain

**The Final Formula**:

```
Total Chain Entropy (in bits) = Block1_bits + Block2_bits + Block3_bits + ...
```

This mathematical trick allows Quai to precisely compare chains of any length while keeping the computation practical for real-world use.

<Note>
  **Key Takeaway**: PoEM measures the exact probability of recreating any blockchain, giving it perfect objectivity when choosing between competing chains. The chain that would be hardest to recreate always wins.
</Note>


# Instantaneous Fork Resolution
Source: https://docs.qu.ai/learn/advanced-introduction/poem/fork-choice/instant-fork-resolution

How the PoEM consensus mechanism eliminated consensus-based forks.

## Why Fork Resolution Matters

When two miners find valid blocks simultaneously, traditional blockchains face a dilemma: which block should the network accept? This creates a temporary "fork" where the network splits into competing chains.

**Impact on Users:**

* **Transaction uncertainty**: Your transaction might be reversed if it's on the losing fork
* **Delayed confirmations**: Must wait for additional blocks to ensure finality
* **Higher fees**: Network congestion from competing for limited block space

**Impact on Miners:**

* **Wasted energy**: Mining power is divided between competing chains
* **Reduced rewards**: Only miners on the winning fork get paid
* **Strategic uncertainty**: Unclear which chain to mine on

## The Traditional Approach: Wait and See

In Proof-of-Work systems like Bitcoin, when two valid blocks appear simultaneously, there's no immediate way to choose between them. Both blocks meet the difficulty requirement, so the network must wait:

1. **Split occurs**: Miners randomly choose which block to build on
2. **Network divides**: Mining power splits between competing chains
3. **Resolution waits**: Only when someone finds the next block does the network know which chain to follow
4. **Time cost**: This can take 10+ minutes in Bitcoin

## PoEM's Solution: Measure True Work

Here's the key insight: **not all valid blocks are actually equal**. Even if two blocks both meet the difficulty requirement, one always required slightly more work to create than the other.

Traditional Proof-of-Work ignores this difference and treats "good enough" blocks as identical. PoEM measures the exact amount of work (entropy removed) for each block, allowing instant, objective decisions.

**How PoEM Resolves Forks Instantly:**

1. **Two blocks appear**: Both meet the minimum difficulty requirement
2. **Measure exact work**: PoEM calculates the precise entropy removed by each
3. **Clear winner**: The block with more entropy removed is objectively better
4. **Instant consensus**: All nodes immediately know which block to follow

## Technical Implementation

PoEM uses [intrinsic block weight](/learn/advanced-introduction/poem/fork-choice/intrinsic-block-weight) to measure the exact work done for each block. Instead of just checking "did this block meet the minimum requirement?", PoEM asks "exactly how much work went into this block?"

This precision enables several key advantages:

**Network Efficiency:**

* **Single proof propagation**: Only one block needs to be shared to achieve consensus
* **No wasted mining**: All computational work contributes to network security
* **Perpetual consensus**: Nodes always agree on the current chain tip

**Scalability Benefits:**

* **Instant coordination**: Can manage unlimited parallel chains
* **No latency impact**: Network delays don't affect consensus decisions
* **Deterministic outcomes**: Given the same information, all nodes make identical choices

<Frame>
  <img />
</Frame>

## Perpetual Consensus

By measuring exact work rather than "good enough" thresholds, PoEM fundamentally changes how consensus works. Instead of periodic attempts to reach agreement, PoEM achieves **perpetual consensus** - all nodes always agree on the current state.

This enables unprecedented capabilities:

* **No fork uncertainty**: Users know transactions are final immediately
* **Infinite scalability**: Can coordinate unlimited parallel chains
* **Maximum efficiency**: All mining power secures the entire network
* **Latency immunity**: Network delays don't create consensus conflicts

## Real-World Example

<Frame>
  <img />
</Frame>

Imagine two miners find competing blocks at the same time:

**Setup:**

* Both blocks meet the minimum difficulty requirement (16 leading zeros)
* Block A hash: `0x0000b9c86d37...`
* Block B hash: `0x0000b9c86d30...`

### How Traditional PoW Handles This:

1. **Both blocks are valid** - Each has 16 leading zeros, meeting requirements
2. **Network splits** - Half the miners work on Block A, half on Block B
3. **Wait for resolution** - Must wait 10+ minutes for someone to find Block 3
4. **Winner determined** - Whichever chain gets Block 3 first becomes canonical
5. **Work wasted** - All mining on the losing chain is discarded

**Result**: Uncertainty, wasted energy, delayed finality

### How PoEM Handles This:

1. **Measure precise work** - Block A removes 16.462525964 bits of entropy
2. **Block B removes more** - Block B removes 16.462525967 bits of entropy
3. **Instant decision** - All nodes immediately recognize Block B as better
4. **Unified mining** - All miners switch to building on Block B
5. **No waste** - All computational work contributes to network security

**Result**: Instant consensus, maximum efficiency, immediate finality

<Note>
  The difference in entropy is tiny (0.000000003 bits) but mathematically decisive. This precision ensures every node makes the same choice without any ambiguity.
</Note>


# Intrinsic Block Weight
Source: https://docs.qu.ai/learn/advanced-introduction/poem/fork-choice/intrinsic-block-weight

How blocks are measured and compared in Quai Network.

## The Problem with "Good Enough"

Traditional Proof-of-Work asks a simple question: "Does this block meet the minimum difficulty requirement?" If yes, the block is considered valid. If no, it's rejected.

**The Issue**: This ignores the actual work done. Imagine two students taking a test:

* Student A scores 85%
* Student B scores 95%
* Both pass the 80% requirement, but Student B clearly did more work

Traditional PoW treats both blocks as "equally valid" once they pass the threshold. PoEM recognizes that one block always represents more work than another.

## What is Intrinsic Block Weight?

**Intrinsic block weight** is like a "work certificate" - it measures exactly how much computational work went into creating a specific block.

Think of it as the difference between:

* **Pass/Fail grading** (traditional PoW): "Did you meet the minimum?"
* **Precise scoring** (PoEM): "Exactly how well did you do?"

This precision allows PoEM to make instant, objective decisions about which block represents the most work and should be accepted by the network.

## How It Works in Practice

When miners create blocks, they're essentially solving a mathematical puzzle. The "answer" they find (the block hash) tells us exactly how much work they did:

**Traditional PoW Logic:**

* Block hash starts with 16 zeros? ✅ Valid
* Block hash starts with 15 zeros? ❌ Invalid
* All valid blocks treated identically

**PoEM Logic:**

* Block A hash: `0x0000b9c86d37...` → 16.462525964 bits of work
* Block B hash: `0x0000b9c86d30...` → 16.462525967 bits of work
* Block B represents more work → Block B wins

This measurement gives PoEM several advantages:

**Instant Decisions:**

* No waiting to see which chain gets longer
* Every node makes the same choice immediately
* No mining power wasted on competing chains

**Perfect Fairness:**

* Most work always wins
* No randomness in fork resolution
* Miners are rewarded proportionally to work done

**Scalability:**

* Can coordinate unlimited parallel chains
* Each chain uses same objective measurement
* No coordination overhead between chains

<Frame>
  <img />
</Frame>

## The Math Behind the Measurement

For those interested in the technical details, here's how intrinsic block weight is calculated:

**Simple Explanation:**
The more leading zeros a hash has, the more work it represents. PoEM measures this precisely using logarithms to get an exact "work score."

**The Formula:**

```
Work Done = Total Hash Length - log₂(Block Hash Value)
```

**Real Example:**

* Hash: `0x0000b9c86d37...`
* This gives us: 256 - log₂(0x0000b9c86d37...) = 16.462525964 bits of work

**Why This Works:**

* Finding a hash with more leading zeros requires exponentially more attempts
* The logarithm converts this exponential relationship into a linear measurement
* This gives us a precise "difficulty score" for each block

<Note>
  The exact mathematical calculation ensures that even tiny differences in work can be measured and compared objectively across the entire network.
</Note>


# Introduction to PoEM
Source: https://docs.qu.ai/learn/advanced-introduction/poem/poem

Quai Network's Proof-of-Entropy-Minima consensus mechanism.

<Note>
  Proof-of-Entropy-Minima is based heavily off of Proof-of-Work Nakamoto Consensus. A strong understanding of Proof-of-Work consensus is
  highly recommended before reading the PoEM documentation. A detailed explanation of Nakamoto Consensus can be found
  [here](https://courses.grainger.illinois.edu/ece598pv/sp2021/lectureslides2021/ECE_598_PV_course_notes3.pdf).

  The original PoEM concept was introduced in a [2023 research paper](https://arxiv.org/abs/2303.04305).
  A more recent paper with a formal security proof
  **["A Better Proof-of-Work Fork Choice Rule"](https://eprint.iacr.org/2024/200)**.
</Note>

## The Consensus Problem

Traditional blockchains face a fundamental challenge: when two valid blocks are found simultaneously, the network temporarily splits. This creates:

* **Uncertainty**: Transactions may be reversed if you're on the losing fork
* **Wasted energy**: Miners work on competing chains that will be discarded
* **Limited scalability**: Only one chain can win, limiting overall throughput

Quai Network solves this with Proof-of-Entropy-Minima (PoEM), ensuring the network never splits and always stays unified.

## How PoEM Works

PoEM is inspired by Bitcoin's [Proof-of-Work (PoW) Nakamoto Consensus](https://bitcoin.org/bitcoin.pdf), but with a crucial improvement. Like PoW, PoEM uses hashes generated by competing miners to verify proposed blocks. However, PoEM differs in how these hashes are compared and measured.

Think of entropy like a "uniqueness score" - PoEM always picks the block with the highest uniqueness score, ensuring every node makes the same choice.

Unlike PoW, which treats all blocks that meet a certain difficulty level as equally valid, PoEM measures the [intrinsic block weight](/learn/advanced-introduction/poem/fork-choice/intrinsic-block-weight) to [calculate the entropy](/learn/advanced-introduction/poem/fork-choice/calc-total-entropy), or randomness, removed by each proposed block. This ensures that all nodes will always prefer one particular block over any other options.

Under PoEM, all nodes immediately agree on the next block as soon as they become aware of it, eliminating any disagreements caused by delays in the network. Two nodes running PoEM will always agree on which block is next in the chain.

## PoEM vs Traditional Consensus

| Traditional PoW              | PoEM                    |
| ---------------------------- | ----------------------- |
| "Good enough" blocks compete | Best block always wins  |
| Network splits temporarily   | Network stays unified   |
| Resolution takes time        | Resolution is instant   |
| Wasted mining effort         | All mining contributes  |
| Limited to single chain      | Enables infinite shards |

## Key Benefits

By removing contention from consensus, PoEM enables "perpetual consensus" - the network never needs time to resolve conflicts because conflicts never occur. This breakthrough provides several advantages:

**For Users:**

* **Instant finality**: Transactions are immediately final, no waiting for confirmations
* **Predictable fees**: No congestion from competing chains
* **Unlimited capacity**: Network can scale infinitely without degrading security

**For the Network:**

* **Energy efficiency**: No wasted mining on discarded forks
* **True decentralization**: Can coordinate unlimited execution shards
* **Enhanced security**: All mining power secures the entire network

<CardGroup>
  <Card title="Instantaneous Fork Resolution" icon="code-branch" href="/learn/advanced-introduction/poem/fork-choice/instant-fork-resolution">
    Given the same set of information, every node in the system will always make the same decision on the next block in the sequence.
  </Card>

  <Card title="Faster Finality" icon="timer" href="/learn/advanced-introduction/poem/finality/finality">
    Proof-of-Entropy-Minima offers a faster mathematical guarantee of on-chain inclusion than all existing consensus mechanisms.
  </Card>

  <Card title="Coordinating Infinite Execution Shards" icon="circle-nodes" href="/learn/advanced-introduction/poem/sharding/execution-sharding">
    Perpetual consensus is a prerequisite to coordinating an infinite number of execution shards. Mechanisms that take any time to resolve
    contention in consensus are ineffective at coordinating more than one chain.
  </Card>
</CardGroup>


# Dynamic Sharding
Source: https://docs.qu.ai/learn/advanced-introduction/poem/sharding/dynamic-sharding

The process of dynamically scaling to more shards in Quai Network.

## Automatic Network Expansion

Imagine a highway system that automatically builds new lanes when traffic gets heavy. That's essentially what Quai Network does with dynamic sharding - it automatically adds processing capacity when demand increases.

**What is Dynamic Sharding?**
The protocol automatically creates new execution shards (processing channels) when the network becomes congested, expanding capacity without human intervention or network upgrades.

**How It Works:**

1. **Network monitors demand**: Protocol tracks congestion indicators in real-time
2. **Automatic expansion**: When thresholds are met, new region and zone chains are created
3. **Seamless integration**: New chains immediately join the existing consensus system
4. **Balanced growth**: All regions gain additional zones to maintain network harmony

**The Key Advantage:**
Unlike other blockchain networks that require hard forks or compromise security when scaling, Quai adds capacity automatically while maintaining full decentralization and security.

<Frame>
  <img />
</Frame>

## How the Network Knows When to Expand

The protocol monitors two key congestion indicators to determine when new capacity is needed:

### 1. Uncle Block Rate

**What are Uncle Blocks?**
Think of uncle blocks as "traffic jams" in mining. When multiple miners find valid blocks simultaneously, only one becomes part of the main chain - the others become "uncles."

**Why This Matters:**

* **High uncle rate** = Network congestion (too many miners competing for limited space)
* **Reduced efficiency** = Wasted mining energy and slower transaction finality
* **Clear signal** = Time to add more capacity

**How Quai Responds:**
When uncle blocks consistently exceed a threshold ratio, the protocol automatically:

1. Creates new region and zone chains
2. Integrates them into the global consensus
3. Distributes mining power across more chains
4. Reduces congestion and restores efficiency

**Result**: High hash efficiency maintained, fast finality preserved

### 2. Gas Limit Utilization

**What is Gas Limit?**
Each block has a maximum computational capacity (gas limit). When blocks consistently hit this limit, it means demand exceeds supply.

**The Fee Problem in Other Networks:**

* **Ethereum example**: When blocks are full, fees can reach \$50+ per transaction
* **Bidding wars**: Users compete by paying higher fees for limited block space
* **User experience**: Transactions become expensive and unpredictable

**Quai's Solution:**
When blocks consistently reach their gas limit, the protocol automatically adds new execution shards, ensuring:

* **Fees stay under \$0.01**: Increased capacity eliminates fee competition
* **No bidding wars**: Always enough block space to meet demand
* **Predictable costs**: Users know transaction fees will remain affordable

**Result**: Unlimited scalability without compromising affordability

## The Only Tradeoff: Settlement Time

**How Network Expansion Works:**

* **3×3 start**: 3 regions, 3 zones each = 9 total zones
* **First expansion**: 4×4 layout = 16 total zones
* **Growth pattern**: 5×5, 6×6, 7×7... unlimited expansion

**What's the Tradeoff?**
The only cost of adding capacity is increased **time to global settlement** - but this doesn't affect transaction safety or usability.

## Settlement vs Finality: Why This Matters

**Critical Distinction:**

* **Finality**: When your transaction is permanent and safe (seconds in Quai)
* **Settlement**: When funds can be spent cross-chain (minutes to hours)

**Real-World Impact:**

* ✅ **Your transaction is safe** immediately after finality
* ✅ **Recipients can trust payment** without waiting for settlement
* ⏳ **Cross-chain spending** requires settlement completion

**Example Timeline:**

1. **10 seconds**: Transaction finalized (safe and permanent)
2. **3,300 seconds**: Global settlement (can spend funds in other regions)

**Why This Design Works:**
Most transactions happen within the same region where settlement is fast. Cross-chain operations are less frequent and users can plan accordingly.

## Settlement Time Calculation

**The Formula:**
Average time to Global (prime) settlement can be measured by the following equation, where:

* **TSₚ** = Average time to Global (prime) settlement (in seconds)
* **nz** = Number of zones per region
* **nr** = Number of regions in the system
* **tz** = Zone block time (in seconds) = 5

$$
TS_{p} = n_{z}^2 * n_{r}^2 * t_{z}
$$

**What This Means:**

* Settlement time increases with the square of both regions and zones per region
* **5 seconds**: Zone block time (where most transactions occur)
* **Total time**: Scales predictably with network size

<br />

<br />

| Number of Regions | Number of Zones per Region | Total Zones | Time to Global Settlement† |
| ----------------- | -------------------------- | ----------- | -------------------------- |
| 3                 | 3                          | 9           | 405s                       |
| 4                 | 4                          | 16          | 1,280s                     |
| 5                 | 5                          | 25          | 3,125s                     |
| 6                 | 6                          | 36          | 6,480s                     |
| 7                 | 7                          | 49          | 12,005s                    |
| 8                 | 8                          | 64          | 20,480s                    |

**Important Notes:**

* Settlement times are **averages** - actual times vary due to the random nature of mining
* **\~50% of transactions** settle faster than the average time
* **All transactions** are final and secure well before settlement completes

**Understanding the Distribution:**
The diagram below shows how cross-chain transaction times are distributed. While the average global settlement is 3,300 seconds, half of transactions complete faster than this.

<Frame>
  <img />
</Frame>


# Execution Sharding
Source: https://docs.qu.ai/learn/advanced-introduction/poem/sharding/execution-sharding

How Quai Network organizes many chains into one network.

## The Scalability Challenge

Blockchain networks face a fundamental tradeoff: you can either process transactions quickly OR coordinate multiple chains securely, but traditional systems struggle to do both.

**The Problem with Traditional Multi-Chain Systems:**

Imagine trying to coordinate multiple busy restaurants (blockchains) that need to share ingredients (transactions) between kitchens. If it takes 10 minutes to confirm each ingredient transfer, the restaurants can only coordinate every 10+ minutes - severely limiting how fast they can serve customers.

**Technical Reality:**

* Single chain: 1 second average consensus, up to 1,000 seconds worst-case
* Multi-chain coordination: Limited to worst-case timing (1,000+ seconds)
* **Result**: Adding more chains doesn't improve throughput because coordination becomes the bottleneck

**Why This Matters:**
The ability to meaningfully increase the number of execution shards requires **instant consensus**. Without it, coordination delays cancel out any performance gains from parallelization.

## PoEM's Solution: Instant Coordination

**The Breakthrough:**
PoEM achieves **deterministic fork resolution** through [intrinsic block weight](/learn/advanced-introduction/poem/fork-choice/intrinsic-block-weight), eliminating coordination delays entirely.

**How It Works:**

1. **Instant decisions**: Every node immediately knows which block is correct across all chains
2. **Perfect synchronization**: All execution shards stay coordinated without waiting
3. **Unlimited parallelization**: Can add more chains without coordination penalties

**Restaurant Analogy Continued:**
With PoEM, it's like having a perfect communication system where all restaurants instantly know the exact status of every ingredient transfer. They can coordinate in real-time, allowing unlimited kitchen expansion without slowing down service.

## Real-World Benefits

**For Users:**

* **Faster transactions**: Multiple chains process in parallel without bottlenecks
* **Lower fees**: Increased capacity reduces competition for block space
* **Unlimited scaling**: Network can grow to meet any demand level

**For the Network:**

* **Maximum efficiency**: All mining power contributes to security across all chains
* **Infinite scalability**: No upper limit on the number of execution shards
* **Maintained security**: Adding chains doesn't compromise safety or decentralization

## Enabling Dynamic Growth

This coordination capability enables Quai's [dynamic sharding](/learn/advanced-introduction/poem/sharding/dynamic-sharding) system, where new execution shards are automatically added when demand increases. Unlike other blockchain networks that face security tradeoffs when adding shards, Quai's only consideration is the time required for cross-chain settlement - and even this remains predictable and manageable.


# Qi: Cash-Like Privacy
Source: https://docs.qu.ai/learn/advanced-introduction/qi-privacy

An overview of the privacy model behind Qi, Quai Network’s UTXO-based token designed for cash-like privacy and scalability.

# Qi: Cash-Like Privacy

**Qi** is one of two native tokens on Quai Network.\
Its design goal is to serve as a **crypto-native medium of exchange and unit of account** for a global monetary system.\
To achieve that, **privacy** must be a core design feature.

This document explains the **privacy architecture of Qi**, the **four key properties** that enable *cash-like privacy*, and why privacy is an essential property of any scalable monetary system.

***

## Why Privacy Matters

In a global economy, privacy is not optional, it’s a **foundational requirement** for free trade and open markets.

Privacy preserves both **individual dignity** and **societal fairness**:

* **For individuals:** Safeguards financial autonomy, allowing users to choose *who* they transact with, *what* they spend, and *when* they do it, free from coercion or surveillance.
* **For organizations:** Prevents unfair competitive intelligence and industrial espionage.
* **For society:** Upholds democratic processes by preventing systemic monitoring and censorship.

In short, **privacy is a shield for freedom, competition, and innovation.**\
A truly global, decentralized economy must protect privacy *by design*, not as an afterthought.

<Callout>
  💡 If we are to build a new global monetary system, privacy must be baked in by default, not left as an afterthought.
</Callout>

***

## Cash-Like Privacy

At Quai Network, we describe **Qi** as having *cash-like privacy* because it mirrors the privacy dynamics of physical cash.

> **Example:** When you pay with cash, both parties know the transaction occurred and agree on the amount.\
> However:
>
> * The merchant doesn’t know how much money you still have.
> * You don’t know how much cash the merchant has.
> * Observers can confirm a transaction occurred but cannot trace where the cash came from or where it ends up.

This is **transparency without traceability**, a property Qi achieves through its unique ledger design.

***

## The Qi Ledger Privacy Model

**Qi** operates on a **[UTXO ledger](https://en.bitcoin.it/wiki/Transaction#Input_and_Output)**, similar to Bitcoin’s, but with four key differences:

1. **Enforced Non-Address Reuse**
2. **Payment Codes**
3. **Fixed Denominations**
4. **Incentivized Co-Operative Reaggregation**

These modifications to the traditional UTXO model make Qi transactions private *by default* while maintaining global scalability.

***

### 1. Enforced Non-Address Reuse

On the Qi ledger, **addresses cannot be reused.**

Every transaction to a recipient must generate a **unique address**. This prevents observers from tracking user activity by linking multiple payments to the same address, a common weakness in blockchain systems like Bitcoin where address reuse compromises privacy.

<Callout type="warning">
  ⚠️ One address may be reused once per prime block for UTXO reaggregation. See [Incentivized Co-Operative Reaggregation](#Incentivized_Co-Operative_Reaggregation).
</Callout>

***

#### 2. Payment Codes: Reusable Identities Without Address Reuse

**[Payment Codes](https://github.com/bitcoin/bips/blob/master/bip-0047.mediawiki)** are a cryptographic mechanism that allows senders to derive unique addresses for each transaction while the recipient maintains a single, reusable identifier.

This enables **reusable identities with unique transaction addresses**, giving Qi users the convenience of a persistent payment identifier while maintaining cash-like privacy by default.

***

### 3. Fixed Denominations

While non-reuse hides *who* is transacting, **fixed denominations** hide *how much* and *where it goes*.

Unlike Bitcoin, which supports 100 million *satoshis* per BTC (creating traceable patterns), **Qi** limits the system to just **16 fixed denominations**.

This design means most transactions will require inputs from both parties making the default behavior look like a 2 person coinjoin. If users desire to increase the rate of entropy creation in the set they can use secondary tools to perform many party [CoinJoins](https://en.bitcoin.it/wiki/CoinJoin).

***

### 4. Incentivized Co-Operative Reaggregation

Since Qi addresses can only be re-used once per prime block, Qi UTXO reaggregations are extremely limited.

Without reaggregation, a user can submit a transaction that splits a 10 Qi UTXO into 10, 1 Qi UTXOs. However, they can't submit a transaction that transforms 10, 1 Qi UTXOs into 1, 10 Qi UTXO.

This incentivizes co-operative reaggregation where multiple parties will co-operate to consolidate their UTXOs once per prime block. Co-operative reaggregation is an added benefit to privacy in that it increases the rate of entropy in the set just like a many party [CoinJoin](https://en.bitcoin.it/wiki/CoinJoin).

***

## Untraceable Money at Scale

These properties combine to create **untraceable, cash-like digital money** that scales globally.

Scalability is key for achieving the maximum amount of privacy. When using systems where the number of total actors is few, your digital footprint is easier to find and isolate. Having more actors participating in the system increases the total set size for bad actors to sort through.

The privacy design goals behind Qi prioritize scalability in achieving cash-like privacy. Other designs that depend on [RingCT](https://eprint.iacr.org/2015/1098.pdf) or [Bulletproofs](https://eprint.iacr.org/2017/1066.pdf) (zero-knowledge proofs) don't scale nearly enough in comparison to truly protect the privacy of their users.

Scalable, cash-like privacy makes Qi a **true decentralized and private medium of exchange**, preserving user privacy while maintaining verifiable on-chain integrity.

***

## Comparing QUAI, WQi, and Qi Privacy

| Token    | Ledger Type             | Privacy Level     | Description                           |
| -------- | ----------------------- | ----------------- | ------------------------------------- |
| **QUAI** | Account-based           | Transparent       | Standard Quai account transactions    |
| **WQi**  | Wrapped (Account-based) | Transparent       | Wrapped Qi for smart contract use     |
| **Qi**   | UTXO-based              | Cash-like Privacy | Private-by-default medium of exchange |

<Callout type="warning">
  ⚠️ Swaps between QUAI, WQi, and Qi are **transparent**.\
  To achieve full cash-like privacy, transact only in **native Qi**.
</Callout>

***

## Related References

* [Bitcoin UTXO Model](https://en.bitcoin.it/wiki/Transaction#Input_and_Output)
* [Payment Codes (BIP47)](https://github.com/bitcoin/bips/blob/master/bip-0047.mediawiki)
* [CoinJoin Overview](https://en.bitcoin.it/wiki/CoinJoin)
* [Schnorr Signatures](https://en.wikipedia.org/wiki/Schnorr_signature)
* [Quai Network Whitepaper](https://qu.ai/whitepaper)

***

**Last Updated:** October 2025


# Project SOAP
Source: https://docs.qu.ai/learn/advanced-introduction/soap

How Quai turns merge-mining into token buybacks via Subsidized Open-market Acquisition Protocol (SOAP)

SOAP (Subsidized Open-market Acquisition Protocol) turns merge-mining rewards into continuous QUAI buybacks. Purchased QUAI is burned (100%).

## Understanding SOAP Pt. 1

### How Quai turns merge-mining into token buybacks

Bitcoin miners point their hardware at a single chain, competing to solve blocks and earn rewards. But what if you could point that same hardware at multiple chains simultaneously, earning rewards from both? This is the core insight behind merge-mining, a technique that lets miners work on two or more blockchains at once without splitting their computational power.

The most famous example is Namecoin, which was merge-mined with Bitcoin starting in 2011. The idea is elegant: when mining Bitcoin, you include a reference to a Namecoin block in your Bitcoin block's coinbase transaction. If your Bitcoin block is valid, you can also claim the Namecoin block reward. You're doing one proof-of-work computation, but getting credit on two chains.

Litecoin and Dogecoin later implemented a more sophisticated version where DOGE miners could simultaneously mine LTC. This created a symbiotic relationship: Dogecoin gained security from Litecoin's hashrate, while Litecoin miners earned additional revenue from DOGE rewards.

But here's the opportunity that inspired SOAP: in traditional merge-mining, the miner receives block rewards from both the parent (e.g., Bitcoin Cash) and the child (e.g., Namecoin) chains directly into their wallet, which means the child chain is effectively paying miners for security, but those miners often immediately sell the child chain’s token, creating ongoing selling pressure.

What if we could channel that flow into permanent protocol support?

### The SOAP Subsidy Model

SOAP transforms merge-mining into a protocol subsidy mechanism. Instead of miners receiving the parent chain's block reward directly, SOAP routes 100% of the parent chain's coinbase output to a protocol-controlled address. That address then converts the parent chain tokens to QUAI at market and burns the purchased QUAI.

Think of it this way: when you mine QUAI with SOAP enabled, you earn QUAI block rewards as you normally would. SOAP doesn't change that. What SOAP adds is the ability to also contribute hashrate from other chains (BCH, LTC, DOGE, RVN) through workshares/blocks to provide a protocol subsidy.

The economic proposition for participating in SOAP is straightforward: you're mining QUAI and getting paid in QUAI, but your parent chain block subsidy goes to the protocol.

### Example of SOAP flows

For miners focused purely on QUAI, nothing changes. They mine KAWPOW blocks and earn QUAI. For miners with existing BCH/LTC/DOGE hardware, SOAP offers a way to now earn QUAI. You simply point your SHA256d or Scrypt rigs at SOAP-enabled pools to mine QUAI while the merge-mined BCH/LTC/DOGE is used for buybacks.

The key insight: SOAP automatically includes valid parent chain merge-mining to create an ongoing protocol subsidy. Miners contribute security through whatever hardware they have available, and the protocol ensures they're paid fairly in QUAI while using the parent chain subsidies to create permanent buy pressure.

In the worst case, this creates net-zero daily flow: miners sell their QUAI, the protocol buys QUAI with parent chain subsidies, the forces cancel. But in practice, some miners are "non-mercenary" (they hold rather than immediately dumping) which means most days produce net positive buy pressure for QUAI.

More subsidy chain funded buying leads to price improvement, which leads to more hashrate, which leads to stronger QUAI security, which makes subsidy chains find SOAP more attractive, which leads to more subsidy flows, which leads to more buy and burn.

Important note: This is not a promise, just a plausible positive feedback loop.

## Technical Structure: AuxPoW

How does Quai verify that a parent chain block actually paid the protocol address and included the required commitment? Through a structure called AuxPoW (auxiliary proof-of-work).

AuxPoW is an SPV-style proof that consists of:

* The parent chain's 80-byte block header (120 bytes for KAWPOW)
* The coinbase transaction from that block
* A Merkle branch proving the coinbase is included in the block
* Metadata identifying which parent chain this is from (BCH, LTC, DOGE, KAWPOW, etc.)

When a Quai node receives a block containing an AuxPoW structure, it performs several checks:

* **Merkle verification:** Does the coinbase transaction actually appear in the parent chain block's Merkle root?
* **Commitment check:** Does the coinbase's scriptSig contain a SOAP push (specifically, the magic bytes `"SOAP" 0x01` followed by the 32-byte hash of the Quai WorkObject)?
* **Payout check:** Does the coinbase's first output pay 100% of the subsidy plus fees to the protocol-specified address (QADDR)?
* **(Optional) PoW verification:** Does the parent chain header satisfy that chain's difficulty target?

The SOAP commitment goes in the coinbase's scriptSig, immediately after the BIP34 height push. This placement is critical: the scriptSig is part of the coinbase transaction that miners construct when building blocks, and it's universally available across all SOAP chains without requiring special OP\_RETURN handling or worrying about policy variability.

The commitment format is minimal:

* `PUSHDATA(BIP34_height)`
* `PUSHDATA("SOAP" 0x01 || 32-byte WO_HASH)`
* `PUSHDATA(extranonce1)`
* `PUSHDATA(extranonce2)`

Miners vary `extranonce2` as usual, pools provide `extranonce1`, and the SOAP push is fixed by the pool's job template. This means standard Stratum v1 mining continues to work without firmware changes. The pool specifies the QUAI payout address that will receive workshare rewards.

The parent chain coinbase construction (including the QADDR payout and SOAP commitment) is handled by the Quai node itself. This means standard Stratum v1 mining continues to work without firmware changes.

## How Quai looks like a mining pool to the parent chain

### Workshares and Multi-Algorithm Mining

Here's where SOAP gets interesting from a protocol design perspective. Quai blocks are authored exclusively by KAWPOW miners. No other algorithm can create a Quai block. But other algorithms (SHA256d from BCH, Scrypt from LTC/DOGE, and KAWPOW itself) can submit workshares that get included in KAWPOW blocks and earn QUAI rewards.

Quai developed workshares initially to prevent selfish mining and provide hashrate samples for faster finality convergence, but the underlying mechanism naturally extends to support multiple proof-of-work algorithms beyond just KAWPOW.

Bitcoin incentive alignment tells us that the core issue is: how do you ensure miners are rewarded proportionally to their work when you can only observe block production, not hash attempts? Requiring miners to submit all attempted mining nonces is impossibly expensive. Mining pools solve this by having miners submit k-subblocks (shares that meet an easier difficulty target), and the pool pays based on share count.

Quai brings this idea on-chain through workshares. But unlike traditional pool shares submitted off-chain, Quai workshares are WorkObjects that:

* Do **not** meet Quai's block difficulty target (not KAWPOW blocks)
* Do include valid AuxPoW proving parent chain participation
* Do commit to the current Quai tip via `parentHash` in the WorkObject

Each workshare proves:

* "I performed computation on chain X (BCH/LTC/DOGE/RVN), I referenced Quai WorkObject Y, and my parent chain block paid QADDR."

The workshare doesn't create a new Quai block, but it does create a QUAI payment to the address specified in the WorkObject's `primaryCoinbase` field.

KAWPOW block producers can include up to 9 workshares per block (hard cap), with a soft target of 3 workshares per block maintained by a separate difficulty adjustment algorithm. Each algorithm (SHA256d, Scrypt, KAWPOW) has its own share difficulty target, preventing any single algorithm from dominating inclusion.

This multi-algorithm approach provides two benefits:

* **Hardware diversity:** ASICs for different algorithms contribute security through different physical supply chains, making it harder for any single manufacturer or hardware class to dominate.
* **Scalability of subsidy conversion:** If Quai's KAWPOW blocks are already being produced at target rate, workshares provide a mechanism to continue scaling parent chain participation without destabilizing Quai's block timing or difficulty adjustment.

## Workshares Add Weight and Provide Security

Workshares contribute directly to block weight and economic finality in Quai consensus. Block weight isn't simply a count of blocks but an entropy measurement reflecting total computational work securing the chain. This entropy is measured via PoEM and Proportional Reward Splitting (PRS) and existed on Quai before the SOAP upgrade.

When calculating a block's total entropy (weight), the protocol:

* Calculates the block's intrinsic entropy from its proof-of-work solution
* Adds workshare entropy from all included workshares (up to 9 per block)
* Applies discounting rules:
  * Workshares below block difficulty threshold receive reduced weight
  * Workshares pointing to older blocks receive exponentially reduced weight (distance-based discount)

A KAWPOW block including SHA256d and Scrypt workshares has measurably more weight than an equivalent KAWPOW block without them. This additional weight makes the block harder to reorg and contributes to faster economic finality.

Economic finality depends on the cost to reorg. An attacker must produce more total entropy than the honest chain. With workshares:

* Each block accumulates more entropy than KAWPOW alone would provide
* Reorg attacks become proportionally more expensive (attacker must overcome both block difficulty and workshare entropy)
* Multi-algorithm security compounds (attacker needs hashrate across multiple algorithms or must produce enough KAWPOW work to overcome the workshare entropy deficit)

Example:

* A block with 1000 KAWPOW entropy plus 200 workshare entropy (150 SHA256d, 50 Scrypt) totals 1200 units.
* An attacker must produce 20% more work to reorg compared to a KAWPOW-only chain.

## Why Miners Participate

This still leaves the puzzle: why would a BCH miner voluntarily send their block reward to QADDR instead of keeping it?

The answer splits across two participant types:

**Parent chain (BCH/LTC/DOGE/RVN) miners submitting workshares**

* They receive QUAI rewards from Quai's emission schedule in proportion to their workshare submissions.
* The parent chain block reward goes to the protocol, but the QUAI payment compensates them.
* Workshares actively secure Quai by providing additional hashrate samples that strengthen consensus and accelerate finality.
* Whether this is profitable depends on:
  * QUAI price relative to parent chain token
  * Quai's workshare reward rate
  * Competition for workshare inclusion (up to 9 per block cap)

**Quai KAWPOW block producers**

* They receive standard QUAI block rewards for producing blocks.
* They're securing Quai directly using KAWPOW and benefit from SOAP buy pressure on QUAI since the protocol continuously converts BCH/LTC/DOGE subsidies into QUAI purchases.

The dynamics are compelling: parent chain miners get diversification (earning both native chain rewards on non-SOAP blocks and QUAI on SOAP blocks), Quai gets external security contributions and permanent buy pressure, and the protocol avoids the pure selling pressure that plagues traditional merge-mined chains.

## Governance and Rotation

One practical concern: how do you update QADDR or adjust SOAP parameters without hard-forking the entire network?

Quai uses a committee-based governance system where a small set of signers create and sign AuxTemplates. Each AuxTemplate specifies:

* Which parent chain (`ChainID`)
* The required payout script (`PayoutScript = QADDR`)
* The previous block hash (`PrevHash`)
* ScriptSig length limits
* Advisory mining parameters (`nBits`, `nTime` mask, etc.)

Templates are signed by a threshold of committee members (for example, 2-of-3 multisig), and Quai consensus requires that any included AuxPoW must correspond to a valid, quorum-signed template.

This allows the protocol to:

* Rotate QADDR if a key is compromised
* Adjust parent chain participation parameters
* Phase in or out supported parent chains

All without requiring every node to hard-fork. The committee structure actually improves on current mining centralization: parent chain mining today is dominated by large pools with single points of control. SOAP replaces single pool operators with a committee of signers, distributing trust across multiple parties.

More importantly, all Quai block proposals are generated locally by individual nodes. The parent chain's trust model becomes equal to or better than existing pool-dominated structures, while Quai's decentralization remains completely unchanged. Nodes maintain full autonomy over block production; the committee only signs templates that specify payout addresses and basic mining parameters.

## Security and Liveness

A final note on the security model: SOAP is designed to fail gracefully. If parent chain participation drops to zero (no BCH/LTC/DOGE/KAWPOW miners submit workshares), Quai keeps producing KAWPOW blocks normally. There's no liveness coupling. Workshares are purely additive.

This is in contrast to some merge-mining setups where the child chain depends on parent chain blocks to maintain consensus. If you required every Quai block to include at least one parent chain AuxPoW, Quai's liveness would be coupled to parent chain production and become fragile.

SOAP's philosophy: take the benefits when available, but don't break if external participants stop showing up.

The actual security benefit comes from diversifying the hardware base and creating economic incentives that align miners with Quai's success rather than just extracting block rewards. Whether those incentives are sufficient is an empirical question that plays out in the market, not something provable in the whitepaper.

## Summary

SOAP transforms traditional merge-mining into a protocol subsidy mechanism by routing parent chain subsidies to protocol-controlled addresses used to buyback QUAI. The purchased QUAI is then burned. This creates continuous buy pressure while allowing external miners to earn QUAI through workshares.

Technically, SOAP uses AuxPoW structures to prove parent chain participation, with commitments placed in coinbase scriptSigs to maintain compatibility with standard mining infrastructure. Quai blocks are KAWPOW-only (transitioning from ProgPoW), but workshares from other algorithms (SHA256d, Scrypt, and KAWPOW itself) can be included for QUAI rewards, diversifying the security base across different hardware classes.

The workshare mechanism builds on FruitChains and PRS protocols, bringing on-chain the same statistical sampling techniques that mining pools use to estimate miner contributions.

SOAP's success depends on market mechanics: miners finding QUAI rewards competitive and enough non-mercenary hashrate creating net positive buy pressure. The protocol pays market rate for security from external chains (BCH, LTC, DOGE) and converts those subsidies into continuous QUAI purchases. This inverts traditional merge-mining economics where child chains face pure selling pressure. Instead, external subsidies become protocol treasury inflows supporting token liquidity while miners receive fair QUAI compensation.


# Bridge to Quai
Source: https://docs.qu.ai/learn/bridge-to-quai

Technical details and contract addresses for bridging assets to and from Quai Network via Symbiosis.

Bridge assets to Quai Network using the [Symbiosis](https://app.symbiosis.finance/swap?amountIn\&chainIn=Base\&chainOut=Quai\&tokenIn=ETH\&tokenOut=QUAI) cross-chain protocol. Symbiosis enables seamless transfers between Quai and other major networks including Ethereum and Base.

### Quick Bridge Links

<div>
  <a href="https://app.symbiosis.finance/bridge?chainIn=Base&chainOut=Quai&syntheticIn=1&syntheticOut=0&tokenIn=0x5c97D726bf5130AE15408cE32bc764e458320D2f&tokenOut=0x006C3e2AaAE5DB1bCd11A1a097cE572312EADdBB">
    Bridge WQUAI from Base to Quai Network
  </a>

  <a href="https://app.symbiosis.finance/bridge?chainIn=Ethereum&chainOut=Quai&syntheticIn=1&syntheticOut=0&tokenIn=0x70b7f7044D2ca8E2F1E999B90EF16d7Cb7A0cDA1&tokenOut=0x006C3e2AaAE5DB1bCd11A1a097cE572312EADdBB">
    Bridge WQUAI from Ethereum to Quai Network
  </a>

  <a href="https://app.symbiosis.finance/bridge?chainIn=Ethereum&chainOut=Quai&syntheticIn=0&syntheticOut=1&tokenIn=0xdAC17F958D2ee523a2206206994597C13D831ec7&tokenOut=0x0049F7cbCa3556C2DfaE62Aafa7015F99de1b8f5">
    Bridge USDT from Ethereum to Quai Network
  </a>
</div>

Note: USDT bridging from Base to Quai is not currently available. For USDT, use Ethereum → Quai.

### Key Contract Addresses

Use these exact addresses when bridging to avoid interacting with the wrong tokens.

| Network  | Token            | Address                                      |
| :------- | :--------------- | :------------------------------------------- |
| Quai     | USDT             | `0x0049F7cbCa3556C2DfaE62Aafa7015F99de1b8f5` |
| Quai     | WQUAI            | `0x006C3e2AaAE5DB1bCd11A1a097cE572312EADdBB` |
| Base     | QUAI (Symbiosis) | `0x5c97D726bf5130AE15408cE32bc764e458320D2f` |
| Ethereum | QUAI (Symbiosis) | `0x70b7f7044D2ca8E2F1E999B90EF16d7Cb7A0cDA1` |

### Add Token to Wallet

Use the buttons below to add the QUAI token (Symbiosis representation) to your wallet on Base or Ethereum. Make sure your wallet (e.g., MetaMask) is installed. The button will switch to the correct network and prompt an “Add Token” dialog.

<div>
  <button>
    Add QUAI on Base to Base Wallet
  </button>

  <button>
    Add QUAI on Ethereum to Ethereum Wallet
  </button>
</div>

## Symbiosis Bridge

Symbiosis is a cross-chain AMM DEX that pools liquidity across multiple blockchains, allowing users to swap any token on any supported chain with a single transaction.

<Card title="Symbiosis App" icon="bridge" href="https://symbiosis.finance">
  Access the Symbiosis bridge interface to transfer assets to and from Quai Network.
</Card>

## Quai Network Configuration

| Property            | Value                              |
| :------------------ | :--------------------------------- |
| Chain ID            | `9`                                |
| RPC Endpoint        | `https://rpc.quai.network/cyprus1` |
| Block Explorer      | [QuaiScan](https://quaiscan.io)    |
| Filter Block Offset | `500`                              |

## Smart Contract Addresses on Quai

The following contracts are deployed on Quai Network (Chain ID: 9) for the Symbiosis bridge integration.

| Contract          | Address                                      |
| :---------------- | :------------------------------------------- |
| MetaRouter        | `0x001C50a8527fA172A5FBcb65e5402D55cf319ADe` |
| MetaRouterGateway | `0x0024334B36aDe5b7FD9b168aD68Ad288d85Ba261` |
| Bridge            | `0x003d4d57930b2E0887606bE461ab167CAC2E769e` |
| Synthesis         | `0x004E53ED63b674B1e64Bed32eF037e1f94fc1996` |
| Portal            | `0x003d9F9666853fD4A10351FF5364c602470A7cF6` |
| Fabric            | `0x005a04B1EB81A8d1591602eb58742DEee478485D` |
| MulticallRouter   | `0x0049ff6C9ACe2BAf67ad0466D82e0A2Dc7E309d1` |

## Token on Quai

| Token                | Address                                      | Decimals |
| :------------------- | :------------------------------------------- | :------- |
| WQUAI (Wrapped Quai) | `0x006C3e2AaAE5DB1bCd11A1a097cE572312EADdBB` | 18       |

## Symbiosis Contracts on Source Chains

### Ethereum (Chain ID: 1)

| Contract          | Address                                      |
| :---------------- | :------------------------------------------- |
| MetaRouter        | `0xf621Fb08BBE51aF70e7E0F4EA63496894166Ff7F` |
| MetaRouterGateway | `0xfCEF2Fe72413b65d3F393d278A714caD87512bcd` |
| Bridge            | `0x5523985926Aa12BA58DC5Ad00DDca99678D7227E` |
| Synthesis         | `0xD7c3DF25683871d18BC838E4F619126442Dd38B3` |
| Portal            | `0xb8f275fBf7A959F4BCE59999A2EF122A099e81A8` |
| Fabric            | `0xbBFb7cb70f84fb6fE1Cb13e42A0B71EFDe769428` |
| MulticallRouter   | `0x49d3Fc00f3ACf80FABCb42D7681667B20F60889A` |

**USDT on Ethereum:** `0xdAC17F958D2ee523a2206206994597C13D831ec7` (6 decimals)

### Base (Chain ID: 8453)

| Contract          | Address                                      |
| :---------------- | :------------------------------------------- |
| MetaRouter        | `0x691df9C4561d95a4a726313089c8536dd682b946` |
| MetaRouterGateway | `0x41Ae964d0F61Bb5F5e253141A462aD6F3b625B92` |
| Bridge            | `0x8097f0B9f06C27AF9579F75762F971D745bb222F` |
| Synthesis         | `0x9F6424FE88fBe7785Fa34F0E369F192bF38E7A6e` |
| Portal            | `0xEE981B2459331AD268cc63CE6167b446AF4161f8` |
| Fabric            | `0x44487a445a7595446309464A82244B4bD4e325D5` |
| MulticallRouter   | `0x01A3c8E513B758EBB011F7AFaf6C37616c9C24d9` |

## Integration Notes

* **CoinGecko Platform ID:** `quai-network`
* **Gas Token ID:** `quai-network`
* Quai uses the Cyprus1 zone for cross-chain operations
* Transactions on Quai use standard EVM-compatible signing for the account-based (Quai) token

<Note>
  USDT is not currently available as a native token on Quai Network. When bridging USDT from other chains, it will be represented as a synthetic asset through the Symbiosis Synthesis contract.
</Note>

## Additional Resources

<CardGroup>
  <Card title="Symbiosis Docs" icon="book" href="https://docs.symbiosis.finance">
    Full documentation for the Symbiosis protocol
  </Card>

  <Card title="Symbiosis SDK" icon="code" href="https://github.com/symbiosis-finance/js-sdk">
    JavaScript SDK for programmatic bridge integration
  </Card>
</CardGroup>


# Introduction
Source: https://docs.qu.ai/learn/introduction



Quai Network is a next-generation blockchain that merges the security of Proof-of-Work with unprecedented scalability.

At its core, Quai introduces three breakthrough innovations:

* **Proof-of-Entropy-Minima (PoEM)**: A consensus mechanism that eliminates block contention and enables instant finality
* **Merged-mined hierarchy**: Allows Quai to scale state processing without dividing mining power while creating optimally organized subnets
* **Energy-based currency (Qi)**: The world's first decentralized dollar tied to the cost of energy

Together, these innovations create a blockchain capable of serving as a global monetary system—secure, scalable, and built for real-world commerce.

<CardGroup>
  <Card title="Unleashed Scalability" icon="arrow-up-right-dots" href="#unleashed-scalability">
    The ability to accommodate the ever growing userbase of humans and AI
    agents.
  </Card>

  <Card title="Energy-Based Stable Currency" icon="coin" href="#energy-based-stable-currency">
    Functions as decentralized money for the compute economy.
  </Card>
</CardGroup>

<Frame>
  <img />
</Frame>

## Unleashed Scalability

**Quai keeps transaction fees permanently low by automatically expanding capacity to meet demand.**

Think of Quai as a highway system that automatically adds new lanes as traffic increases. Through [Proof-of-Entropy-Minima (PoEM)](/learn/advanced-introduction/poem/poem), Quai can coordinate multiple parallel processing chains ([execution shards](/learn/advanced-introduction/poem/sharding/execution-sharding)) while maintaining perfect consensus.

Key benefits:

* **Dynamic scaling**: The network automatically adds processing power as demand grows
* **Low fees forever**: More users means more capacity, not higher costs
* **Trustless interoperability**: All shards are seamlessly connected through [miner-validated bridges](/learn/advanced-introduction/merged-mining/coincident-blocks)

The only tradeoff is [slightly longer settlement times](/learn/advanced-introduction/poem/sharding/dynamic-sharding#time-to-global-settlement) when transacting across distant shards—a small price for unlimited scalability.

## Energy-Based Stable Currency

**Unlike traditional stablecoins that rely on collateral or algorithms, Qi derives its stability from the universal constant of energy costs.**

How it works:

* Proof-of-Work mining acts as an [oracle for real-world energy prices](/learn/tokenomics/token-dynamics/token-dynamics)
* The protocol automatically adjusts [Qi supply](/learn/tokenomics/qi-emissions) based on mining costs
* [Market incentives](/learn/tokenomics/token-dynamics/token-dynamics) naturally drive Qi's value toward the cost of energy

Just as a kilowatt-hour has consistent value worldwide, Qi aims to be a universal unit of value. This makes Qi ideal for:

* **Global commerce**: No currency conversion or volatility risk
* **AI economies**: Energy is the primary input for computation
* **Pricing goods, services, and contracts**: Stable purchasing power over time

Energy is the single largest input to both human activity and artificial intelligence. By anchoring currency to energy, Quai creates money that's inherently valuable to both humans and machines.

Quai Network joins protocols like [Hacash](https://hacash.money/) and [Themelio](https://docs.melproject.org/concepts/melmint) in pioneering this new category of energy-based currencies.

<Note>
  **Why This Matters**

  Current blockchains force users to choose between:

  * **Security** (Bitcoin) or **functionality** (Ethereum)
  * **Decentralization** or **low fees**
  * **Stable value** or **trustless operation**

  Quai eliminates these tradeoffs by combining Proof-of-Work security with unlimited scalability and energy-based stability.
</Note>

## Ready to Explore?

<CardGroup>
  <Card title="Try Quai" icon="rocket" href="/learn/use-quai">
    Get started with wallets and tools
  </Card>

  <Card title="Understand the Tech" icon="book" href="/learn/advanced-introduction/poem/poem">
    Deep dive into PoEM consensus
  </Card>

  <Card title="Join the Network" icon="server" href="/guides/client/node">
    Run a node or start mining
  </Card>
</CardGroup>


# Qi Emissions
Source: https://docs.qu.ai/learn/tokenomics/qi-emissions

An explanation of the Qi token.

## The World's First Energy Dollar

Imagine a currency whose value is directly tied to the cost of energy - the most fundamental resource in our economy. That's Qi: the world's first energy-backed digital currency, designed to provide the stability and utility that traditional cryptocurrencies lack.

While Bitcoin and other tokens fluctuate wildly based on speculation, Qi's value is anchored to something real and measurable: the actual cost of energy required to mine it. This creates an intrinsic value floor based on physics and economics, not market sentiment.

**Why Energy Backing Matters:**
Energy is the ultimate store of value - everything valuable requires energy to create or maintain. By pegging Qi to energy costs, we create a currency with real-world stability and intrinsic worth.

**Design for Daily Use:**
Qi is purpose-built for transactions and commerce:

* **Stable value**: Energy backing reduces volatility
* **Fixed denominations**: UTXO-based like physical cash
* **Privacy features**: Cash-like privacy for everyday transactions
* **No scripting**: Simple, efficient, and secure

**Responsive Supply:**
Unlike deflationary Quai, Qi has an accommodative supply that expands with demand. As network usage grows, more Qi enters circulation to meet transaction needs - maintaining stability while enabling scale.

## Energy-Proportional Emissions

The genius of Qi lies in its emission mechanism: rewards are issued in direct proportion to the energy (hash) difficulty required to mine blocks. This creates a direct mathematical relationship between energy costs and token supply, establishing Qi's energy backing.

**How Energy Backing Works:**
Think of difficulty as a proxy for energy costs. When mining becomes more energy-intensive (higher difficulty), Qi rewards increase proportionally to compensate miners. When energy costs decrease (lower difficulty), Qi rewards decrease accordingly.

This creates a dynamic equilibrium:

* **Rising difficulty** → More energy needed → Higher Qi rewards → Maintains energy-value relationship
* **Falling difficulty** → Less energy needed → Lower Qi rewards → Preserves stability

**The Linear Relationship:**
Unlike Quai's logarithmic emissions, Qi uses linear scaling that directly tracks energy expenditure. This ensures that each Qi token represents approximately the same amount of energy, regardless of when it was mined.

$$
Block Reward_{Qi}  ∝ (Difficulty)
$$

Note that there is a proportionality constant/variable in the Qi [block reward](/learn/tokenomics/token-dynamics/block-rewards/block-rewards) function above, which is currently set to $8.0 \times 10^9$.

## Qi Supply: Market-Driven & Demand-Responsive

Unlike traditional cryptocurrencies with predetermined supply schedules, Qi's supply responds dynamically to actual market conditions and usage patterns. This creates a stable, utility-driven currency that expands when needed and contracts when appropriate.

$$
Supply_{Qi} = ∑(Emissions_{Qi}) ± ∑(Conversions_{Qi})
$$

**Two Supply Mechanisms:**

**1. Miner-Selected Emissions:**
The block reward function determines potential Qi emissions, but miners choose whether to receive Quai or Qi rewards. This means Qi supply reflects actual demand from miners, who typically choose based on market conditions and utility needs.

**2. Token Conversions:**
Anyone can convert between Qi and Quai at the current mining reward ratio - not just miners. This [conversion mechanism](/learn/tokenomics/token-dynamics/conversions) allows the market to fine-tune supply based on actual utility demand.

**Why This Matters:**
This dual-mechanism approach ensures Qi supply stays aligned with practical usage needs:

* When transaction demand is high, more Qi enters circulation through conversions
* When mining economics favor stability, miners choose Qi rewards
* Supply automatically adjusts to maintain the energy-value relationship

The result is a currency whose supply grows organically with adoption and usage, maintaining stability while enabling unlimited scale.


# Quai Emissions
Source: https://docs.qu.ai/learn/tokenomics/quai-emissions



## Emissions Overview

Quai supply changes over time from two sources: **genesis unlocks** and **mining emissions**. Two updates shape the current supply trajectory:

* The **Singularity Fork** reduced future genesis unlocks by **1,667,159,984 QUAI** (**81.1%** of future unlocks), shifting the vested baseline from **3,000,000,000 QUAI** to **1,332,840,016 QUAI**.
* **SOAP** funds open-market QUAI buybacks that are burned (100%). At \~**180,000,000 QUAI/year**, that is about **13.6%** of the current post-fork baseline (**\~1.33B QUAI**) burned annually.

## Rethinking Token Emissions

Traditional cryptocurrencies use fixed emission schedules. Bitcoin’s 21 million cap is the best-known example. While predictable, fixed schedules can create artificial scarcity that creates boom-bust cycles as supply continues regardless of changing demand.

A rough analogy: fixing the money supply 100 years in advance, as if the Federal Reserve had to lock in policy today, is similar to fixed token emissions. It imposes mathematical predictability at the expense of market responsiveness.

For a store-of-value token, long-term value creation requires inflation to remain below network growth. The best case is strong demand expansion with controlled supply growth, so value can compound over time without excessive speculative stress.

## Network Value Theory & Emission Design

Network systems often follow two growth phases:

* Early stage: explosive n² expansion from network effects
* Mature stage: slower n×log(n) expansion from efficiency gains

Quai’s emission design is intentionally adaptive so supply growth can track these realities better than fixed schedules. Instead of relying on time-based release cliffs, Quai’s emissions model responds to market conditions: hashrate, price discovery, and demand.

* Price discovery: market value is set by utility and demand
* Network hashrate: security reflects real usage and confidence
* Token utility: true consumption of the network drives durable value

This gives three concrete benefits:

* Adaptive supply: protocol reacts to changing conditions
* Efficient allocation: capital and rewards move where they are most productive
* Reduced volatility: less abrupt supply shocks than rigid, fixed-release models

**81.1%** of future genesis unlocks will be burned at the Singularity Fork — reducing future unlocks from **2,055,088,772 QUAI** to **387,928,788 QUAI**.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

<Note>
  Genesis vested baseline moved from **3,000,000,000 QUAI** to **1,332,840,016 QUAI** at the **Singularity Fork**.
</Note>

**Cap scenario (illustrative):** Total supply = genesis unlocks + mining emissions - SOAP burns. If SOAP buybacks fully offset mining emissions over time, net emissions approach zero and QUAI supply trends toward the post-Singularity genesis baseline: **\~1.33284B QUAI**.

## QUAI Emission Distribution

QUAI is built to become a fair, mining-driven asset. Four years after launch, Mined QUAI becomes the largest source of supply at about **50%**, and by ten years it dominates at greater than **75%**.

In other words, the share of supply tied to early allocations shrinks every year, while the share earned through real proof-of-work grows. Combined with SOAP buyback and burn, this trajectory points toward a QUAI supply that is increasingly decentralized, demand-driven, and scarce over time.

<Frame>
  <img />
</Frame>

For the live, up-to-date supply breakdown, visit [supply.qu.ai](https://supply.qu.ai).

## SOAP Buyback and Burn

With [SOAP](/learn/advanced-introduction/soap) active, merge-mining subsidies from selected parent chains (BCH/LTC/DOGE/RVN) are routed to a protocol address, converted to QUAI on the open market, and then burned or routed to long-term staking rewards. The result is continuous, market-driven buy pressure on QUAI.

In practice, this is the short version:

* External chain subsidy is captured at the protocol level through AuxPoW commitments.
* Quai buys QUAI using that subsidy.
* The flow reduces net supply growth and creates a stronger long-term security budget for miners through staking-weighted support.

For the full technical design (workshares, AuxPoW validation, committee governance, and reward flow), continue to [Project SOAP](/learn/advanced-introduction/soap).
For latest burn flow and program updates, visit [soap.qu.ai](https://soap.qu.ai).

<Frame>
  <img />
</Frame>

<AccordionGroup>
  <Accordion title="Legacy Tokenomics (Pre-SOAP / Pre-Singularity Fork)">
    ### Genesis Allocations: Legacy Baseline

    Legacy baseline before SOAP and the Singularity Fork: **3,000,000,000 vested QUAI**.

    <Frame>
      <img />
    </Frame>

    ### Unlock Schedule

    |                                         |                                                                                                                                                                                   |
    | --------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
    | [**Team**](#team)                       | 1 year cliff, monthly unlock over 36 months (years 1-4)                                                                                                                           |
    | [**Investment Rounds**](#investment)    |                                                                                                                                                                                   |
    | - Seed 1                                | 25% at TGE, 1 year cliff, monthly unlock over 36 months                                                                                                                           |
    | - Seed 2                                | 1 year cliff, 25% at cliff, monthly unlock over 36 months                                                                                                                         |
    | - Strategic                             | 25% at TGE, 1 year cliff, monthly unlock over 36 months                                                                                                                           |
    | [**Development Company**](#dev)         | 25% at TGE, 6-month cliff, monthly unlock over 42 months                                                                                                                          |
    | [**Foundation Reserve**](#foundation)   | 2% at TGE, 6-month cliff, monthly unlock over 66 months                                                                                                                           |
    | [**Community Incentives**](#community)  | 15% at TGE, 6-month cliff, monthly unlock over 42 months                                                                                                                          |
    | [**Testnet & Earn Program**](#testnet)  | Earn Program Wave 1 & Testnet Rewards: 100% available at TGE<br />Earn Program Wave 2 & 3: 25% on first distribution, monthly unlock for 24 months<br />Remaing allocation burned |
    | [**Exchange/Market Making**](#exchange) | 100% available at TGE                                                                                                                                                             |

    <Note>
      This is the legacy model used in docs before SOAP and Singularity Fork updates.
    </Note>

    ### Foundation (33%)

    **Purpose: Maximize adoption of the Quai protocol.**
    2% released at TGE with a 6-month cliff, followed by monthly unlocks over 66 months to fund future innovations, partnerships, and ecosystem growth.

    ### Community Incentives (23%)

    **Purpose: To encourage and reward active participation and contribution from the community.**
    15% released at TGE with a 6-month cliff, followed by monthly unlocks over 42 months, with predefined criteria to ensure fair distribution.

    ### Team (16%)

    **Purpose: To reward and retain talented team members.**
    Tokens have a 1-year cliff followed by monthly unlocks over 36 months (years 1-4) to attract and retain top talent committed to the project.

    ### Investment Rounds (14%)

    **Purpose: To provide capital for development and growth.**

    * **Seed 1 Investors (10%)**: 25% released at TGE with a 1-year cliff, followed by monthly unlocks over 36 months.
    * **Seed 2 Investors (2%)**: 25% released at 1-year cliff, followed by monthly unlocks over 36 months.
    * **Strategic Investors (2%)**: 25% released at TGE with a 1-year cliff, followed by monthly unlocks over 36 months to align with entities providing strategic value.

    ### Development Company (6%)

    **Purpose: To fund ongoing protocol development.**
    25% released at TGE with a 6-month cliff, followed by monthly unlocks over 42 months to support sustainable development efforts.

    ### Testnet & Earn Program (5%)

    **Purpose: To incentivize participation in the testnet phase for debugging and optimizing the network.**
    100% available at TGE with approximately 70M tokens to be burned, ensuring a well-tested network before full deployment.

    ### Exchange Liquidity (2%)

    **Purpose: To provide liquidity on exchanges for the project's token.**
    100% available at TGE to enable easy trading and fair pricing, crucial for attracting new users and investors.
  </Accordion>

  <Accordion title="Emission Mechanics (Optional)">
    Quai supply comes from genesis unlocks and mining emissions, and can be reduced by SOAP buyback and burn.

    For deeper dives:

    * [Block rewards](/learn/tokenomics/token-dynamics/block-rewards/block-rewards)
    * [Conversions](/learn/tokenomics/token-dynamics/conversions/conversions)
  </Accordion>
</AccordionGroup>


# Block Rewards
Source: https://docs.qu.ai/learn/tokenomics/token-dynamics/block-rewards

An explanation of mining and block rewards in Quai Network.

Block rewards in Quai Network follow two fundamentally different mathematical relationships that create the economic foundation for the dual-token system. These reward functions determine not just how many tokens miners receive, but also the long-term supply characteristics that make Quai deflationary and Qi inflationary. Understanding these mathematical relationships is crucial for grasping how Quai Network creates both digital gold and an energy-backed currency.

Quai block rewards are proportional to "bits" of difficulty, which can be approximately represented by the number of leading zeros in each hash that "finds" a valid block. This logarithmic relationship means that as mining becomes exponentially more difficult, Quai rewards increase only incrementally. Quai has an effectively fixed supply, as [inflation trends towards zero over time](/learn/tokenomics/quai-emissions).

$$
Block Reward_{Quai} ∝ log_{2}(Difficulty)
$$

In contrast to Quai's logarithmic scaling, Qi block rewards follow a linear relationship with mining difficulty. Qi block rewards are linearly proportional to "hashes" of difficulty, representing the expected number of computational attempts needed to mine a block at the current difficulty level. This direct proportional relationship ensures that Qi rewards scale directly with the energy cost of mining, creating its energy-backing property.

$$
Block Reward_{Qi} ∝ (Difficulty)
$$

The contrasting mathematical foundations create dramatically different economic properties for each token. This logarithmic versus linear relationship produces the significant difference between Quai scarcity and Qi expansion. For every doubling in mining difficulty - representing twice the computational work and energy expenditure - Quai rewards increase by only one logarithmic unit, while Qi rewards double entirely. Over time, this mathematical divergence ensures Quai's increasing scarcity as the network grows, while Qi remains naturally connected to the actual cost of mining production, functioning as a reliable measure of energy or electricity pricing.

The reward functions establish the mathematical potential for token emissions, but actual supply is determined by market forces and miner preferences. These block reward functions only define how many Quai or Qi tokens can potentially be emitted at any given difficulty level. Actual, realized supply emissions from block rewards are determined by the choices miners must make to receive either Quai or Qi - they cannot receive both simultaneously. This selection mechanism allows miners to respond to market conditions and change their preference at any time, creating a demand-responsive emission system.

This miner choice mechanism means that actual token supply reflects not just mathematical formulas, but real economic preferences and market conditions. When miners prefer stable value for operational expenses, they choose Qi. When they want to hold appreciating assets, they choose Quai.

<Note>
  Note that there are proportionality constants/variables in each of the block
  reward functions provided above. The exact calculus for these
  constants/variables will be shared publicly closer to Mainnet launch.
</Note>

## Coinbase Maturity Period

Beyond choosing between Quai and Qi, miners can further optimize their rewards through strategic lock-up periods. The coinbase maturity system provides additional yield for miners willing to commit their rewards for longer periods, creating incentives for long-term network participation. This system recognizes that longer commitments provide more stability to the network and rewards miners accordingly.

Miners can choose to lock their rewards for extended periods to receive higher yields. The yield multipliers decrease over time as the network matures, providing early adopters with higher rewards while maintaining long-term sustainability.

| Lock Duration | Year 1    | Year 2    | Year 3    | Year 4    | Year 5+   |
| ------------- | --------- | --------- | --------- | --------- | --------- |
| 2 weeks\*     | 1.000000x | 1.000000x | 1.000000x | 1.000000x | 1.000000x |
| 3 months      | 1.035000x | 1.017500x | 1.008750x | 1.004375x | 1.002188x |
| 6 months      | 1.100000x | 1.050000x | 1.025000x | 1.012500x | 1.006250x |
| 12 months     | 1.250000x | 1.125000x | 1.062500x | 1.031250x | 1.015625x |

<sub>\*Base maturity period</sub>


# Conversions
Source: https://docs.qu.ai/learn/tokenomics/token-dynamics/conversions

An explanation of the conversion mechanism between the Quai and Qi tokens.

Token conversions represent one of Quai Network's most innovative features, enabling seamless exchange between its two native tokens at mathematically determined rates. The conversion system serves as both a market mechanism and a stability tool, allowing supply to adjust dynamically to demand while maintaining economic equilibrium between the tokens. Understanding the conversion mechanism is essential for grasping how Quai Network creates a self-regulating monetary system.

The Quai Network Protocol employs two tokens: **Quai**, the native token of an Ethereum Virtual Machine (EVM)-compatible ledger, and **Qi**, the native token of a fixed-denomination Unspent Transaction Output (UTXO) ledger. Both tokens are mineable and interconvertible by holders at a protocol-defined exchange rate that reflects their underlying economic relationship. A sophisticated controller mechanism ensures neutrality between Quai and Qi, preventing any inherent bias toward either token and maintaining fair conversion rates.

This section details the mathematical formulations governing miner difficulty, conversion flow, exchange rate, and transaction adjustments within the protocol. The conversion system operates through multiple interconnected mechanisms that work together to create stability and responsiveness in the dual-token economy.

> **Note**\
> All conversion transactions are locked up for 2 weeks

***

## Core Components

### Miner Difficulty

Miner difficulty at block `i`, denoted `minerDifficulty_i`, is calculated as an Exponential Moving Average (EMA) of prime block difficulty over a 4000-block window. This balances responsiveness to network changes with long-term stability:

<Frame>
  <img />
</Frame>

* `minerDifficulty_{i-1}`: Difficulty at the previous block.
* `blockDifficulty_i`: Difficulty of the current prime block.

This averaging smooths short-term fluctuations while adapting to evolving network conditions.

***

### Block Rewards and `k_Qi`

Block rewards are distributed in Quai or Qi, scaled by coefficients `k_Quai` and `k_Qi`, respectively:

* **Quai Block Reward**:\
  `reward_Quai = k_Quai × log2(blockDifficulty_i)`

* **Qi Block Reward**:\
  `reward_Qi = k_Qi × blockDifficulty_i`

The protocol treats `k_Qi` as a dynamic parameter tied to hashrate efficiency, which evolves with GPU performance improvements. Based on research from [Epoch AI](https://epoch.ai/blog/predicting-gpu-performance), GPU efficiency (measured in flops) doubles every 2.69 years due to smaller transistors and increased core counts, plateauing after 2030. Assuming saturation after two doublings, `k_Qi` adjusts with block height (`number`):

<Frame>
  <img />
</Frame>

Where:

* `baseKqi = 1 / (8 × 10^9)`
* `doublingPeriodInBlocks = (365 × BlocksPerDay × 2.69)`
* `doublingCount = floor(number / doublingPeriodInBlocks)`
* `remainingBlocks = number - doublingCount × doublingPeriodInBlocks`
* `BlocksPerDay`: Constant number of blocks mined per day.

Unlike `k_Qi`, which adjusts to technological trends, `k_Quai` is actively controlled by the protocol to maintain token neutrality. All exchange rate references below pertain to `k_Quai`.

***

### Conversion Flow Amount and Discounts

The conversion flow amount at block `i`, `conversionFlowAmount_i`, is an EMA of Quai conversion amounts, adjusted by two discounts: a **cubic conversion flow discount** and a **K-Quai discount**. It includes a minimum threshold:

<Frame>
  <img />
</Frame>

* `conversionFlowAmount_{i-1}`: Previous block’s conversion flow amount.
* `currentFlowAmount_i`: Current block’s conversion amount before the discounts.

The 100 Quai minimum conversion flow amount is maintained to keep a baseline flow. The adjusted conversion flow is also capped at 2× the previous amount.

#### Cubic Conversion Flow Discount

Each conversion transaction receives a cubic discount:

<Frame>
  <img />
</Frame>

#### K-Quai Discount

K-Quai Discount applies to only one type of conversion at any point depending on the direction of the controller adjustment over the 4000 block window.
If exchange rate is increasing, then the discount applies to Quai to Qi conversions and if exchange rate is decreasing, the discount applies to
only Qi to Quai conversions.

<Frame>
  <img />
</Frame>

#### Discount Cap

`finalValue ≥ 0.1 × originalValue`

#### Max Slip Specification

* **Quai-to-Qi**:
  * Max Slip default: 90% (9000 basis points)
  * Specified in first two bytes of the Data field
  * Refunds happen via `etx` in next zone block

* **Qi-to-Quai**:
  * Data field must be 22 bytes: Bytes 0–1 for slip, 2–21 for refund address
  * Refunds are locked for two weeks, 1 Qi precision

***

### Exchange Rate Calculation

<Frame>
  <img />
</Frame>

Where:

* `kQuai_{i-1}`: Previous rate
* `α = 0.001`
* `d`: Normalized difficulty
* `d*`: Target difficulty

#### Normalized Difficulty

<Frame>
  <img />
</Frame>

#### Target Difficulty

Simple average of adjusted difficulty over last 4000 blocks.

***

### Transaction Processing and Adjusted Difficulty

1. **Coinbase Transactions**: Add a choice to Quai or Qi
2. **Conversion Transactions**: Normalize by destination block reward

<Frame>
  <img />
</Frame>

Sign depends on token choice majority.

***

## Summary

The Quai/Qi controller maintains equilibrium through interconnected mechanisms: miner difficulty adjusts to network effort, conversion flow applies stabilizing discounts, and the exchange rate evolves with normalized and target difficulties. Transaction-based adjustments further refine the system, ensuring fairness and stability in a dual-token framework. These dynamics adapt to miner behavior, conversion trends, and network activity, upholding the protocol’s neutral design.

With the emissions of Qi adjusting to technological trends and all other mechanisms seeking token neutrality between Qi and Quai, Qi becomes a tokenized representation of energy (hashes spent) with stable value over time compared to Quai which becomes a store of value.


# Difficulty Adjustments
Source: https://docs.qu.ai/learn/tokenomics/token-dynamics/difficulty-adjustments

An explanation of difficulty within Quai Network and how it relates to the Quai and Qi tokens.

Difficulty adjustments form the backbone of any proof-of-work blockchain, serving as the automatic regulation system that maintains network stability and security. In Quai Network, this mechanism becomes even more sophisticated, as it must balance not just network security but also the economic relationship between two different tokens with distinct monetary properties. Understanding how difficulty adjustment works provides insight into the fundamental economic forces that drive the entire Quai Network ecosystem.

Work-based protocols are essentially automated supply-and-demand matching systems for network security. These protocols function by continuously monitoring network activity and adjusting mining difficulty to maintain consistent block production rates regardless of how much computational power joins or leaves the network. They periodically set difficulty and block reward values, establishing a desired rate of block production and new token issuance based on the estimated hashrate demand derived from observed block times over recent periods.

The difficulty adjustment mechanism operates as a feedback control system, constantly measuring network performance against target metrics and making corrective adjustments. This continuous optimization process ensures that the network maintains its intended economic and security properties even as external conditions change dramatically. The mechanism works by analyzing recent network activity and adjusting system parameters like difficulty to bring future performance back toward optimal levels.

1. Difficulty set to achieve certain blocktimes based on existing hashrate
2. More than expected miner hashrate deployed
3. Faster blocktimes
4. Increase in system difficulty
5. Harder to mine a block
6. Blocktimes slow toward desired rate

The same flow works in the reverse as well, when less than expected miner hashrate is deployed, blocktimes slow, and difficulty must be adjusted downwards.

Changes in hashrate are driven by market demand. Simply put, miners will deploy more when they’re paid more. With this framing, we can see that mining processes and the difficulty adjustment are best understood as a reactive market supply and demand matching function.

Quai Network makes difficulty adjustments on a rolling basis over a previous set of blocks (instead of in sequential periods), to best match the supply of hashrate and demand for network security.


# Token Dynamics
Source: https://docs.qu.ai/learn/tokenomics/token-dynamics/token-dynamics

An explanation of the emissions, conversions, and supplies of the Quai and Qi tokens.

Quai Network's dual-token system creates a sophisticated economic model that serves different monetary needs. The intricate relationship between [Quai](/learn/tokenomics/quai-emissions) and [Qi](/learn/tokenomics/qi-emissions) tokens positions Quai as an [increasingly-scarce store-of-value](/learn/tokenomics/quai-emissions), while Qi functions as a medium of exchange, loosely tied to the cost of generating a hash and thus the cost of energy. These complementary roles are achieved through carefully designed economic mechanisms that maintain balance and utility.

The primary mechanisms driving these token dynamics are emissions through block rewards, conversions between the two tokens, and a highly responsive difficulty algorithm. Each mechanism works in concert to create a stable, functional monetary system where supply responds to demand in real-time. Understanding these interactions is crucial for grasping how Quai Network maintains economic equilibrium while serving diverse financial needs.

## Emissions (Block Rewards)

Block rewards form the foundation of token creation in Quai Network, determining how new tokens enter circulation. Mining rewards follow two distinct mathematical functions that create fundamentally different supply dynamics for each token. The system measures mining difficulty - essentially how much computational work is required to find a valid block - but applies this measurement in drastically different ways for Quai versus Qi rewards.

Quai and Qi block reward emissions are both calculated as functions of difficulty, but these functions produce opposite scarcity characteristics. The specific mathematical relationships between difficulty and token emissions create the economic properties that make Quai deflationary and Qi inflationary. These relationships are explored in detail on the [block rewards page](/learn/tokenomics/token-dynamics/block-rewards) of the documentation.

The mathematical foundation of token scarcity lies in these contrasting emission functions. The logarithmic relationship between difficulty and Quai emissions versus the linear relationship between difficulty and Qi emissions produces the fundamental difference between Quai scarcity and Qi expansion. For every doubling in mining difficulty - representing twice the computational work - Quai rewards increase by only one logarithmic unit, while Qi rewards double entirely. This creates dramatically different supply trajectories over time.

This design ensures Quai becomes increasingly scarce as the network grows, while Qi remains naturally connected to miners' actual costs of production, making it a reliable measure of energy or electricity pricing. The ability for miners to select which token they wish to receive as block rewards creates a market-driven emission system where Qi supply directly responds to demand, while Quai supply becomes progressively more constrained.

## Conversions

Conversions between Qi and Quai provide the critical mechanism for rapid supply adjustment in response to market conditions. This system creates an arbitrage market that allows any network participant to exchange tokens at any time, not just miners receiving block rewards. The conversion ratio is dynamically determined by the current Quai and Qi block reward rates, ensuring the exchange rate reflects the underlying economic value of each token type.

This conversion mechanism serves as a pressure valve for the entire token system, allowing supply to adjust almost instantly to demand changes. When market conditions shift, participants can convert between tokens to capture value or meet their specific monetary needs, creating natural market-driven supply regulation.

The conversion system creates powerful stabilizing forces that respond to market demand in both directions. When demand for Qi falls, arbitrageurs can swap from Qi to Quai at the current conversion ratio, effectively reducing the circulating supply of Qi and supporting its value. Conversely, when demand for Qi rises, miners become incentivized to accept their block rewards in Qi rather than Quai, increasing the supply of Qi to meet growing demand.

This dual-direction mechanism ensures that Qi supply stays closely aligned with actual usage and demand, while Quai benefits from the deflationary pressure when participants convert to it during low-Qi-demand periods. The conversion dynamic and its mathematical underpinnings are explored more in-depth in the [conversions page](/learn/tokenomics/token-dynamics/conversions) of the documentation.

## Difficulty

Difficulty adjustment represents the fundamental control mechanism that maintains network security and economic stability in Quai Network. Like other proof-of-work systems, the network determines block production rates and token emissions by dynamically adjusting how difficult it is to mine valid blocks. However, Quai Network's approach to difficulty adjustment is more sophisticated and responsive than traditional systems, enabling real-time adaptation to changing market conditions.

At its core, difficulty serves as the network's throttle, controlling how fast new blocks are produced and thus how quickly new tokens enter circulation. This mechanism ensures consistent block times regardless of how much mining power joins or leaves the network.

The difficulty adjustment algorithm operates as a supply-and-demand matching system for network security. Difficulty responds to demand-driven changes in miner hashrate by analyzing block time deviations and renormalizing the target difficulty accordingly. Unlike Bitcoin's periodic adjustments that occur every 2016 blocks, Quai Network implements rolling difficulty adjustments based on a moving window of recent blocks, enabling much faster response to market changes.

This continuous adjustment mechanism prevents the dramatic swings in block times that can occur in systems with infrequent difficulty updates. Instead of waiting for predetermined intervals, the network constantly fine-tunes difficulty to maintain optimal block production rates.

The interaction between rolling difficulty adjustments and the dual-token emission model creates a dynamic economic system where token rewards evolve continuously. As difficulty changes with each block, the respective quantities of potential Quai and Qi rewards shift according to their distinct mathematical functions - logarithmic for Quai and linear for Qi. This means the economic incentives and supply dynamics are constantly adapting to network conditions and miner behavior.

This real-time adjustment system ensures that both tokens maintain their intended economic properties even as network conditions change dramatically over time. The technical details of how Quai Network measures and adjusts difficulty are further explored in the [difficulty adjustments page](/learn/tokenomics/token-dynamics/difficulty-adjustments) of the documentation.


# Tokenomics Overview
Source: https://docs.qu.ai/learn/tokenomics/tokenomics-overview

A high level overview of Quai Network's two-token system.

## Two Tokens, Complete Money System

Most blockchain networks have a single token trying to serve multiple purposes - store of value, payment currency, and unit of account. This creates inherent tensions. Bitcoin is great as digital gold but terrible for buying coffee. Stablecoins work well for payments but aren't good stores of value. Quai solves this by purpose-designing two complementary tokens.

**The Challenge with Single-Token Systems:**
Traditional approaches force one token to be everything:

* Store of value tokens are too volatile for everyday transactions
* Payment tokens lack the scarcity needed for long-term value storage
* Networks must choose between price stability OR value appreciation

**Quai's Two-Token Solution:**
Quai Network introduces two native tokens that work together to provide a complete monetary system:

**[Quai](/learn/tokenomics/quai-emissions)**: The Digital Gold

* EVM-compatible deflationary token designed as a store of value
* Limited supply creates scarcity and potential appreciation
* Perfect for savings, investments, and long-term wealth storage

**[Qi](/learn/tokenomics/qi-emissions)**: The Energy Dollar

* Stable token linked to the cost of energy production
* UTXO-based with cash-like privacy properties
* Ideal for everyday transactions and unit of account

**Together, They Complete Money:**
This dual-token system provides all three essential characteristics of money:

* **Store of Value**: Quai's deflationary design preserves wealth over time
* **Medium of Exchange**: Qi's stability enables frictionless transactions
* **Unit of Account**: Qi's energy peg provides consistent pricing reference

For the first time, a single network provides both digital gold and a practical currency, creating a truly complete decentralized monetary system.

## Token Names & Etymology

The names aren't arbitrary - they reflect each token's fundamental purpose:

**Quai (pronounced "k-why")**
Derives from the Chinese character 块, a colloquial term for money similar to "buck" or "quid" in English. Just as these informal terms became synonymous with currency, Quai represents the evolution of digital money.

**Qi (pronounced "chee")**
Comes from the Chinese character 气, meaning "energy" or "life force." This reflects Qi's unique property as an energy-backed currency - the world's first token whose value is intrinsically tied to the cost of energy production.

These names capture the essence of what makes Quai's monetary system revolutionary: Quai as digital money for value storage, and Qi as energy-backed currency for transactions.

## SOAP: Making It All Sustainable

SOAP turns merge-mining rewards into continuous QUAI **buyback and burn**.

How it works:

1. Merge-mined rewards flow into SOAP
2. SOAP buys QUAI on the open market
3. Purchased QUAI is burned (100%)

The result is a built-in sink for supply that can help offset emissions.

<Frame>
  <img />
</Frame>

For the broader supply story, see [Quai Emissions](/learn/tokenomics/quai-emissions) and [SOAP](/learn/advanced-introduction/soap).


# Use Quai
Source: https://docs.qu.ai/learn/use-quai

Explore the various ways to participate in the Quai Network ecosystem, from mining to DeFi and beyond.

Quai Network started in 2018 with the design of a scalable proof-of-work architecture and a plan for a hierarchical, merge-mined chain to scale PoW.
It emerged from the [Dr. K](https://x.com/mechanikalk)’s work and GridPlus and was a research project at the University of Texas at Austin, where NSF-supported research in 2019 helped advance the concept into a development comapny called Dominant Strategies.
Since then, it has been developed and improved with innovations like Proof-of-Entropy-Minima [(PoEM)](https://arxiv.org/abs/2303.04305), a dual-token model (Qi and Quai), multi-algorithm mining, and workshare considerations. Quai Network mainnet began with the genesis block on February 4, 2025.

<CardGroup>
  <Card title="Get a Wallet" icon="wallet" href="#get-a-quai-wallet">
    Set up your Quai Network wallet to start participating in the ecosystem.
  </Card>

  <Card title="Get Quai" icon="coins" href="#get-quai">
    Purchase QUAI via centralized exchanges, instant swaps, and bridges.
  </Card>

  <Card title="Mine Quai" icon="pickaxe" href="#mine-quai">
    Secure the network and earn rewards through solo or pool mining configurations.
  </Card>

  <Card title="Build on Quai" icon="code" href="#build-on-quai">
    Access developer guides, SDKs, and grants to launch your dApp on the network.
  </Card>

  <Card title="Network Tools & Explorers" icon="chart-network" href="#network-tools-and-explorers">
    Visualize the hierarchy, track live transactions, and monitor network health.
  </Card>

  <Card title="Understand Quai" icon="book-open" href="#understand-quai">
    Deep dive into the architecture, tokenomics, and economic innovations like SOAP and Qi.
  </Card>
</CardGroup>

<Card title="Where to Find Quai Network?" icon="magnifying-glass-location" href="#where-to-find-quai-network">
  Join the global community and follow official channels for the latest updates and announcements.
</Card>

## Get a Quai Wallet

Choose from several wallet options to store and manage your assets.

| Wallet                                                                      | Type              | Features               | Status             |
| :-------------------------------------------------------------------------- | :---------------- | :--------------------- | :----------------- |
| [Pelagus Wallet](https://pelaguswallet.io)                                  | Browser Extension | Official Quai wallet   | Supports QUAI & QI |
| [Blip Mobile](https://blippay.me)                                           | Mobile App        | Beta mobile payments   | Available for QUAI |
| [Tangem](https://tangem.com)                                                | Hardware Wallet   | Physical card security | Available for QUAI |
| [Metamask Snap](/guides/wallet/metamask-snap)                               | Browser Extension | Metamask integration   | Available for QUAI |
| [Quai CLI](https://github.com/dominant-strategies/quai-cli-wallet/releases) | Command Line      | Linux/MacOS support    | Available for QUAI |

## Get QUAI

### Centralized Exchanges (CEX)

Trade QUAI on major exchanges.

| Exchange                                                        | Pair      | Features                   | Status    |
| :-------------------------------------------------------------- | :-------- | :------------------------- | :-------- |
| [Gate.io](https://www.gate.io/trade/QUAI_USDT)                  | QUAI/USDT | Highest volume & liquidity | Available |
| [MEXC](https://www.mexc.com/exchange/QUAI_USDT)                 | QUAI/USDT | Popular global exchange    | Available |
| [BitMart](https://www.bitmart.com/trade/en-US?symbol=QUAI_USDT) | QUAI/USDT | User-friendly interface    | Available |
| [CoinEx](https://www.coinex.com/en/exchange/QUAI-USDT)          | QUAI/USDT | Popular global exchange    | Available |
| [Kraken](https://www.kraken.com)                                | QUAI/USD  | Major US Exchange          | Available |
| [BloFin](https://blofin.com/spot/en/QUAI-USDT)                  | QUAI/USDT | Popular global exchange    | Available |
| [Ourbit](https://www.ourbit.com/exchange/QUAI_USDT)             | QUAI/USDT | Popular global exchange    | Available |

### Decentralized Exchanges (DEX)

Trade QUAI on Base. Now available via [Symbiosis Bridge](/learn/bridge-to-quai).

<Warning>
  Always validate contract addresses on networks other than Quai. Quai on Base: 0x5c97D726bf5130AE15408cE32bc764e458320D2f
</Warning>

<div>
  <a href="https://swap.cow.fi/#/8453/swap/ETH/0x5c97D726bf5130AE15408cE32bc764e458320D2f">
    <img alt="CoW" />

    Buy QUAI on CoW on Base
  </a>

  <a href="https://1inch.com/swap?src=1:ETH&dst=8453:0x5c97d726bf5130ae15408ce32bc764e458320d2f">
    <img alt="1inch" />

    Buy QUAI on 1inch on Base
  </a>

  <a href="https://jumper.exchange/?fromChain=8453&fromToken=0x0000000000000000000000000000000000000000&toChain=8453&toToken=0x5c97D726bf5130AE15408cE32bc764e458320D2f">
    <img alt="Jumper" />

    Buy QUAI on Jumper on Base
  </a>

  <a href="https://oku.trade/swap?inputChain=base&inToken=0x0000000000000000000000000000000000000000&outToken=0x5c97D726bf5130AE15408cE32bc764e458320D2f">
    <img alt="oku" />

    Buy QUAI on oku on Base
  </a>

  <a href="https://www.sushi.com/base/swap?token0=NATIVE&token1=0x5c97d726bf5130ae15408ce32bc764e458320d2f">
    <img alt="Sushi" />

    Buy QUAI on Sushi on Base
  </a>

  <a href="https://lfj.gg/base/swap?inputCurrency=ETH&outputCurrency=0x5c97D726bf5130AE15408cE32bc764e458320D2f">
    <img alt="LFJ" />

    Buy QUAI on LFJ on Base
  </a>

  <a href="https://aerodrome.finance/swap?from=eth&to=0x5c97d726bf5130ae15408ce32bc764e458320d2f&chain0=8453&chain1=8453">
    <img alt="Aerodrome" />

    Buy QUAI on Aerodrome on Base
  </a>
</div>

### KYC-Free Instant Swaps

Exchange cryptocurrencies for QUAI without registration. Note that for fiat support, the platforms below rely on stablecoins (USDC, USDT).

| Platform                                | Type        | Features                                          |
| :-------------------------------------- | :---------- | :------------------------------------------------ |
| [SwapSpace](https://swapspace.co)       | Aggregator  | Compare rates across services                     |
| [LetsExchange](https://letsexchange.io) | Direct Swap | Quick crypto-to-crypto                            |
| [Buy QUAI](https://buyquai.com/)        | Direct Swap | Swap USDT for QUAI on Ethereum or BNB Smart Chain |
| [ChangeHero](https://changehero.io/)    | Direct Swap | Quick crypto-to-crypto                            |

### Bridges

Transfer assets securely to and from Quai Network.

| Bridge                                 | Supported Networks | Status                        |
| :------------------------------------- | :----------------- | :---------------------------- |
| [Symbiosis](https://symbiosis.finance) | Ethereum, Base     | [Live](/learn/bridge-to-quai) |

### On Ramps

Buy QUAI directly with fiat currency.

| Platform                         | Features             |
| :------------------------------- | :------------------- |
| [FinchPay](https://finchpay.io/) | Buy crypto with fiat |

## Mine Quai

Quai Network uses the KawPow mining algorithm and is merge-mined with SHA-256 and Scrypt. Miners can select to mine either QUAI or QI.

### Solo Mining (StratumX)

Connect to decentralized mining infrastructure with no fees, no KYC, with full self-custody and mining customization including Qi mining and [Locked Mining Rewards](https://docs.qu.ai/learn/advanced-introduction/liquid-mining-tokens).

| Resource                                                    | Type          | Features                                                             |
| :---------------------------------------------------------- | :------------ | :------------------------------------------------------------------- |
| [StratumX.org](https://www.stratumx.org/)                   | Platform      | Connect SHA-256, Scrypt, and KawPow rigs directly (no node required) |
| [Revenue Calculator](https://www.stratumx.org/calculator)   | Tool          | Estimate profitability for different algorithms                      |
| [Setup Guide](https://docs.qu.ai/guides/client/solo-mining) | Documentation | Run a StratumX node for QUAI mining with KawPow, Scrypt, SHA-256     |

### Mining Resources

Essential guides and data for miners.

| Resource                                                                                                              | Category      | Description                                                     |
| :-------------------------------------------------------------------------------------------------------------------- | :------------ | :-------------------------------------------------------------- |
| [Mining Guide](https://docs.qu.ai/guides/miner/)                                                                      | Documentation | Guides for SHA-256, Scrypt, and KawPow (HiveOS, Ubuntu, Docker) |
| [Pools & Software](https://docs.qu.ai/guides/miner/pools-software)                                                    | List          | Comprehensive list of available pools and mining software       |
| [go-quai Client Setup](https://docs.qu.ai/guides/client/node)                                                         | Documentation | Guide for setting up and maintaining a Quai node                |
| [MiningPoolStats](https://miningpoolstats.stream/quai/)                                                               | Data          | Live hashrate distribution and pool stats                       |
| [Mining Strategy](https://qu.ai/blog/maximizing-mining-strategy-in-quai-network-choosing-between-quai-and-qi-tokens/) | Blog          | Guide on choosing between mining Quai or Qi                     |

## Build on Quai

### Developer Resources

Everything you need to start building dApps on Quai.

| Resource                                                                                        | Description                                                 |
| :---------------------------------------------------------------------------------------------- | :---------------------------------------------------------- |
| [Quai Academy](https://quai-academy.gitbook.io/quai-academy/getting-started/about-quai-network) | Educational materials from the community                    |
| [Solidity Guides](https://docs.qu.ai/guides/development/)                                       | Documentation for Solidity & SolidityX development          |
| [Quai APIs](https://docs.qu.ai/build/apis/)                                                     | Reference for interacting with the network programmatically |
| [Smart Contract SDK](https://docs.qu.ai/sdk/introduction)                                       | Tools and libraries for contract deployment and interaction |
| [Developer Discord](https://discord.gg/utBPaFZnZu)                                              | Technical support and community discussion                  |
| [Builders Grants](https://docs.qu.ai/build/grants#quai-builders-program-and-grants)             | Funding opportunities for developers and projects           |

## Network Tools & Explorers

Track network activity and explore the blockchain.

| Tool                                         | Purpose          | Features                                      |
| :------------------------------------------- | :--------------- | :-------------------------------------------- |
| [QuaiScan](https://quaiscan.io/)             | Block Explorer   | Search transactions, blocks, and addresses    |
| [Network Stats](https://stats.quai.network/) | Live Statistics  | Real-time node count and hashrate data        |
| [Chain Visualizer](https://live.qu.ai/)      | 3D Visualization | Interactive view of the multi-chain hierarchy |
| [QuaiSwap](https://quaiswap.io/)             | DEX              | Swap tokens on Quai Network                   |

## Understand Quai

<iframe title="Quai Network Video" />

### Core Concepts

Quick guide to learning what makes Quai unique.

| Resource                                                                                                                                                            | Format   | Description                                                                                |
| :------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :------- | :----------------------------------------------------------------------------------------- |
| [The Origin Story of Quai Network?](https://www.youtube.com/watch?v=-NLnQQkErXQ)                                                                                    | Video    | How Quai Network came to be                                                                |
| [Stephen Wolfram and Dr. K: Blockchain & Physics, PoEM, Thermoeconomics](https://youtube.com/playlist?list=PLSGKRp6O6_8N7-QQT14taRm-RfCFi-MZd\&si=hanWwTbJbb2Md9Q0) | Playlist | Stephen Wolfram and Dr. K  discuss the future of blockchain in a three-part podcast series |
| [Quai Explained](https://www.youtube.com/watch?v=8WnXOQZI6yo)                                                                                                       | Video    | Interview with Dr. K                                                                       |
| [Quai Primer (PDF)](https://qu.ai/wp-content/uploads/2024/10/Quai-Primer_10_14.pdf)                                                                                 | Document | High-level introduction                                                                    |
| [Whitepapers](https://docs.qu.ai/learn/academic-resources/whitepapers)                                                                                              | Document | Technical specifications                                                                   |
| [Quai vs Other Chains](https://x.com/QuaiNetwork/status/1984992140494094517?s=20)                                                                                   | Thread   | Comparison on X (Twitter)                                                                  |
| [DefiLLama](https://defillama.com/revenue/chains)                                                                                                                   | Data     | Chain Revenue statistics                                                                   |

### What is Qi?

More resources about the [Energy Dollar](https://docs.qu.ai/learn/tokenomics/qi-emissions).

| Topic                                                                 | Format | Resource             |
| :-------------------------------------------------------------------- | :----- | :------------------- |
| [Conversions Dashboard](https://conversions.quai.network/)            | Tool   | Live Quai ↔ Qi rates |
| [The Energy Dollar](https://youtu.be/L5rm7UZQHjs?si=4paV0vJA6bbO5Ss_) | Video  | 5-min explainer      |

### What is SOAP?

More resources about the [Subsidized Open-market Acquisition Protocol (SOAP)](https://docs.qu.ai/learn/advanced-introduction/soap) and token burning mechanisms.

| Resource                                                                                    | Format  | Description                                              |
| :------------------------------------------------------------------------------------------ | :------ | :------------------------------------------------------- |
| [SOAP Dashboard](https://soap.qu.ai/)                                                       | Tool    | Live metrics and stats                                   |
| [Total QUAI Burned](https://quaiscan.io/address/0x0050AF0000000000000000000000000000000000) | Data    | Burn address tracker                                     |
| [Release Blog](https://qu.ai/blog/soap-revolutionizing-proof-of-work-economics-security/)   | Article | Explainer blog how SOAP is revolutionizing PoW economics |
| [Video Overview](https://youtu.be/b5X_DxX-im0?si=P3pYo68Ukk3ul0NQ)                          | Video   | Mechanism deep dive in a university call by Dr. K        |

### Backers & Market

Details on the financial partners and economic structure.

| Entity                                                                                             | Type     | Role                                              |
| :------------------------------------------------------------------------------------------------- | :------- | :------------------------------------------------ |
| [Polychain Capital](https://blog.qu.ai/quai-network-raises-8m-from-polychain-capital-a34c2447a420) | Investor | Strategic Round                                   |
| [Alumni Ventures](https://qu.ai/blog/alumni-ventures/)                                             | Investor | Strategic Round                                   |
| [GSR.io](https://www.gsr.io/)                                                                      | Partner  | Market Maker                                      |
| [Tokenomics](https://docs.qu.ai/learn/tokenomics)                                                  | Guide    | Overview of supply & emissions                    |
| [Supply Dashboard](https://supply.qu.ai)                                                           | Tool     | Live QUAI supply breakdown & allocation over time |

## Where to Find Quai Network?

### Official Resources

<CardGroup>
  <Card title="qu.ai" icon="globe" href="https://qu.ai">
    Official website for Quai Network
  </Card>

  <Card title="quai.org" icon="folder-open" href="https://quai.org">
    Central hub for the Quai ecosystem
  </Card>

  <Card title="GitHub" icon="github" href="https://github.com/dominant-strategies">
    Main Dominant Strategies codebase
  </Card>

  <Card title="Media Kit" icon="newspaper" href="https://docs.qu.ai/get-involved/quai-media-kit">
    Official logos and brand assets
  </Card>

  <Card title="Discord" icon="discord" href="https://discord.gg/quai">
    Main Quai Nation chat
  </Card>

  <Card title="X" icon="x-twitter" href="https://x.com/QuaiNetwork">
    Latest real-time updates
  </Card>

  <Card title="YouTube" icon="youtube" href="https://youtube.com/@quainetwork?si=nOgJxlgMGF6kpnSX">
    Educational content and tutorials
  </Card>

  <Card title="Telegram News" icon="bullhorn" href="https://t.me/QuaiNetwork_Announcements">
    Official announcements channel
  </Card>

  <Card title="Telegram Chat" icon="telegram" href="https://t.me/QuaiNetwork">
    General community discussion
  </Card>
</CardGroup>


# Introduction
Source: https://docs.qu.ai/sdk/introduction

Introduction to the Quais SDK.

The Quais SDK is a complete Quai Network interaction library for JavaScript and TypeScript. Quais was built using the Ethers v6 framework, with significant changes made to support Quai Network's multi-chain environment.

This will be a very short introduction to the SDK's features, installation, and important concepts.

## Quai Specific Features

<CardGroup>
  <Card title="API Compatibility" icon="code-branch">
    Quais utilizes the `quai_` namespace, which allows developers to correctly make calls to any Quai RPC endpoint or wallet. Quai APIs also
    return different data types in comparison to Ethereum APIs, which the SDK is built to handle.
  </Card>

  <Card title="Utilities" icon="wrench-simple">
    The quais SDK has a number of additional utility functions designed to make handling the hierarchy much easier.
  </Card>

  <Card title="Contract Address Grinding" icon="grid-5">
    Similar to the address sharding mentioned above, contract addresses must have a shard prefix. During deployment, Quais handles address
    grinding to ensure the contract address has the correct shard prefix.
  </Card>
</CardGroup>

<Warning>
  **NOTE** if the contract you are interacting with uses the CREATE2 opcode, quais is unable to handle the address grinding for you. You
  must ensure that when deploying a new contract using CREATE2 that the deployed contract will be in the proper address scope of the shard
  that you intend to deploy to. For more information and examples please refer to [Sharding](/learn/advanced-introduction/hierarchical-structure/sharding)
  in the docs.
</Warning>

## Installation

To install Quais, simply install via NPM:

```bash theme={null}
npm install quais
```

<Warning>To use the Quais SDK, you need to be running NodeJS with a version higher than 17.</Warning>

All of the methods in Quais are exported at the root level and available through the `quais` object. Exports are also available for each module, which allows for more granular control of method imports.

Quais supports imports in both Node.js and ESM in browser environments.

<Tabs>
  <Tab title="import in Node.js">
    ```js theme={null}
    // Import all methods
    import { quais } from 'quais'

    // Import specific methods
    import { getZoneFromAddress, parseQuai } from 'quais'

    // Import from a specific module
    import { QuaiHDWallet } from 'quais/wallet'
    ```
  </Tab>

  <Tab title="import in ESM">
    ```js theme={null}
    <script type="module">
      import { quais } from "./dist/quais.min.js";
    </script>
    ```
  </Tab>
</Tabs>

## Concepts

### Provider

A [Provider](/sdk/content/interfaces/Provider) is the primary interface for reading data from any chain or ledger within Quai Network. With a Provider, you can query details about accounts, blocks and transactions, event logs, and much more.

As the **Provider** class provides exclusively read-only access to the network, it is often paired alongside a **Signer** to create a read-and-write system for full interaction with the network.

```js theme={null}
// Connect a provider to pelagus
const browserProvider = new quais.BrowserProvider(window.pelagus)

// Connect a provider to a remote node
const provider = new quais.JsonRpcProvider('https://rpc.quai.network', undefined, { usePathing: true })
```

### Transaction

Transactions are state changing operations made to any of the chains within the network. They are always accompanied by a fee, which covers the cost of transaction execution and information storage for network operators.

Quais supports transactions on all shards across both the Quai and Qi ledgers. Account based Quai transactions are represented by the [QuaiTransaction](/sdk/content/classes/QuaiTransaction) class. UTXO ledger Qi transactions are represented by the [QiTransaction](/sdk/content/classes/QiTransaction) class.

Transactions within Quai generally serve 4 different purposes: sending tokens from one user to another, deploying a smart contract, executing a state changing operation in a smart contract, or natively converting from Quai to Qi.

```ts theme={null}
// Create a transaction
const tx: QuaiTransactionRequest = {
	to: '0x1234567890123456789012345678901234567890',
	value: parseQuai('1.0'),
}

// Send a transaction
await signer.sendTransaction(tx)
```

### Contract

A [Contract](/sdk/content/classes/Contract) is a piece of code that has been deployed to and stored on the Quai ledger virtual machine. They do not exist on the Qi ledger.

Contract state changing operations can be executed using a [Signer](/sdk/content/interfaces/Signer) and data can be from them using a [Provider](/sdk/content/interfaces/Provider).

```js theme={null}
// create a contract
const contract = new quais.Contract(contractAddress, contractABI, provider)

// call a read-only contract function
const symbol = await contract.symbol()
```


# Addresses
Source: https://docs.qu.ai/sdk/static/address

Quai and Qi address utilities.

## Overview

**Addresses are a fundamental part of interacting with Quai Network**. They represent the global identity of Externally Owned Accounts (accounts backed by a private key), contracts, and UTXO wallets.

These functions help convert between various formats, validate addresses across the Quai and Qi address spaces, and other utilities for working with addresses.

The Quais SDK supports the following address formats:

* **Quai addresses**: Account ledger addresses
* **Qi addresses**: UTXO ledger addresses

Quai and Qi addresses utilize a [sharded address space](/learn/advanced-introduction/hierarchical-structure/sharding#sharded-address-space) to allow nodes and wallets to quickly identify which chain and ledger an address resides on. The first 9 bits of every address is the binary identification prefix, of which the first 8 bits are the chain identifiers, and the last bit is the ledger identifier.

| bits 0-3      | bits 4-7    | bit 8             |
| ------------- | ----------- | ----------------- |
| region number | zone number | ledger identifier |

The following addresses are examples to illustrate how the binary identification prefixes work in practice.

| Address                                    | Region    | Zone    | Ledger |
| ------------------------------------------ | --------- | ------- | ------ |
| 0x000DEADBEEFCAFE0000000000000000000000000 | region-0  | zone-0  | Quai   |
| 0x2A40000DEADBEEFCAFE000000000000000000000 | region-2  | zone-10 | Quai   |
| 0xFF700000000DEADBEEFCAFE00000000000000000 | region-15 | zone-15 | Quai   |
| 0x008000000000000DEADBEEFCAFE0000000000000 | region-0  | zone-0  | Qi     |
| 0xF3F0000000000000000DEADBEEFCAFE000000000 | region-15 | zone-3  | Qi     |

## Usage

Most commonly, the provided address utilities are used to validate addresses in the Quai and Qi address spaces.

### Validate a Quai address

To validate a Quai address, you can use the [isQuaiAddress](/content/functions/isQuaiAddress) function, which returns `true` if the address is in the Quai ledger scope, and `false` otherwise.

```ts theme={null}
import { isQuaiAddress } from 'quais'

const address = '0x8ba1f109551bD432803012645Ac136ddd64DBA72'

if (isQuaiAddress(address)) {
	console.log('This is a valid Quai address')
} else {
	console.log('This is not a valid Quai address')
}
```

### Validate a Qi address

In the case of Qi addresses, you can use the [isQiAddress](/content/functions/isQiAddress) function, which returns `true` if the address is in the Qi ledger scope, and `false` otherwise.

```ts theme={null}
import { isQiAddress } from 'quais'

const address = '0x8ba1f109551bD432803012645Ac136ddd64DBA72'

if (isQiAddress(address)) {
	console.log('This is a valid Qi address')
} else {
	console.log('This is not a valid Qi address')
}
```


# AbiCoder
Source: https://docs.qu.ai/sdk/content/classes/AbiCoder



The **AbiCoder** is a low-level class responsible for encoding JavaScript values into binary data and decoding binary
data into JavaScript values.

## Methods

### decode()

```ts theme={null}
decode(
   types, 
   data, 
   loose?): Result
```

Decode the ABI data as the types into values.

If loose decoding is enabled, then strict padding is not enforced. Some older versions of Solidity incorrectly
padded event data emitted from `external` functions.

#### Parameters

| Parameter | Type                                                                    | Description                               |
| :-------- | :---------------------------------------------------------------------- | :---------------------------------------- |
| `types`   | readonly (`string` \| [`ParamType`](/sdk/content/classes/ParamType))\[] | Array of parameter types.                 |
| `data`    | [`BytesLike`](/sdk/content/type-aliases/BytesLike)                      | The ABI data to decode.                   |
| `loose`?  | `boolean`                                                               | Enable loose decoding. Default is `false` |

#### Returns

[`Result`](/sdk/content/classes/Result)

The decoded values.

#### Source

[abi/abi-coder.ts:223](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/abi-coder.ts#L223)

***

### encode()

```ts theme={null}
encode(types, values): string
```

Encode the values as the specified types into ABI data.

#### Parameters

| Parameter | Type                                                                    | Description                |
| :-------- | :---------------------------------------------------------------------- | :------------------------- |
| `types`   | readonly (`string` \| [`ParamType`](/sdk/content/classes/ParamType))\[] | Array of parameter types.  |
| `values`  | readonly `any`\[]                                                       | Array of values to encode. |

#### Returns

`string`

The encoded data in hexadecimal format.

#### Source

[abi/abi-coder.ts:201](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/abi-coder.ts#L201)

***

### getDefaultValue()

```ts theme={null}
getDefaultValue(types): Result
```

Get the default values for the given types. For example, a `uint` is by default `0` and `bool` is by default
`false`.

#### Parameters

| Parameter | Type                                                                    | Description                                         |
| :-------- | :---------------------------------------------------------------------- | :-------------------------------------------------- |
| `types`   | readonly (`string` \| [`ParamType`](/sdk/content/classes/ParamType))\[] | Array of parameter types to get default values for. |

#### Returns

[`Result`](/sdk/content/classes/Result)

The default values corresponding to the given types.

#### Source

[abi/abi-coder.ts:188](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/abi-coder.ts#L188)

***

### defaultAbiCoder()

```ts theme={null}
static defaultAbiCoder(): AbiCoder
```

Returns the shared singleton instance of a default [**AbiCoder**](/sdk/content/classes/AbiCoder).

On the first call, the instance is created internally.

#### Returns

[`AbiCoder`](/sdk/content/classes/AbiCoder)

The default ABI coder instance.

#### Source

[abi/abi-coder.ts:252](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/abi-coder.ts#L252)

***

### getBuiltinCallException()

```ts theme={null}
static getBuiltinCallException(
   action, 
   tx, 
   data): CallExceptionError
```

Returns a quais-compatible [**CallExceptionError**](/sdk/content/interfaces/CallExceptionError) for the given result data.

#### Parameters

| Parameter  | Type                                                                   | Description                                  |
| :--------- | :--------------------------------------------------------------------- | :------------------------------------------- |
| `action`   | [`CallExceptionAction`](/sdk/content/type-aliases/CallExceptionAction) | The action that triggered the exception.     |
| `tx`       | `object`                                                               | The transaction information.                 |
| `tx.data`? | `string`                                                               | -                                            |
| `tx.from`? | `null` \| `string`                                                     | -                                            |
| `tx.to`?   | `null` \| `string`                                                     | -                                            |
| `data`     | `null` \| [`BytesLike`](/sdk/content/type-aliases/BytesLike)           | The data associated with the call exception. |

#### Returns

[`CallExceptionError`](/sdk/content/interfaces/CallExceptionError)

The corresponding call exception error.

#### Source

[abi/abi-coder.ts:267](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/abi-coder.ts#L267)


# BaseContract
Source: https://docs.qu.ai/sdk/content/classes/BaseContract



Creates a new contract connected to target with the abi and optionally connected to a runner to perform operations on
behalf of.

## Implements

* [`Addressable`](/sdk/content/interfaces/Addressable)
* [`EventEmitterable`](/sdk/content/interfaces/EventEmitterable)\<[`ContractEventName`](/sdk/content/type-aliases/ContractEventName)>

## Properties

| Property    | Modifier   | Type                                                                                     | Description                                                                                                                                                                                                                                                                                                           |
| :---------- | :--------- | :--------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `fallback`  | `readonly` | `null` \| [`WrappedFallback`](/sdk/content/interfaces/WrappedFallback)                   | The fallback or receive function if any.                                                                                                                                                                                                                                                                              |
| `filters`   | `readonly` | `Record`\<`string`, [`ContractEvent`](/sdk/content/interfaces/ContractEvent)\<`any`\[]>> | All the Events available on this contract.                                                                                                                                                                                                                                                                            |
| `interface` | `readonly` | [`Interface`](/sdk/content/classes/Interface)                                            | The contract Interface.                                                                                                                                                                                                                                                                                               |
| `runner`    | `readonly` | `null` \| [`ContractRunner`](/sdk/content/interfaces/ContractRunner)                     | The connected runner. This is generally a [**Provider**](../interfaces/Provider) or a<br />[**Signer**](../interfaces/Signer), which dictates what operations are supported.<br /><br />For example, a **Contract** connected to a [**Provider**](../interfaces/Provider) may only execute read-only<br />operations. |
| `target`    | `readonly` | `string` \| [`Addressable`](/sdk/content/interfaces/Addressable)                         | The target to connect to.<br /><br />This can be an address or any [Addressable](../interfaces/Addressable), such as another contract. To get the<br />resolved address, use the `getAddress` method.                                                                                                                 |

## Methods

### addListener()

```ts theme={null}
addListener(event, listener): Promise<BaseContract>
```

Alias for [**on**](/sdk/content/classes/BaseContract#on).

#### Parameters

| Parameter  | Type                                                               | Description                                     |
| :--------- | :----------------------------------------------------------------- | :---------------------------------------------- |
| `event`    | [`ContractEventName`](/sdk/content/type-aliases/ContractEventName) | The event to listen for.                        |
| `listener` | [`Listener`](/sdk/content/type-aliases/Listener)                   | The listener to call when the event is emitted. |

#### Returns

`Promise`\<[`BaseContract`](/sdk/content/classes/BaseContract)>

#### Implementation of

[`EventEmitterable`](/sdk/content/interfaces/EventEmitterable).[`addListener`](/sdk/content/interfaces/EventEmitterable#addlistener)

#### Source

[contract/contract.ts:1490](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1490)

***

### attach()

```ts theme={null}
attach(target): BaseContract
```

Return a new Contract instance with the same ABI and runner, but a different `target`.

#### Parameters

| Parameter | Type                                                             | Description               |
| :-------- | :--------------------------------------------------------------- | :------------------------ |
| `target`  | `string` \| [`Addressable`](/sdk/content/interfaces/Addressable) | The target to connect to. |

#### Returns

[`BaseContract`](/sdk/content/classes/BaseContract)

The new contract instance.

#### Source

[contract/contract.ts:1167](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1167)

***

### connect()

```ts theme={null}
connect(runner): BaseContract
```

Return a new Contract instance with the same target and ABI, but a different `runner`.

#### Parameters

| Parameter | Type                                                                 | Description        |
| :-------- | :------------------------------------------------------------------- | :----------------- |
| `runner`  | `null` \| [`ContractRunner`](/sdk/content/interfaces/ContractRunner) | The runner to use. |

#### Returns

[`BaseContract`](/sdk/content/classes/BaseContract)

The new contract instance.

#### Source

[contract/contract.ts:1157](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1157)

***

### deploymentTransaction()

```ts theme={null}
deploymentTransaction(): null | ContractTransactionResponse
```

Return the transaction used to deploy this contract.

This is only available if this instance was returned from a [**ContractFactor**](../classes/ContractFactory).

#### Returns

`null` | [`ContractTransactionResponse`](/sdk/content/classes/ContractTransactionResponse)

The transaction used to deploy this contract or `null`.

#### Source

[contract/contract.ts:1248](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1248)

***

### emit()

```ts theme={null}
emit(event, ...args): Promise<boolean>
```

Emit an `event` calling all listeners with `args`.

Resolves to `true` if any listeners were called.

#### Parameters

| Parameter | Type                                                               | Description                             |
| :-------- | :----------------------------------------------------------------- | :-------------------------------------- |
| `event`   | [`ContractEventName`](/sdk/content/type-aliases/ContractEventName) | The event to emit.                      |
| ...`args` | `any`\[]                                                           | The arguments to pass to the listeners. |

#### Returns

`Promise`\<`boolean`>

`true` if any listeners were called.

#### Implementation of

[`EventEmitterable`](/sdk/content/interfaces/EventEmitterable).[`emit`](/sdk/content/interfaces/EventEmitterable#emit)

#### Source

[contract/contract.ts:1379](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1379)

***

### getAddress()

```ts theme={null}
getAddress(): Promise<string>
```

Return the resolved address of this Contract.

#### Returns

`Promise`\<`string`>

The resolved address.

#### Implementation of

[`Addressable`](/sdk/content/interfaces/Addressable).[`getAddress`](/sdk/content/interfaces/Addressable#getaddress)

#### Source

[contract/contract.ts:1176](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1176)

***

### getDeployedCode()

```ts theme={null}
getDeployedCode(): Promise<null | string>
```

Return the deployed bytecode or null if no bytecode is found.

#### Returns

`Promise`\<`null` | `string`>

The deployed bytecode or null.

#### Throws

If the runner does not support .provider.

#### Source

[contract/contract.ts:1186](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1186)

***

### getEvent()

```ts theme={null}
getEvent(key): ContractEvent<any[]>
```

Return the event for a given name. This is useful when a contract event name conflicts with a JavaScript name
such as `prototype` or when using a Contract programatically.

#### Parameters

| Parameter | Type                                                              | Description                      |
| :-------- | :---------------------------------------------------------------- | :------------------------------- |
| `key`     | `string` \| [`EventFragment`](/sdk/content/classes/EventFragment) | The name of the event to return. |

#### Returns

[`ContractEvent`](/sdk/content/interfaces/ContractEvent)\<`any`\[]>

The event for the given name.

#### Source

[contract/contract.ts:1274](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1274)

***

### getFunction()

```ts theme={null}
getFunction<T>(key): T
```

Return the function for a given name. This is useful when a contract method name conflicts with a JavaScript name
such as `prototype` or when using a Contract programatically.

#### Type parameters

| Type parameter                                                                                         | Value                                                                               |
| :----------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------- |
| `T` *extends* [`ContractMethod`](/sdk/content/interfaces/ContractMethod)\<`any`\[], `any`, `any`, `T`> | [`ContractMethod`](/sdk/content/interfaces/ContractMethod)\<`any`\[], `any`, `any`> |

#### Parameters

| Parameter | Type                                                                    | Description                         |
| :-------- | :---------------------------------------------------------------------- | :---------------------------------- |
| `key`     | `string` \| [`FunctionFragment`](/sdk/content/classes/FunctionFragment) | The name of the function to return. |

#### Returns

`T`

The function for the given name.

#### Source

[contract/contract.ts:1259](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1259)

***

### listenerCount()

```ts theme={null}
listenerCount(event?): Promise<number>
```

Resolves to the number of listeners of `event` or the total number of listeners if unspecified.

#### Parameters

| Parameter | Type                                                               | Description                       |
| :-------- | :----------------------------------------------------------------- | :-------------------------------- |
| `event`?  | [`ContractEventName`](/sdk/content/type-aliases/ContractEventName) | The event to count listeners for. |

#### Returns

`Promise`\<`number`>

The number of listeners.

#### Implementation of

[`EventEmitterable`](/sdk/content/interfaces/EventEmitterable).[`listenerCount`](/sdk/content/interfaces/EventEmitterable#listenercount)

#### Source

[contract/contract.ts:1389](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1389)

***

### listeners()

```ts theme={null}
listeners(event?): Promise<Listener[]>
```

Resolves to the listeners subscribed to `event` or all listeners if unspecified.

#### Parameters

| Parameter | Type                                                               | Description                     |
| :-------- | :----------------------------------------------------------------- | :------------------------------ |
| `event`?  | [`ContractEventName`](/sdk/content/type-aliases/ContractEventName) | The event to get listeners for. |

#### Returns

`Promise`\<[`Listener`](/sdk/content/type-aliases/Listener)\[]>

The listeners.

#### Implementation of

[`EventEmitterable`](/sdk/content/interfaces/EventEmitterable).[`listeners`](/sdk/content/interfaces/EventEmitterable#listeners)

#### Source

[contract/contract.ts:1413](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1413)

***

### off()

```ts theme={null}
off(event, listener?): Promise<BaseContract>
```

Remove the `listener` from the listeners for `event` or remove all listeners if unspecified.

#### Parameters

| Parameter   | Type                                                               | Description                            |
| :---------- | :----------------------------------------------------------------- | :------------------------------------- |
| `event`     | [`ContractEventName`](/sdk/content/type-aliases/ContractEventName) | The event to remove the listener from. |
| `listener`? | [`Listener`](/sdk/content/type-aliases/Listener)                   | The listener to remove.                |

#### Returns

`Promise`\<[`BaseContract`](/sdk/content/classes/BaseContract)>

This contract instance.

#### Implementation of

[`EventEmitterable`](/sdk/content/interfaces/EventEmitterable).[`off`](/sdk/content/interfaces/EventEmitterable#off)

#### Source

[contract/contract.ts:1438](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1438)

***

### on()

```ts theme={null}
on(event, listener): Promise<BaseContract>
```

Add an event `listener` for the `event`.

#### Parameters

| Parameter  | Type                                                               | Description                                     |
| :--------- | :----------------------------------------------------------------- | :---------------------------------------------- |
| `event`    | [`ContractEventName`](/sdk/content/type-aliases/ContractEventName) | The event to listen for.                        |
| `listener` | [`Listener`](/sdk/content/type-aliases/Listener)                   | The listener to call when the event is emitted. |

#### Returns

`Promise`\<[`BaseContract`](/sdk/content/classes/BaseContract)>

This contract instance.

#### Implementation of

[`EventEmitterable`](/sdk/content/interfaces/EventEmitterable).[`on`](/sdk/content/interfaces/EventEmitterable#on)

#### Source

[contract/contract.ts:1350](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1350)

***

### once()

```ts theme={null}
once(event, listener): Promise<BaseContract>
```

Add an event `listener` for the `event`, but remove the listener after it is fired once.

#### Parameters

| Parameter  | Type                                                               | Description                                     |
| :--------- | :----------------------------------------------------------------- | :---------------------------------------------- |
| `event`    | [`ContractEventName`](/sdk/content/type-aliases/ContractEventName) | The event to listen for.                        |
| `listener` | [`Listener`](/sdk/content/type-aliases/Listener)                   | The listener to call when the event is emitted. |

#### Returns

`Promise`\<[`BaseContract`](/sdk/content/classes/BaseContract)>

#### Implementation of

[`EventEmitterable`](/sdk/content/interfaces/EventEmitterable).[`once`](/sdk/content/interfaces/EventEmitterable#once)

#### Source

[contract/contract.ts:1363](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1363)

***

### queryFilter()

```ts theme={null}
queryFilter(
   event, 
   fromBlock?, 
toBlock?): Promise<(EventLog | Log)[]>
```

Provide historic access to event data for `event` in the range `fromBlock` (default: `0`) to `toBlock` (default:
`"latest"`) inclusive.

#### Parameters

| Parameter    | Type                                                               | Description                       |
| :----------- | :----------------------------------------------------------------- | :-------------------------------- |
| `event`      | [`ContractEventName`](/sdk/content/type-aliases/ContractEventName) | The event to query.               |
| `fromBlock`? | [`BlockTag`](/sdk/content/type-aliases/BlockTag)                   | The block to start querying from. |
| `toBlock`?   | [`BlockTag`](/sdk/content/type-aliases/BlockTag)                   | The block to stop querying at.    |

#### Returns

`Promise`\<([`EventLog`](/sdk/content/classes/EventLog) | [`Log`](/sdk/content/classes/Log))\[]>

An array of event logs.

#### Source

[contract/contract.ts:1300](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1300)

***

### removeAllListeners()

```ts theme={null}
removeAllListeners(event?): Promise<BaseContract>
```

Remove all the listeners for `event` or remove all listeners if unspecified.

#### Parameters

| Parameter | Type                                                               | Description                             |
| :-------- | :----------------------------------------------------------------- | :-------------------------------------- |
| `event`?  | [`ContractEventName`](/sdk/content/type-aliases/ContractEventName) | The event to remove the listeners from. |

#### Returns

`Promise`\<[`BaseContract`](/sdk/content/classes/BaseContract)>

This contract instance.

#### Implementation of

[`EventEmitterable`](/sdk/content/interfaces/EventEmitterable).[`removeAllListeners`](/sdk/content/interfaces/EventEmitterable#removealllisteners)

#### Source

[contract/contract.ts:1465](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1465)

***

### removeListener()

```ts theme={null}
removeListener(event, listener): Promise<BaseContract>
```

Alias for [**off**](/sdk/content/classes/BaseContract#off).

#### Parameters

| Parameter  | Type                                                               | Description                            |
| :--------- | :----------------------------------------------------------------- | :------------------------------------- |
| `event`    | [`ContractEventName`](/sdk/content/type-aliases/ContractEventName) | The event to remove the listener from. |
| `listener` | [`Listener`](/sdk/content/type-aliases/Listener)                   | The listener to remove.                |

#### Returns

`Promise`\<[`BaseContract`](/sdk/content/classes/BaseContract)>

#### Implementation of

[`EventEmitterable`](/sdk/content/interfaces/EventEmitterable).[`removeListener`](/sdk/content/interfaces/EventEmitterable#removelistener)

#### Source

[contract/contract.ts:1500](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1500)

***

### waitForDeployment()

```ts theme={null}
waitForDeployment(): Promise<BaseContract>
```

Resolve to this Contract once the bytecode has been deployed, or resolve immediately if already deployed.

#### Returns

`Promise`\<[`BaseContract`](/sdk/content/classes/BaseContract)>

The contract instance.

#### Throws

If the contract runner does not support .provider.

#### Source

[contract/contract.ts:1205](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1205)

***

### buildClass()

```ts theme={null}
static buildClass<T>(abi): Object
```

Create a new Class for the `abi`.

#### Type parameters

| Type parameter | Value                                                            |
| :------------- | :--------------------------------------------------------------- |
| `T`            | [`ContractInterface`](/sdk/content/interfaces/ContractInterface) |

#### Parameters

| Parameter | Type                                                                                                      | Description                       |
| :-------- | :-------------------------------------------------------------------------------------------------------- | :-------------------------------- |
| `abi`     | [`Interface`](/sdk/content/classes/Interface) \| [`InterfaceAbi`](/sdk/content/type-aliases/InterfaceAbi) | The ABI to create the class from. |

#### Returns

`Object`

The new Class for the ABI.

#### Source

[contract/contract.ts:1510](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1510)

***

### from()

```ts theme={null}
static from<T>(
   target, 
   abi, 
runner?): BaseContract & Omit<T, keyof BaseContract>
```

Create a new BaseContract with a specified Interface.

#### Type parameters

| Type parameter | Value                                                            |
| :------------- | :--------------------------------------------------------------- |
| `T`            | [`ContractInterface`](/sdk/content/interfaces/ContractInterface) |

#### Parameters

| Parameter | Type                                                                                                      | Description               |
| :-------- | :-------------------------------------------------------------------------------------------------------- | :------------------------ |
| `target`  | `string`                                                                                                  | The target to connect to. |
| `abi`     | [`Interface`](/sdk/content/classes/Interface) \| [`InterfaceAbi`](/sdk/content/type-aliases/InterfaceAbi) | The ABI to use.           |
| `runner`? | `null` \| [`ContractRunner`](/sdk/content/interfaces/ContractRunner)                                      | The runner to use.        |

#### Returns

[`BaseContract`](/sdk/content/classes/BaseContract) & `Omit`\<`T`, keyof [`BaseContract`](/sdk/content/classes/BaseContract)>

The new BaseContract.

#### Source

[contract/contract.ts:1529](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1529)


# ConstructorFragment
Source: https://docs.qu.ai/sdk/content/classes/ConstructorFragment



A Fragment which represents a constructor.

## Extends

* [`Fragment`](/sdk/content/classes/Fragment)

## Properties

| Property  | Modifier   | Type                                                      | Description                                         | Inherited from                                       |
| :-------- | :--------- | :-------------------------------------------------------- | :-------------------------------------------------- | :--------------------------------------------------- |
| `gas`     | `readonly` | `null` \| `bigint`                                        | The recommended gas limit for deployment or `null`. | -                                                    |
| `inputs`  | `readonly` | readonly [`ParamType`](/sdk/content/classes/ParamType)\[] | The inputs for the fragment.                        | [`Fragment`](/sdk/content/classes/Fragment).`inputs` |
| `payable` | `readonly` | `boolean`                                                 | Whether the constructor can receive an endowment.   | -                                                    |
| `type`    | `readonly` | [`FragmentType`](/sdk/content/type-aliases/FragmentType)  | The type of the fragment.                           | [`Fragment`](/sdk/content/classes/Fragment).`type`   |

## Methods

### format()

```ts theme={null}
format(format?): string
```

Returns a string representation of this constructor as `format`.

#### Parameters

| Parameter | Type                                                 |
| :-------- | :--------------------------------------------------- |
| `format`? | [`FormatType`](/sdk/content/type-aliases/FormatType) |

#### Returns

`string`

#### Overrides

[`Fragment`](/sdk/content/classes/Fragment).[`format`](/sdk/content/classes/Fragment#format)

#### Source

[abi/fragments.ts:1390](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1390)

***

### from()

```ts theme={null}
static from(obj): ConstructorFragment
```

Returns a new **ConstructorFragment** for `obj`.

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `obj`     | `any` |

#### Returns

[`ConstructorFragment`](/sdk/content/classes/ConstructorFragment)

#### Overrides

[`Fragment`](/sdk/content/classes/Fragment).[`from`](/sdk/content/classes/Fragment#from)

#### Source

[abi/fragments.ts:1421](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1421)

***

### isConstructor()

```ts theme={null}
static isConstructor(value): value is ConstructorFragment
```

Returns true if `value` is a [**ConstructorFragment**](/sdk/content/classes/ConstructorFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is ConstructorFragment`

#### Inherited from

[`Fragment`](/sdk/content/classes/Fragment).[`isConstructor`](/sdk/content/classes/Fragment#isconstructor)

#### Source

[abi/fragments.ts:1122](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1122)

***

### isError()

```ts theme={null}
static isError(value): value is ErrorFragment
```

Returns true if `value` is an [**ErrorFragment**](/sdk/content/classes/ErrorFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is ErrorFragment`

#### Inherited from

[`Fragment`](/sdk/content/classes/Fragment).[`isError`](/sdk/content/classes/Fragment#iserror)

#### Source

[abi/fragments.ts:1129](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1129)

***

### isEvent()

```ts theme={null}
static isEvent(value): value is EventFragment
```

Returns true if `value` is an [**EventFragment**](/sdk/content/classes/EventFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is EventFragment`

#### Inherited from

[`Fragment`](/sdk/content/classes/Fragment).[`isEvent`](/sdk/content/classes/Fragment#isevent)

#### Source

[abi/fragments.ts:1136](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1136)

***

### isFragment()

```ts theme={null}
static isFragment(value): value is ConstructorFragment
```

Returns `true` and provides a type guard if `value` is a **ConstructorFragment**.

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is ConstructorFragment`

#### Source

[abi/fragments.ts:1454](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1454)

***

### isFunction()

```ts theme={null}
static isFunction(value): value is FunctionFragment
```

Returns true if `value` is a [**FunctionFragment**](/sdk/content/classes/FunctionFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is FunctionFragment`

#### Inherited from

[`Fragment`](/sdk/content/classes/Fragment).[`isFunction`](/sdk/content/classes/Fragment#isfunction)

#### Source

[abi/fragments.ts:1143](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1143)

***

### isStruct()

```ts theme={null}
static isStruct(value): value is StructFragment
```

Returns true if `value` is a [**StructFragment**](/sdk/content/classes/StructFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is StructFragment`

#### Inherited from

[`Fragment`](/sdk/content/classes/Fragment).[`isStruct`](/sdk/content/classes/Fragment#isstruct)

#### Source

[abi/fragments.ts:1150](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1150)


# Contract
Source: https://docs.qu.ai/sdk/content/classes/Contract



A [**BaseContract**](/sdk/content/classes/BaseContract) with no type guards on its methods or events.

## Extends

* [`BaseContract`](/sdk/content/classes/BaseContract)\<`this`> & `Omit`\<[`ContractInterface`](/sdk/content/interfaces/ContractInterface), keyof [`BaseContract`](/sdk/content/classes/BaseContract)>

## Properties

| Property    | Modifier   | Type                                                                                     | Description                                                                                                                                                                                                                                                                                                           | Inherited from              |
| :---------- | :--------- | :--------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :-------------------------- |
| `fallback`  | `readonly` | `null` \| [`WrappedFallback`](/sdk/content/interfaces/WrappedFallback)                   | The fallback or receive function if any.                                                                                                                                                                                                                                                                              | `_ContractBase().fallback`  |
| `filters`   | `readonly` | `Record`\<`string`, [`ContractEvent`](/sdk/content/interfaces/ContractEvent)\<`any`\[]>> | All the Events available on this contract.                                                                                                                                                                                                                                                                            | `_ContractBase().filters`   |
| `interface` | `readonly` | [`Interface`](/sdk/content/classes/Interface)                                            | The contract Interface.                                                                                                                                                                                                                                                                                               | `_ContractBase().interface` |
| `runner`    | `readonly` | `null` \| [`ContractRunner`](/sdk/content/interfaces/ContractRunner)                     | The connected runner. This is generally a [**Provider**](../interfaces/Provider) or a<br />[**Signer**](../interfaces/Signer), which dictates what operations are supported.<br /><br />For example, a **Contract** connected to a [**Provider**](../interfaces/Provider) may only execute read-only<br />operations. | `_ContractBase().runner`    |
| `target`    | `readonly` | `string` \| [`Addressable`](/sdk/content/interfaces/Addressable)                         | The target to connect to.<br /><br />This can be an address or any [Addressable](../interfaces/Addressable), such as another contract. To get the<br />resolved address, use the `getAddress` method.                                                                                                                 | `_ContractBase().target`    |

## Methods

### addListener()

```ts theme={null}
addListener(event, listener): Promise<Contract>
```

Alias for [**on**](/sdk/content/classes/BaseContract#on).

#### Parameters

| Parameter  | Type                                                               | Description                                     |
| :--------- | :----------------------------------------------------------------- | :---------------------------------------------- |
| `event`    | [`ContractEventName`](/sdk/content/type-aliases/ContractEventName) | The event to listen for.                        |
| `listener` | [`Listener`](/sdk/content/type-aliases/Listener)                   | The listener to call when the event is emitted. |

#### Returns

`Promise`\<[`Contract`](/sdk/content/classes/Contract)>

#### Inherited from

`_ContractBase().addListener`

#### Source

[contract/contract.ts:1490](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1490)

***

### attach()

```ts theme={null}
attach(target): BaseContract
```

Return a new Contract instance with the same ABI and runner, but a different `target`.

#### Parameters

| Parameter | Type                                                             | Description               |
| :-------- | :--------------------------------------------------------------- | :------------------------ |
| `target`  | `string` \| [`Addressable`](/sdk/content/interfaces/Addressable) | The target to connect to. |

#### Returns

[`BaseContract`](/sdk/content/classes/BaseContract)

The new contract instance.

#### Inherited from

`_ContractBase().attach`

#### Source

[contract/contract.ts:1167](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1167)

***

### connect()

```ts theme={null}
connect(runner): BaseContract
```

Return a new Contract instance with the same target and ABI, but a different `runner`.

#### Parameters

| Parameter | Type                                                                 | Description        |
| :-------- | :------------------------------------------------------------------- | :----------------- |
| `runner`  | `null` \| [`ContractRunner`](/sdk/content/interfaces/ContractRunner) | The runner to use. |

#### Returns

[`BaseContract`](/sdk/content/classes/BaseContract)

The new contract instance.

#### Inherited from

`_ContractBase().connect`

#### Source

[contract/contract.ts:1157](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1157)

***

### deploymentTransaction()

```ts theme={null}
deploymentTransaction(): null | ContractTransactionResponse
```

Return the transaction used to deploy this contract.

This is only available if this instance was returned from a [**ContractFactor**](../classes/ContractFactory).

#### Returns

`null` | [`ContractTransactionResponse`](/sdk/content/classes/ContractTransactionResponse)

The transaction used to deploy this contract or `null`.

#### Inherited from

`_ContractBase().deploymentTransaction`

#### Source

[contract/contract.ts:1248](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1248)

***

### emit()

```ts theme={null}
emit(event, ...args): Promise<boolean>
```

Emit an `event` calling all listeners with `args`.

Resolves to `true` if any listeners were called.

#### Parameters

| Parameter | Type                                                               | Description                             |
| :-------- | :----------------------------------------------------------------- | :-------------------------------------- |
| `event`   | [`ContractEventName`](/sdk/content/type-aliases/ContractEventName) | The event to emit.                      |
| ...`args` | `any`\[]                                                           | The arguments to pass to the listeners. |

#### Returns

`Promise`\<`boolean`>

`true` if any listeners were called.

#### Inherited from

`_ContractBase().emit`

#### Source

[contract/contract.ts:1379](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1379)

***

### getAddress()

```ts theme={null}
getAddress(): Promise<string>
```

Return the resolved address of this Contract.

#### Returns

`Promise`\<`string`>

The resolved address.

#### Inherited from

`_ContractBase().getAddress`

#### Source

[contract/contract.ts:1176](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1176)

***

### getDeployedCode()

```ts theme={null}
getDeployedCode(): Promise<null | string>
```

Return the deployed bytecode or null if no bytecode is found.

#### Returns

`Promise`\<`null` | `string`>

The deployed bytecode or null.

#### Inherited from

`_ContractBase().getDeployedCode`

#### Throws

If the runner does not support .provider.

#### Source

[contract/contract.ts:1186](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1186)

***

### getEvent()

```ts theme={null}
getEvent(key): ContractEvent<any[]>
```

Return the event for a given name. This is useful when a contract event name conflicts with a JavaScript name
such as `prototype` or when using a Contract programatically.

#### Parameters

| Parameter | Type                                                              | Description                      |
| :-------- | :---------------------------------------------------------------- | :------------------------------- |
| `key`     | `string` \| [`EventFragment`](/sdk/content/classes/EventFragment) | The name of the event to return. |

#### Returns

[`ContractEvent`](/sdk/content/interfaces/ContractEvent)\<`any`\[]>

The event for the given name.

#### Inherited from

`_ContractBase().getEvent`

#### Source

[contract/contract.ts:1274](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1274)

***

### getFunction()

```ts theme={null}
getFunction<T>(key): T
```

Return the function for a given name. This is useful when a contract method name conflicts with a JavaScript name
such as `prototype` or when using a Contract programatically.

#### Type parameters

| Type parameter                                                                                         | Value                                                                               |
| :----------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------- |
| `T` *extends* [`ContractMethod`](/sdk/content/interfaces/ContractMethod)\<`any`\[], `any`, `any`, `T`> | [`ContractMethod`](/sdk/content/interfaces/ContractMethod)\<`any`\[], `any`, `any`> |

#### Parameters

| Parameter | Type                                                                    | Description                         |
| :-------- | :---------------------------------------------------------------------- | :---------------------------------- |
| `key`     | `string` \| [`FunctionFragment`](/sdk/content/classes/FunctionFragment) | The name of the function to return. |

#### Returns

`T`

The function for the given name.

#### Inherited from

`_ContractBase().getFunction`

#### Source

[contract/contract.ts:1259](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1259)

***

### listenerCount()

```ts theme={null}
listenerCount(event?): Promise<number>
```

Resolves to the number of listeners of `event` or the total number of listeners if unspecified.

#### Parameters

| Parameter | Type                                                               | Description                       |
| :-------- | :----------------------------------------------------------------- | :-------------------------------- |
| `event`?  | [`ContractEventName`](/sdk/content/type-aliases/ContractEventName) | The event to count listeners for. |

#### Returns

`Promise`\<`number`>

The number of listeners.

#### Inherited from

`_ContractBase().listenerCount`

#### Source

[contract/contract.ts:1389](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1389)

***

### listeners()

```ts theme={null}
listeners(event?): Promise<Listener[]>
```

Resolves to the listeners subscribed to `event` or all listeners if unspecified.

#### Parameters

| Parameter | Type                                                               | Description                     |
| :-------- | :----------------------------------------------------------------- | :------------------------------ |
| `event`?  | [`ContractEventName`](/sdk/content/type-aliases/ContractEventName) | The event to get listeners for. |

#### Returns

`Promise`\<[`Listener`](/sdk/content/type-aliases/Listener)\[]>

The listeners.

#### Inherited from

`_ContractBase().listeners`

#### Source

[contract/contract.ts:1413](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1413)

***

### off()

```ts theme={null}
off(event, listener?): Promise<Contract>
```

Remove the `listener` from the listeners for `event` or remove all listeners if unspecified.

#### Parameters

| Parameter   | Type                                                               | Description                            |
| :---------- | :----------------------------------------------------------------- | :------------------------------------- |
| `event`     | [`ContractEventName`](/sdk/content/type-aliases/ContractEventName) | The event to remove the listener from. |
| `listener`? | [`Listener`](/sdk/content/type-aliases/Listener)                   | The listener to remove.                |

#### Returns

`Promise`\<[`Contract`](/sdk/content/classes/Contract)>

This contract instance.

#### Inherited from

`_ContractBase().off`

#### Source

[contract/contract.ts:1438](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1438)

***

### on()

```ts theme={null}
on(event, listener): Promise<Contract>
```

Add an event `listener` for the `event`.

#### Parameters

| Parameter  | Type                                                               | Description                                     |
| :--------- | :----------------------------------------------------------------- | :---------------------------------------------- |
| `event`    | [`ContractEventName`](/sdk/content/type-aliases/ContractEventName) | The event to listen for.                        |
| `listener` | [`Listener`](/sdk/content/type-aliases/Listener)                   | The listener to call when the event is emitted. |

#### Returns

`Promise`\<[`Contract`](/sdk/content/classes/Contract)>

This contract instance.

#### Inherited from

`_ContractBase().on`

#### Source

[contract/contract.ts:1350](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1350)

***

### once()

```ts theme={null}
once(event, listener): Promise<Contract>
```

Add an event `listener` for the `event`, but remove the listener after it is fired once.

#### Parameters

| Parameter  | Type                                                               | Description                                     |
| :--------- | :----------------------------------------------------------------- | :---------------------------------------------- |
| `event`    | [`ContractEventName`](/sdk/content/type-aliases/ContractEventName) | The event to listen for.                        |
| `listener` | [`Listener`](/sdk/content/type-aliases/Listener)                   | The listener to call when the event is emitted. |

#### Returns

`Promise`\<[`Contract`](/sdk/content/classes/Contract)>

#### Inherited from

`_ContractBase().once`

#### Source

[contract/contract.ts:1363](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1363)

***

### queryFilter()

```ts theme={null}
queryFilter(
   event, 
   fromBlock?, 
toBlock?): Promise<(EventLog | Log)[]>
```

Provide historic access to event data for `event` in the range `fromBlock` (default: `0`) to `toBlock` (default:
`"latest"`) inclusive.

#### Parameters

| Parameter    | Type                                                               | Description                       |
| :----------- | :----------------------------------------------------------------- | :-------------------------------- |
| `event`      | [`ContractEventName`](/sdk/content/type-aliases/ContractEventName) | The event to query.               |
| `fromBlock`? | [`BlockTag`](/sdk/content/type-aliases/BlockTag)                   | The block to start querying from. |
| `toBlock`?   | [`BlockTag`](/sdk/content/type-aliases/BlockTag)                   | The block to stop querying at.    |

#### Returns

`Promise`\<([`EventLog`](/sdk/content/classes/EventLog) | [`Log`](/sdk/content/classes/Log))\[]>

An array of event logs.

#### Inherited from

`_ContractBase().queryFilter`

#### Source

[contract/contract.ts:1300](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1300)

***

### removeAllListeners()

```ts theme={null}
removeAllListeners(event?): Promise<Contract>
```

Remove all the listeners for `event` or remove all listeners if unspecified.

#### Parameters

| Parameter | Type                                                               | Description                             |
| :-------- | :----------------------------------------------------------------- | :-------------------------------------- |
| `event`?  | [`ContractEventName`](/sdk/content/type-aliases/ContractEventName) | The event to remove the listeners from. |

#### Returns

`Promise`\<[`Contract`](/sdk/content/classes/Contract)>

This contract instance.

#### Inherited from

`_ContractBase().removeAllListeners`

#### Source

[contract/contract.ts:1465](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1465)

***

### removeListener()

```ts theme={null}
removeListener(event, listener): Promise<Contract>
```

Alias for [**off**](/sdk/content/classes/BaseContract#off).

#### Parameters

| Parameter  | Type                                                               | Description                            |
| :--------- | :----------------------------------------------------------------- | :------------------------------------- |
| `event`    | [`ContractEventName`](/sdk/content/type-aliases/ContractEventName) | The event to remove the listener from. |
| `listener` | [`Listener`](/sdk/content/type-aliases/Listener)                   | The listener to remove.                |

#### Returns

`Promise`\<[`Contract`](/sdk/content/classes/Contract)>

#### Inherited from

`_ContractBase().removeListener`

#### Source

[contract/contract.ts:1500](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1500)

***

### waitForDeployment()

```ts theme={null}
waitForDeployment(): Promise<Contract>
```

Resolve to this Contract once the bytecode has been deployed, or resolve immediately if already deployed.

#### Returns

`Promise`\<[`Contract`](/sdk/content/classes/Contract)>

The contract instance.

#### Inherited from

`_ContractBase().waitForDeployment`

#### Throws

If the contract runner does not support .provider.

#### Source

[contract/contract.ts:1205](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/contract.ts#L1205)


# ContractEventPayload
Source: https://docs.qu.ai/sdk/content/classes/ContractEventPayload



A **ContractEventPayload** is included as the last parameter to Contract Events when the event is known.

## Extends

* [`ContractUnknownEventPayload`](/sdk/content/classes/ContractUnknownEventPayload)

## Properties

| Property   | Modifier   | Type                                                                                                                                | Description                                         | Overrides                                                                                   | Inherited from                                                                              |
| :--------- | :--------- | :---------------------------------------------------------------------------------------------------------------------------------- | :-------------------------------------------------- | :------------------------------------------------------------------------------------------ | :------------------------------------------------------------------------------------------ |
| `args`     | `readonly` | [`Result`](/sdk/content/classes/Result)                                                                                             | The parsed arguments passed to the event by `emit`. | -                                                                                           | -                                                                                           |
| `emitter`  | `readonly` | [`EventEmitterable`](/sdk/content/interfaces/EventEmitterable)\<[`ContractEventName`](/sdk/content/type-aliases/ContractEventName)> | The **EventEmitterable**.                           | [`ContractUnknownEventPayload`](/sdk/content/classes/ContractUnknownEventPayload).`emitter` | [`ContractUnknownEventPayload`](/sdk/content/classes/ContractUnknownEventPayload).`emitter` |
| `filter`   | `readonly` | [`ContractEventName`](/sdk/content/type-aliases/ContractEventName)                                                                  | The event filter.                                   | [`ContractUnknownEventPayload`](/sdk/content/classes/ContractUnknownEventPayload).`filter`  | [`ContractUnknownEventPayload`](/sdk/content/classes/ContractUnknownEventPayload).`filter`  |
| `fragment` | `readonly` | [`EventFragment`](/sdk/content/classes/EventFragment)                                                                               | The matching event.                                 | -                                                                                           | -                                                                                           |
| `log`      | `readonly` | [`EventLog`](/sdk/content/classes/EventLog)                                                                                         | The log, with parsed properties.                    | [`ContractUnknownEventPayload`](/sdk/content/classes/ContractUnknownEventPayload).`log`     | [`ContractUnknownEventPayload`](/sdk/content/classes/ContractUnknownEventPayload).`log`     |

## Accessors

### eventName

```ts theme={null}
get eventName(): string
```

The event name.

#### Returns

`string`

#### Source

[contract/wrappers.ts:238](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/wrappers.ts#L238)

***

### eventSignature

```ts theme={null}
get eventSignature(): string
```

The event signature.

#### Returns

`string`

#### Source

[contract/wrappers.ts:245](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/wrappers.ts#L245)

## Methods

### getBlock()

```ts theme={null}
getBlock(shard): Promise<Block>
```

Resolves to the block the event occured in.

#### Parameters

| Parameter | Type                                       | Description                      |
| :-------- | :----------------------------------------- | :------------------------------- |
| `shard`   | [`Shard`](/sdk/content/enumerations/Shard) | The shard to get the block from. |

#### Returns

`Promise`\<[`Block`](/sdk/content/classes/Block)>

A promise resolving to the block the event occured in.

#### Inherited from

[`ContractUnknownEventPayload`](/sdk/content/classes/ContractUnknownEventPayload).[`getBlock`](/sdk/content/classes/ContractUnknownEventPayload#getblock)

#### Source

[contract/wrappers.ts:176](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/wrappers.ts#L176)

***

### getTransaction()

```ts theme={null}
getTransaction(): Promise<TransactionResponse>
```

Resolves to the transaction the event occured in.

#### Returns

`Promise`\<[`TransactionResponse`](/sdk/content/type-aliases/TransactionResponse)>

A promise resolving to the transaction the event occured in.

#### Inherited from

[`ContractUnknownEventPayload`](/sdk/content/classes/ContractUnknownEventPayload).[`getTransaction`](/sdk/content/classes/ContractUnknownEventPayload#gettransaction)

#### Source

[contract/wrappers.ts:185](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/wrappers.ts#L185)

***

### getTransactionReceipt()

```ts theme={null}
getTransactionReceipt(): Promise<TransactionReceipt>
```

Resolves to the transaction receipt the event occured in.

#### Returns

`Promise`\<[`TransactionReceipt`](/sdk/content/classes/TransactionReceipt)>

A promise resolving to the transaction receipt the event occured in.

#### Inherited from

[`ContractUnknownEventPayload`](/sdk/content/classes/ContractUnknownEventPayload).[`getTransactionReceipt`](/sdk/content/classes/ContractUnknownEventPayload#gettransactionreceipt)

#### Source

[contract/wrappers.ts:194](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/wrappers.ts#L194)

***

### removeListener()

```ts theme={null}
removeListener(): Promise<void>
```

Unregister the triggered listener for future events.

#### Returns

`Promise`\<`void`>

#### Inherited from

[`ContractUnknownEventPayload`](/sdk/content/classes/ContractUnknownEventPayload).[`removeListener`](/sdk/content/classes/ContractUnknownEventPayload#removelistener)

#### Source

[utils/events.ts:99](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/events.ts#L99)


# ContractFactory
Source: https://docs.qu.ai/sdk/content/classes/ContractFactory



A **ContractFactory** is used to deploy a Contract to the blockchain.

## Type parameters

| Type parameter         | Value                                               |
| :--------------------- | :-------------------------------------------------- |
| `A` *extends* `any`\[] | `any`\[]                                            |
| `I`                    | [`BaseContract`](/sdk/content/classes/BaseContract) |

## Constructors

### new ContractFactory()

```ts theme={null}
new ContractFactory<A, I>(
   abi, 
   bytecode, 
   runner?, 
IPFSHash?): ContractFactory<A, I>
```

Create a new **ContractFactory** with `abi` and `bytecode`, optionally connected to `runner`.

The `bytecode` may be the `bytecode` property within the standard Solidity JSON output.

#### Parameters

| Parameter   | Type                                                                                                      | Default value |
| :---------- | :-------------------------------------------------------------------------------------------------------- | :------------ |
| `abi`       | [`Interface`](/sdk/content/classes/Interface) \| [`InterfaceAbi`](/sdk/content/type-aliases/InterfaceAbi) | `undefined`   |
| `bytecode`  | [`BytesLike`](/sdk/content/type-aliases/BytesLike) \| \{ `"object"`: `string`; }                          | `undefined`   |
| `runner`?   | `null` \| [`ContractRunner`](/sdk/content/interfaces/ContractRunner)                                      | `undefined`   |
| `IPFSHash`? | `null` \| `string`                                                                                        | `null`        |

#### Returns

[`ContractFactory`](/sdk/content/classes/ContractFactory)\<`A`, `I`>

#### Source

[contract/factory.ts:50](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/factory.ts#L50)

## Properties

| Property    | Modifier   | Type                                                                 | Description                                                  |
| :---------- | :--------- | :------------------------------------------------------------------- | :----------------------------------------------------------- |
| `bytecode`  | `readonly` | `string`                                                             | The Contract deployment bytecode. Often called the initcode. |
| `interface` | `readonly` | [`Interface`](/sdk/content/classes/Interface)                        | The Contract Interface.                                      |
| `runner`    | `readonly` | `null` \| [`ContractRunner`](/sdk/content/interfaces/ContractRunner) | The ContractRunner to deploy the Contract as.                |

## Methods

### connect()

```ts theme={null}
connect(runner): ContractFactory<A, I>
```

Return a new **ContractFactory** with the same ABI and bytecode, but connected to `runner`.

#### Parameters

| Parameter | Type                                                                 | Description               |
| :-------- | :------------------------------------------------------------------- | :------------------------ |
| `runner`  | `null` \| [`ContractRunner`](/sdk/content/interfaces/ContractRunner) | The runner to connect to. |

#### Returns

[`ContractFactory`](/sdk/content/classes/ContractFactory)\<`A`, `I`>

A new ContractFactory.

#### Source

[contract/factory.ts:218](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/factory.ts#L218)

***

### deploy()

```ts theme={null}
deploy(...args): Promise<BaseContract & {
  "deploymentTransaction": ContractTransactionResponse;
} & Omit<I, keyof BaseContract>>
```

Resolves to the Contract deployed by passing `args` into the constructor.

This will resovle to the Contract before it has been deployed to the network, so the
[baseContract.waitForDeployment](../classes/BaseContract#waitForDeployment) should be used before sending any
transactions to it.

#### Parameters

| Parameter | Type                       | Description                       |
| :-------- | :------------------------- | :-------------------------------- |
| ...`args` | `ContractMethodArgs`\<`A`> | The arguments to the constructor. |

#### Returns

`Promise`\<[`BaseContract`](/sdk/content/classes/BaseContract) & \{
`"deploymentTransaction"`: [`ContractTransactionResponse`](/sdk/content/classes/ContractTransactionResponse);
} & `Omit`\<`I`, keyof [`BaseContract`](/sdk/content/classes/BaseContract)>>

A promise resolving to the Contract.

#### Source

[contract/factory.ts:126](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/factory.ts#L126)

***

### getDeployTransaction()

```ts theme={null}
getDeployTransaction(...args): Promise<ContractDeployTransaction>
```

Resolves to the transaction to deploy the contract, passing `args` into the constructor.

#### Parameters

| Parameter | Type                       | Description                       |
| :-------- | :------------------------- | :-------------------------------- |
| ...`args` | `ContractMethodArgs`\<`A`> | The arguments to the constructor. |

#### Returns

`Promise`\<[`ContractDeployTransaction`](/sdk/content/interfaces/ContractDeployTransaction)>

A promise resolving to the deployment transaction.

#### Source

[contract/factory.ts:89](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/factory.ts#L89)

***

### fromSolidity()

```ts theme={null}
static fromSolidity<A, I>(output, runner?): ContractFactory<A, I>
```

Create a new **ContractFactory** from the standard Solidity JSON output.

#### Type parameters

| Type parameter         | Value                                                            |
| :--------------------- | :--------------------------------------------------------------- |
| `A` *extends* `any`\[] | `any`\[]                                                         |
| `I`                    | [`ContractInterface`](/sdk/content/interfaces/ContractInterface) |

#### Parameters

| Parameter | Type                                                       | Description               |
| :-------- | :--------------------------------------------------------- | :------------------------ |
| `output`  | `any`                                                      | The Solidity JSON output. |
| `runner`? | [`ContractRunner`](/sdk/content/interfaces/ContractRunner) | The runner to connect to. |

#### Returns

[`ContractFactory`](/sdk/content/classes/ContractFactory)\<`A`, `I`>

A new ContractFactory.

#### Source

[contract/factory.ts:229](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/factory.ts#L229)


# ContractTransactionReceipt
Source: https://docs.qu.ai/sdk/content/classes/ContractTransactionReceipt



A **ContractTransactionReceipt** includes the parsed logs from a [**TransactionReceipt**](/sdk/content/classes/TransactionReceipt).

## Extends

* [`TransactionReceipt`](/sdk/content/classes/TransactionReceipt)

## Properties

| Property            | Modifier   | Type                                           | Description                                                                                                                                                                                                                                                                    | Inherited from                                                                      |
| :------------------ | :--------- | :--------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------- |
| `#logs`             | `private`  | readonly [`Log`](/sdk/content/classes/Log)\[]  | The root hash of this transaction.<br /><br />This is no present and was only included in pre-byzantium blocks, but could be used to validate certain parts of<br />the receipt.                                                                                               | [`TransactionReceipt`](/sdk/content/classes/TransactionReceipt).`#logs`             |
| `blockHash`         | `readonly` | `string`                                       | The block hash of the [**Block**](/sdk/content/classes/Block) this transaction was included in.                                                                                                                                                                                | [`TransactionReceipt`](/sdk/content/classes/TransactionReceipt).`blockHash`         |
| `blockNumber`       | `readonly` | `number`                                       | The block number of the [**Block**](/sdk/content/classes/Block) this transaction was included in.                                                                                                                                                                              | [`TransactionReceipt`](/sdk/content/classes/TransactionReceipt).`blockNumber`       |
| `contractAddress`   | `readonly` | `null` \| `string`                             | The address of the contract if the transaction was directly responsible for deploying one.<br /><br />This is non-null **only** if the `to` is empty and the `data` was successfully executed as initcode.                                                                     | [`TransactionReceipt`](/sdk/content/classes/TransactionReceipt).`contractAddress`   |
| `cumulativeGasUsed` | `readonly` | `bigint`                                       | The amount of gas used by all transactions within the block for this and all transactions with a lower `index`.<br /><br />This is generally not useful for developers but can be used to validate certain aspects of execution.                                               | [`TransactionReceipt`](/sdk/content/classes/TransactionReceipt).`cumulativeGasUsed` |
| `from`              | `readonly` | `string`                                       | The sender of the transaction.                                                                                                                                                                                                                                                 | [`TransactionReceipt`](/sdk/content/classes/TransactionReceipt).`from`              |
| `gasPrice`          | `readonly` | `bigint`                                       | The actual gas price used during execution.<br /><br />Due to the complexity of [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559) this value can only be caluclated<br />after the transaction has been mined, snce the base fee is protocol-enforced.                       | [`TransactionReceipt`](/sdk/content/classes/TransactionReceipt).`gasPrice`          |
| `gasUsed`           | `readonly` | `bigint`                                       | The actual amount of gas used by this transaction.<br /><br />When creating a transaction, the amount of gas that will be used can only be approximated, but the sender must<br />pay the gas fee for the entire gas limit. After the transaction, the difference is refunded. | [`TransactionReceipt`](/sdk/content/classes/TransactionReceipt).`gasUsed`           |
| `hash`              | `readonly` | `string`                                       | The transaction hash.                                                                                                                                                                                                                                                          | [`TransactionReceipt`](/sdk/content/classes/TransactionReceipt).`hash`              |
| `index`             | `readonly` | `number`                                       | The index of this transaction within the block transactions.                                                                                                                                                                                                                   | [`TransactionReceipt`](/sdk/content/classes/TransactionReceipt).`index`             |
| `logsBloom`         | `readonly` | `string`                                       | The bloom filter bytes that represent all logs that occurred within this transaction. This is generally not<br />useful for most developers, but can be used to validate the included logs.                                                                                    | [`TransactionReceipt`](/sdk/content/classes/TransactionReceipt).`logsBloom`         |
| `provider`          | `readonly` | [`Provider`](/sdk/content/interfaces/Provider) | The provider connected to the log used to fetch additional details if necessary.                                                                                                                                                                                               | [`TransactionReceipt`](/sdk/content/classes/TransactionReceipt).`provider`          |
| `status`            | `readonly` | `null` \| `number`                             | The status of this transaction, indicating success (i.e. `1`) or a revert (i.e. `0`).<br /><br />This is available in post-byzantium blocks, but some backends may backfill this value.                                                                                        | [`TransactionReceipt`](/sdk/content/classes/TransactionReceipt).`status`            |
| `to`                | `readonly` | `null` \| `string`                             | The address the transaction was sent to.                                                                                                                                                                                                                                       | [`TransactionReceipt`](/sdk/content/classes/TransactionReceipt).`to`                |
| `type`              | `readonly` | `number`                                       | The [EIP-2718](https://eips.ethereum.org/EIPS/eip-2718) transaction type.                                                                                                                                                                                                      | [`TransactionReceipt`](/sdk/content/classes/TransactionReceipt).`type`              |

## Accessors

### fee

```ts theme={null}
get fee(): bigint
```

The total fee for this transaction, in wei.

#### Returns

`bigint`

#### Source

[providers/provider.ts:1375](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1375)

***

### logs

```ts theme={null}
get logs(): (EventLog | Log)[]
```

The parsed logs for any [**Log**](/sdk/content/classes/Log) which has a matching event in the Contract ABI.

#### Returns

([`EventLog`](/sdk/content/classes/EventLog) | [`Log`](/sdk/content/classes/Log))\[]

#### Source

[contract/wrappers.ts:98](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/wrappers.ts#L98)

## Methods

### confirmations()

```ts theme={null}
confirmations(): Promise<number>
```

Resolves to the number of confirmations this transaction has.

#### Returns

`Promise`\<`number`>

A promise resolving to the number of confirmations.

#### Inherited from

[`TransactionReceipt`](/sdk/content/classes/TransactionReceipt).[`confirmations`](/sdk/content/classes/TransactionReceipt#confirmations)

#### Throws

If the block is not found.

#### Source

[providers/provider.ts:1426](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1426)

***

### getBlock()

```ts theme={null}
getBlock(shard): Promise<Block>
```

Resolves to the block this transaction occurred in.

#### Parameters

| Parameter | Type                                       | Description                        |
| :-------- | :----------------------------------------- | :--------------------------------- |
| `shard`   | [`Shard`](/sdk/content/enumerations/Shard) | The shard to fetch the block from. |

#### Returns

`Promise`\<[`Block`](/sdk/content/classes/Block)>

A promise resolving to the block.

#### Inherited from

[`TransactionReceipt`](/sdk/content/classes/TransactionReceipt).[`getBlock`](/sdk/content/classes/TransactionReceipt#getblock)

#### Throws

If the block is not found.

#### Source

[providers/provider.ts:1386](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1386)

***

### getResult()

```ts theme={null}
getResult(): Promise<string>
```

Resolves to the return value of the execution of this transaction.

Support for this feature is limited, as it requires an archive node with the `debug_` or `trace_` API enabled.

#### Returns

`Promise`\<`string`>

A promise resolving to the return value of the transaction.

#### Inherited from

[`TransactionReceipt`](/sdk/content/classes/TransactionReceipt).[`getResult`](/sdk/content/classes/TransactionReceipt#getresult)

#### Throws

If the transaction is not found.

#### Source

[providers/provider.ts:1416](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1416)

***

### getTransaction()

```ts theme={null}
getTransaction(): Promise<TransactionResponse | ExternalTransactionResponse>
```

Resolves to the transaction this transaction occurred in.

#### Returns

`Promise`\<[`TransactionResponse`](/sdk/content/type-aliases/TransactionResponse) | `ExternalTransactionResponse`>

A promise resolving to the transaction.

#### Inherited from

[`TransactionReceipt`](/sdk/content/classes/TransactionReceipt).[`getTransaction`](/sdk/content/classes/TransactionReceipt#gettransaction)

#### Throws

If the transaction is not found.

#### Source

[providers/provider.ts:1400](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1400)

***

### toJSON()

```ts theme={null}
toJSON(): any
```

Returns a JSON-compatible representation.

#### Returns

`any`

#### Inherited from

[`TransactionReceipt`](/sdk/content/classes/TransactionReceipt).[`toJSON`](/sdk/content/classes/TransactionReceipt#tojson)

#### Source

[providers/provider.ts:1319](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1319)


# ContractTransactionResponse
Source: https://docs.qu.ai/sdk/content/classes/ContractTransactionResponse



A **ContractTransactionResponse** will return a [**ContractTransactionReceipt**](/sdk/content/classes/ContractTransactionReceipt)
when waited on.

## Extends

* [`QuaiTransactionResponse`](/sdk/content/classes/QuaiTransactionResponse)

## Properties

| Property      | Modifier   | Type                                                           | Description                                                                                                                                                                                                                                                                                                                                                                            | Inherited from                                                                          |
| :------------ | :--------- | :------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------- |
| `accessList`  | `readonly` | `null` \| [`AccessList`](/sdk/content/type-aliases/AccessList) | The [EIP-2930](https://eips.ethereum.org/EIPS/eip-2930) access list for transaction types that support it,<br />otherwise `null`.                                                                                                                                                                                                                                                      | [`QuaiTransactionResponse`](/sdk/content/classes/QuaiTransactionResponse).`accessList`  |
| `blockHash`   | `readonly` | `null` \| `string`                                             | The blockHash of the block that this transaction was included in.<br /><br />This is `null` for pending transactions.                                                                                                                                                                                                                                                                  | [`QuaiTransactionResponse`](/sdk/content/classes/QuaiTransactionResponse).`blockHash`   |
| `blockNumber` | `readonly` | `null` \| `number`                                             | The block number of the block that this transaction was included in.<br /><br />This is `null` for pending transactions.                                                                                                                                                                                                                                                               | [`QuaiTransactionResponse`](/sdk/content/classes/QuaiTransactionResponse).`blockNumber` |
| `chainId`     | `readonly` | `bigint`                                                       | The chain ID.                                                                                                                                                                                                                                                                                                                                                                          | [`QuaiTransactionResponse`](/sdk/content/classes/QuaiTransactionResponse).`chainId`     |
| `data`        | `readonly` | `string`                                                       | The data.                                                                                                                                                                                                                                                                                                                                                                              | [`QuaiTransactionResponse`](/sdk/content/classes/QuaiTransactionResponse).`data`        |
| `from`        | `readonly` | `string`                                                       | The sender of this transaction. It is implicitly computed from the transaction pre-image hash (as the digest) and<br />the [**signature** ](/sdk/content/classes/QuaiTransactionResponse) using ecrecover.                                                                                                                                                                             | [`QuaiTransactionResponse`](/sdk/content/classes/QuaiTransactionResponse).`from`        |
| `gasLimit`    | `readonly` | `bigint`                                                       | The maximum units of gas this transaction can consume. If execution exceeds this, the entries transaction is<br />reverted and the sender is charged for the full amount, despite not state changes being made.                                                                                                                                                                        | [`QuaiTransactionResponse`](/sdk/content/classes/QuaiTransactionResponse).`gasLimit`    |
| `gasPrice`    | `readonly` | `null` \| `bigint`                                             | The maximum fee (per unit of gas) to allow this transaction to charge the sender.                                                                                                                                                                                                                                                                                                      | [`QuaiTransactionResponse`](/sdk/content/classes/QuaiTransactionResponse).`gasPrice`    |
| `hash`        | `readonly` | `string`                                                       | The transaction hash.                                                                                                                                                                                                                                                                                                                                                                  | [`QuaiTransactionResponse`](/sdk/content/classes/QuaiTransactionResponse).`hash`        |
| `index`       | `readonly` | `bigint`                                                       | The index within the block that this transaction resides at.                                                                                                                                                                                                                                                                                                                           | [`QuaiTransactionResponse`](/sdk/content/classes/QuaiTransactionResponse).`index`       |
| `nonce`       | `readonly` | `number`                                                       | The nonce, which is used to prevent replay attacks and offer a method to ensure transactions from a given sender<br />are explicitly ordered.<br /><br />When sending a transaction, this must be equal to the number of transactions ever sent by<br />[**from** ](/sdk/content/classes/QuaiTransactionResponse).                                                                     | [`QuaiTransactionResponse`](/sdk/content/classes/QuaiTransactionResponse).`nonce`       |
| `provider`    | `readonly` | [`Provider`](/sdk/content/interfaces/Provider)                 | The provider this is connected to, which will influence how its methods will resolve its async inspection<br />methods.                                                                                                                                                                                                                                                                | [`QuaiTransactionResponse`](/sdk/content/classes/QuaiTransactionResponse).`provider`    |
| `signature`   | `readonly` | [`Signature`](/sdk/content/classes/Signature)                  | The signature.                                                                                                                                                                                                                                                                                                                                                                         | [`QuaiTransactionResponse`](/sdk/content/classes/QuaiTransactionResponse).`signature`   |
| `to`          | `readonly` | `null` \| `string`                                             | The receiver of this transaction.<br /><br />If `null`, then the transaction is an initcode transaction. This means the result of executing the<br />[**data** ](/sdk/content/classes/QuaiTransactionResponse) will be deployed as a new contract on chain (assuming it does not<br />revert) and the address may be computed using [getCreateAddress](../functions/getCreateAddress). | [`QuaiTransactionResponse`](/sdk/content/classes/QuaiTransactionResponse).`to`          |
| `type`        | `readonly` | `number`                                                       | The [EIP-2718](https://eips.ethereum.org/EIPS/eip-2718) transaction envelope type. This is `0` for legacy<br />transactions types.                                                                                                                                                                                                                                                     | [`QuaiTransactionResponse`](/sdk/content/classes/QuaiTransactionResponse).`type`        |
| `value`       | `readonly` | `bigint`                                                       | The value, in wei. Use [formatEther](../functions/formatEther) to format this value as ether.                                                                                                                                                                                                                                                                                          | [`QuaiTransactionResponse`](/sdk/content/classes/QuaiTransactionResponse).`value`       |

## Methods

### confirmations()

```ts theme={null}
confirmations(): Promise<number>
```

Resolve to the number of confirmations this transaction has.

#### Returns

`Promise`\<`number`>

A promise resolving to the number of confirmations.

#### Inherited from

[`QuaiTransactionResponse`](/sdk/content/classes/QuaiTransactionResponse).[`confirmations`](/sdk/content/classes/QuaiTransactionResponse#confirmations)

#### Throws

If the block is not found.

#### Source

[providers/provider.ts:1921](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1921)

***

### getBlock()

```ts theme={null}
getBlock(shard): Promise<null | Block>
```

Resolves to the Block that this transaction was included in.

This will return null if the transaction has not been included yet.

#### Parameters

| Parameter | Type                                       | Description                        |
| :-------- | :----------------------------------------- | :--------------------------------- |
| `shard`   | [`Shard`](/sdk/content/enumerations/Shard) | The shard to fetch the block from. |

#### Returns

`Promise`\<`null` | [`Block`](/sdk/content/classes/Block)>

A promise resolving to the block.

#### Inherited from

[`QuaiTransactionResponse`](/sdk/content/classes/QuaiTransactionResponse).[`getBlock`](/sdk/content/classes/QuaiTransactionResponse#getblock)

#### Source

[providers/provider.ts:1882](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1882)

***

### getTransaction()

```ts theme={null}
getTransaction(): Promise<null | QuaiTransactionResponse>
```

Resolves to this transaction being re-requested from the provider. This can be used if you have an unmined
transaction and wish to get an up-to-date populated instance.

#### Returns

`Promise`\<`null` | [`QuaiTransactionResponse`](/sdk/content/classes/QuaiTransactionResponse)>

A promise resolving to the transaction, or null if not found.

#### Inherited from

[`QuaiTransactionResponse`](/sdk/content/classes/QuaiTransactionResponse).[`getTransaction`](/sdk/content/classes/QuaiTransactionResponse#gettransaction)

#### Source

[providers/provider.ts:1906](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1906)

***

### isMined()

```ts theme={null}
isMined(): this is QuaiMinedTransactionResponse
```

Returns `true` if this transaction has been included.

This is effective only as of the time the TransactionResponse was instantiated. To get up-to-date information,
use [**getTransaction**](/sdk/content/classes/QuaiTransactionResponse#gettransaction).

This provides a Type Guard that this transaction will have non-null property values for properties that are null
for unmined transactions.

#### Returns

`this is QuaiMinedTransactionResponse`

True if the transaction has been mined.

#### Inherited from

[`QuaiTransactionResponse`](/sdk/content/classes/QuaiTransactionResponse).[`isMined`](/sdk/content/classes/QuaiTransactionResponse#ismined)

#### Throws

If the transaction was replaced, repriced, or cancelled.

#### Source

[providers/provider.ts:2179](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2179)

***

### removedEvent()

```ts theme={null}
removedEvent(): OrphanFilter
```

Returns a filter which can be used to listen for orphan events that evict this transaction.

#### Returns

[`OrphanFilter`](/sdk/content/type-aliases/OrphanFilter)

The orphan filter.

#### Inherited from

[`QuaiTransactionResponse`](/sdk/content/classes/QuaiTransactionResponse).[`removedEvent`](/sdk/content/classes/QuaiTransactionResponse#removedevent)

#### Source

[providers/provider.ts:2188](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2188)

***

### reorderedEvent()

```ts theme={null}
reorderedEvent(other?): OrphanFilter
```

Returns a filter which can be used to listen for orphan events that re-order this event against `other`.

#### Parameters

| Parameter | Type                                                                   | Description                               |
| :-------- | :--------------------------------------------------------------------- | :---------------------------------------- |
| `other`?  | [`TransactionResponse`](/sdk/content/type-aliases/TransactionResponse) | The other transaction to compare against. |

#### Returns

[`OrphanFilter`](/sdk/content/type-aliases/OrphanFilter)

The orphan filter.

#### Inherited from

[`QuaiTransactionResponse`](/sdk/content/classes/QuaiTransactionResponse).[`reorderedEvent`](/sdk/content/classes/QuaiTransactionResponse#reorderedevent)

#### Source

[providers/provider.ts:2201](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2201)

***

### replaceableTransaction()

```ts theme={null}
replaceableTransaction(startBlock): QuaiTransactionResponse
```

Returns a new TransactionResponse instance which has the ability to detect (and throw an error) if the
transaction is replaced, which will begin scanning at `startBlock`.

This should generally not be used by developers and is intended primarily for internal use. Setting an incorrect
`startBlock` can have devastating performance consequences if used incorrectly.

#### Parameters

| Parameter    | Type     | Description                                          |
| :----------- | :------- | :--------------------------------------------------- |
| `startBlock` | `number` | The block number to start scanning for replacements. |

#### Returns

[`QuaiTransactionResponse`](/sdk/content/classes/QuaiTransactionResponse)

The replaceable transaction.

#### Inherited from

[`QuaiTransactionResponse`](/sdk/content/classes/QuaiTransactionResponse).[`replaceableTransaction`](/sdk/content/classes/QuaiTransactionResponse#replaceabletransaction)

#### Source

[providers/provider.ts:2223](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2223)

***

### toJSON()

```ts theme={null}
toJSON(): any
```

Returns a JSON-compatible representation of this transaction.

#### Returns

`any`

#### Inherited from

[`QuaiTransactionResponse`](/sdk/content/classes/QuaiTransactionResponse).[`toJSON`](/sdk/content/classes/QuaiTransactionResponse#tojson)

#### Source

[providers/provider.ts:1850](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1850)

***

### wait()

```ts theme={null}
wait(confirms?): Promise<null | ContractTransactionReceipt>
```

Resolves once this transaction has been mined and has `confirms` blocks including it (default: `1`) with an
optional `timeout`.

This can resolve to `null` only if `confirms` is `0` and the transaction has not been mined, otherwise this will
wait until enough confirmations have completed.

#### Parameters

| Parameter   | Type     | Description                              |
| :---------- | :------- | :--------------------------------------- |
| `confirms`? | `number` | The number of confirmations to wait for. |

#### Returns

`Promise`\<`null` | [`ContractTransactionReceipt`](/sdk/content/classes/ContractTransactionReceipt)>

The transaction receipt, or `null` if `confirms` is `0`.

#### Overrides

[`QuaiTransactionResponse`](/sdk/content/classes/QuaiTransactionResponse).[`wait`](/sdk/content/classes/QuaiTransactionResponse#wait)

#### Source

[contract/wrappers.ts:141](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/wrappers.ts#L141)


# ContractUnknownEventPayload
Source: https://docs.qu.ai/sdk/content/classes/ContractUnknownEventPayload



A **ContractUnknownEventPayload** is included as the last parameter to Contract Events when the event does not match
any events in the ABI.

## Extends

* [`EventPayload`](/sdk/content/classes/EventPayload)\<[`ContractEventName`](/sdk/content/type-aliases/ContractEventName)>

## Extended by

* [`ContractEventPayload`](/sdk/content/classes/ContractEventPayload)

## Properties

| Property  | Modifier   | Type                                                                                                                                | Description                      | Inherited from                                                |
| :-------- | :--------- | :---------------------------------------------------------------------------------------------------------------------------------- | :------------------------------- | :------------------------------------------------------------ |
| `emitter` | `readonly` | [`EventEmitterable`](/sdk/content/interfaces/EventEmitterable)\<[`ContractEventName`](/sdk/content/type-aliases/ContractEventName)> | The **EventEmitterable**.        | [`EventPayload`](/sdk/content/classes/EventPayload).`emitter` |
| `filter`  | `readonly` | [`ContractEventName`](/sdk/content/type-aliases/ContractEventName)                                                                  | The event filter.                | [`EventPayload`](/sdk/content/classes/EventPayload).`filter`  |
| `log`     | `readonly` | [`Log`](/sdk/content/classes/Log)                                                                                                   | The log with no matching events. | -                                                             |

## Methods

### getBlock()

```ts theme={null}
getBlock(shard): Promise<Block>
```

Resolves to the block the event occured in.

#### Parameters

| Parameter | Type                                       | Description                      |
| :-------- | :----------------------------------------- | :------------------------------- |
| `shard`   | [`Shard`](/sdk/content/enumerations/Shard) | The shard to get the block from. |

#### Returns

`Promise`\<[`Block`](/sdk/content/classes/Block)>

A promise resolving to the block the event occured in.

#### Source

[contract/wrappers.ts:176](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/wrappers.ts#L176)

***

### getTransaction()

```ts theme={null}
getTransaction(): Promise<TransactionResponse>
```

Resolves to the transaction the event occured in.

#### Returns

`Promise`\<[`TransactionResponse`](/sdk/content/type-aliases/TransactionResponse)>

A promise resolving to the transaction the event occured in.

#### Source

[contract/wrappers.ts:185](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/wrappers.ts#L185)

***

### getTransactionReceipt()

```ts theme={null}
getTransactionReceipt(): Promise<TransactionReceipt>
```

Resolves to the transaction receipt the event occured in.

#### Returns

`Promise`\<[`TransactionReceipt`](/sdk/content/classes/TransactionReceipt)>

A promise resolving to the transaction receipt the event occured in.

#### Source

[contract/wrappers.ts:194](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/wrappers.ts#L194)

***

### removeListener()

```ts theme={null}
removeListener(): Promise<void>
```

Unregister the triggered listener for future events.

#### Returns

`Promise`\<`void`>

#### Inherited from

[`EventPayload`](/sdk/content/classes/EventPayload).[`removeListener`](/sdk/content/classes/EventPayload#removelistener)

#### Source

[utils/events.ts:99](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/events.ts#L99)


# ErrorDescription
Source: https://docs.qu.ai/sdk/content/classes/ErrorDescription



When using the [**Interface.parseError**](/sdk/content/classes/Interface#parseerror) to automatically match an error for a call
result for parsing, an **ErrorDescription** is returned.

## Properties

| Property    | Modifier   | Type                                                  | Description                                      |
| :---------- | :--------- | :---------------------------------------------------- | :----------------------------------------------- |
| `args`      | `readonly` | [`Result`](/sdk/content/classes/Result)               | The arguments passed to the Error with `revert`. |
| `fragment`  | `readonly` | [`ErrorFragment`](/sdk/content/classes/ErrorFragment) | The matching fragment.                           |
| `name`      | `readonly` | `string`                                              | The name of the Error.                           |
| `selector`  | `readonly` | `string`                                              | The selector for the Error.                      |
| `signature` | `readonly` | `string`                                              | The full Error signature.                        |


# ErrorFragment
Source: https://docs.qu.ai/sdk/content/classes/ErrorFragment



A Fragment which represents a *Custom Error*.

## Extends

* [`NamedFragment`](/sdk/content/classes/NamedFragment)

## Properties

| Property | Modifier   | Type                                                      | Description                  | Inherited from                                                 |
| :------- | :--------- | :-------------------------------------------------------- | :--------------------------- | :------------------------------------------------------------- |
| `inputs` | `readonly` | readonly [`ParamType`](/sdk/content/classes/ParamType)\[] | The inputs for the fragment. | [`NamedFragment`](/sdk/content/classes/NamedFragment).`inputs` |
| `name`   | `readonly` | `string`                                                  | The name of the fragment.    | [`NamedFragment`](/sdk/content/classes/NamedFragment).`name`   |
| `type`   | `readonly` | [`FragmentType`](/sdk/content/type-aliases/FragmentType)  | The type of the fragment.    | [`NamedFragment`](/sdk/content/classes/NamedFragment).`type`   |

## Accessors

### selector

```ts theme={null}
get selector(): string
```

The Custom Error selector.

#### Returns

`string`

#### Source

[abi/fragments.ts:1198](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1198)

## Methods

### format()

```ts theme={null}
format(format?): string
```

Returns a string representation of this fragment as `format`.

#### Parameters

| Parameter | Type                                                 |
| :-------- | :--------------------------------------------------- |
| `format`? | [`FormatType`](/sdk/content/type-aliases/FormatType) |

#### Returns

`string`

#### Overrides

[`NamedFragment`](/sdk/content/classes/NamedFragment).[`format`](/sdk/content/classes/NamedFragment#format)

#### Source

[abi/fragments.ts:1205](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1205)

***

### from()

```ts theme={null}
static from(obj): ErrorFragment
```

Returns a new **ErrorFragment** for `obj`.

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `obj`     | `any` |

#### Returns

[`ErrorFragment`](/sdk/content/classes/ErrorFragment)

#### Overrides

[`NamedFragment`](/sdk/content/classes/NamedFragment).[`from`](/sdk/content/classes/NamedFragment#from)

#### Source

[abi/fragments.ts:1228](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1228)

***

### isConstructor()

```ts theme={null}
static isConstructor(value): value is ConstructorFragment
```

Returns true if `value` is a [**ConstructorFragment**](/sdk/content/classes/ConstructorFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is ConstructorFragment`

#### Inherited from

[`NamedFragment`](/sdk/content/classes/NamedFragment).[`isConstructor`](/sdk/content/classes/NamedFragment#isconstructor)

#### Source

[abi/fragments.ts:1122](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1122)

***

### isError()

```ts theme={null}
static isError(value): value is ErrorFragment
```

Returns true if `value` is an [**ErrorFragment**](/sdk/content/classes/ErrorFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is ErrorFragment`

#### Inherited from

[`NamedFragment`](/sdk/content/classes/NamedFragment).[`isError`](/sdk/content/classes/NamedFragment#iserror)

#### Source

[abi/fragments.ts:1129](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1129)

***

### isEvent()

```ts theme={null}
static isEvent(value): value is EventFragment
```

Returns true if `value` is an [**EventFragment**](/sdk/content/classes/EventFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is EventFragment`

#### Inherited from

[`NamedFragment`](/sdk/content/classes/NamedFragment).[`isEvent`](/sdk/content/classes/NamedFragment#isevent)

#### Source

[abi/fragments.ts:1136](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1136)

***

### isFragment()

```ts theme={null}
static isFragment(value): value is ErrorFragment
```

Returns `true` and provides a type guard if `value` is an **ErrorFragment**.

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is ErrorFragment`

#### Source

[abi/fragments.ts:1249](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1249)

***

### isFunction()

```ts theme={null}
static isFunction(value): value is FunctionFragment
```

Returns true if `value` is a [**FunctionFragment**](/sdk/content/classes/FunctionFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is FunctionFragment`

#### Inherited from

[`NamedFragment`](/sdk/content/classes/NamedFragment).[`isFunction`](/sdk/content/classes/NamedFragment#isfunction)

#### Source

[abi/fragments.ts:1143](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1143)

***

### isStruct()

```ts theme={null}
static isStruct(value): value is StructFragment
```

Returns true if `value` is a [**StructFragment**](/sdk/content/classes/StructFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is StructFragment`

#### Inherited from

[`NamedFragment`](/sdk/content/classes/NamedFragment).[`isStruct`](/sdk/content/classes/NamedFragment#isstruct)

#### Source

[abi/fragments.ts:1150](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1150)


# EventFragment
Source: https://docs.qu.ai/sdk/content/classes/EventFragment



A Fragment which represents an Event.

## Extends

* [`NamedFragment`](/sdk/content/classes/NamedFragment)

## Properties

| Property    | Modifier   | Type                                                      | Description                      | Inherited from                                                 |
| :---------- | :--------- | :-------------------------------------------------------- | :------------------------------- | :------------------------------------------------------------- |
| `anonymous` | `readonly` | `boolean`                                                 | Whether this event is anonymous. | -                                                              |
| `inputs`    | `readonly` | readonly [`ParamType`](/sdk/content/classes/ParamType)\[] | The inputs for the fragment.     | [`NamedFragment`](/sdk/content/classes/NamedFragment).`inputs` |
| `name`      | `readonly` | `string`                                                  | The name of the fragment.        | [`NamedFragment`](/sdk/content/classes/NamedFragment).`name`   |
| `type`      | `readonly` | [`FragmentType`](/sdk/content/type-aliases/FragmentType)  | The type of the fragment.        | [`NamedFragment`](/sdk/content/classes/NamedFragment).`type`   |

## Accessors

### topicHash

```ts theme={null}
get topicHash(): string
```

The Event topic hash.

#### Returns

`string`

#### Source

[abi/fragments.ts:1277](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1277)

## Methods

### format()

```ts theme={null}
format(format?): string
```

Returns a string representation of this event as `format`.

#### Parameters

| Parameter | Type                                                 |
| :-------- | :--------------------------------------------------- |
| `format`? | [`FormatType`](/sdk/content/type-aliases/FormatType) |

#### Returns

`string`

#### Overrides

[`NamedFragment`](/sdk/content/classes/NamedFragment).[`format`](/sdk/content/classes/NamedFragment#format)

#### Source

[abi/fragments.ts:1284](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1284)

***

### from()

```ts theme={null}
static from(obj): EventFragment
```

Returns a new **EventFragment** for `obj`.

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `obj`     | `any` |

#### Returns

[`EventFragment`](/sdk/content/classes/EventFragment)

#### Overrides

[`NamedFragment`](/sdk/content/classes/NamedFragment).[`from`](/sdk/content/classes/NamedFragment#from)

#### Source

[abi/fragments.ts:1320](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1320)

***

### getTopicHash()

```ts theme={null}
static getTopicHash(name, params?): string
```

Return the topic hash for an event with `name` and `params`.

#### Parameters

| Parameter | Type     |
| :-------- | :------- |
| `name`    | `string` |
| `params`? | `any`\[] |

#### Returns

`string`

#### Source

[abi/fragments.ts:1311](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1311)

***

### isConstructor()

```ts theme={null}
static isConstructor(value): value is ConstructorFragment
```

Returns true if `value` is a [**ConstructorFragment**](/sdk/content/classes/ConstructorFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is ConstructorFragment`

#### Inherited from

[`NamedFragment`](/sdk/content/classes/NamedFragment).[`isConstructor`](/sdk/content/classes/NamedFragment#isconstructor)

#### Source

[abi/fragments.ts:1122](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1122)

***

### isError()

```ts theme={null}
static isError(value): value is ErrorFragment
```

Returns true if `value` is an [**ErrorFragment**](/sdk/content/classes/ErrorFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is ErrorFragment`

#### Inherited from

[`NamedFragment`](/sdk/content/classes/NamedFragment).[`isError`](/sdk/content/classes/NamedFragment#iserror)

#### Source

[abi/fragments.ts:1129](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1129)

***

### isEvent()

```ts theme={null}
static isEvent(value): value is EventFragment
```

Returns true if `value` is an [**EventFragment**](/sdk/content/classes/EventFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is EventFragment`

#### Inherited from

[`NamedFragment`](/sdk/content/classes/NamedFragment).[`isEvent`](/sdk/content/classes/NamedFragment#isevent)

#### Source

[abi/fragments.ts:1136](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1136)

***

### isFragment()

```ts theme={null}
static isFragment(value): value is EventFragment
```

Returns `true` and provides a type guard if `value` is an **EventFragment**.

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is EventFragment`

#### Source

[abi/fragments.ts:1351](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1351)

***

### isFunction()

```ts theme={null}
static isFunction(value): value is FunctionFragment
```

Returns true if `value` is a [**FunctionFragment**](/sdk/content/classes/FunctionFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is FunctionFragment`

#### Inherited from

[`NamedFragment`](/sdk/content/classes/NamedFragment).[`isFunction`](/sdk/content/classes/NamedFragment#isfunction)

#### Source

[abi/fragments.ts:1143](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1143)

***

### isStruct()

```ts theme={null}
static isStruct(value): value is StructFragment
```

Returns true if `value` is a [**StructFragment**](/sdk/content/classes/StructFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is StructFragment`

#### Inherited from

[`NamedFragment`](/sdk/content/classes/NamedFragment).[`isStruct`](/sdk/content/classes/NamedFragment#isstruct)

#### Source

[abi/fragments.ts:1150](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1150)


# EventLog
Source: https://docs.qu.ai/sdk/content/classes/EventLog



An **EventLog** contains additional properties parsed from the [**Log**](/sdk/content/classes/Log).

## Extends

* [`Log`](/sdk/content/classes/Log)

## Properties

| Property           | Modifier   | Type                                                  | Description                                                                                                                                                                                                                                                                 | Inherited from                                       |
| :----------------- | :--------- | :---------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------- |
| `address`          | `readonly` | `string`                                              | The address of the contract that emitted this log.                                                                                                                                                                                                                          | [`Log`](/sdk/content/classes/Log).`address`          |
| `args`             | `readonly` | [`Result`](/sdk/content/classes/Result)               | The parsed arguments passed to the event by `emit`.                                                                                                                                                                                                                         | -                                                    |
| `blockHash`        | `readonly` | `string`                                              | The block hash of the block this log occurred in. Use the [**Log.getBlock**](/sdk/content/classes/Log#getblock) to get the<br />[**Block**](/sdk/content/classes/Block).                                                                                                    | [`Log`](/sdk/content/classes/Log).`blockHash`        |
| `blockNumber`      | `readonly` | `number`                                              | The block number of the block this log occurred in. It is preferred to use the Block.hash \| **Block.hash**<br />when fetching the related [**Block**](/sdk/content/classes/Block), since in the case of an orphaned block, the block at that<br />height may have changed. | [`Log`](/sdk/content/classes/Log).`blockNumber`      |
| `data`             | `readonly` | `string`                                              | The data included in this log when it was emitted.                                                                                                                                                                                                                          | [`Log`](/sdk/content/classes/Log).`data`             |
| `fragment`         | `readonly` | [`EventFragment`](/sdk/content/classes/EventFragment) | The matching event.                                                                                                                                                                                                                                                         | -                                                    |
| `index`            | `readonly` | `number`                                              | The index within the block this log occurred at. This is generally not useful to developers, but can be used with<br />the various roots to proof inclusion within a block.                                                                                                 | [`Log`](/sdk/content/classes/Log).`index`            |
| `interface`        | `readonly` | [`Interface`](/sdk/content/classes/Interface)         | The Contract Interface.                                                                                                                                                                                                                                                     | -                                                    |
| `provider`         | `readonly` | [`Provider`](/sdk/content/interfaces/Provider)        | The provider connected to the log used to fetch additional details if necessary.                                                                                                                                                                                            | [`Log`](/sdk/content/classes/Log).`provider`         |
| `removed`          | `readonly` | `boolean`                                             | If the **Log** represents a block that was removed due to an orphaned block, this will be true.<br /><br />This can only happen within an orphan event listener.                                                                                                            | [`Log`](/sdk/content/classes/Log).`removed`          |
| `topics`           | `readonly` | readonly `string`\[]                                  | The indexed topics included in this log when it was emitted.<br /><br />All topics are included in the bloom filters, so they can be efficiently filtered using the<br />[**Provider.getLogs**](/sdk/content/interfaces/Provider#getlogs) method.                           | [`Log`](/sdk/content/classes/Log).`topics`           |
| `transactionHash`  | `readonly` | `string`                                              | The transaction hash of the transaction this log occurred in. Use the<br />[**Log.getTransaction**](/sdk/content/classes/Log#gettransaction) to get the<br />[\*\*TransactionResponse](/sdk/content/type-aliases/TransactionResponse).                                      | [`Log`](/sdk/content/classes/Log).`transactionHash`  |
| `transactionIndex` | `readonly` | `number`                                              | The index within the transaction of this log.                                                                                                                                                                                                                               | [`Log`](/sdk/content/classes/Log).`transactionIndex` |

## Accessors

### eventName

```ts theme={null}
get eventName(): string
```

The name of the event.

#### Returns

`string`

#### Source

[contract/wrappers.ts:47](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/wrappers.ts#L47)

***

### eventSignature

```ts theme={null}
get eventSignature(): string
```

The signature of the event.

#### Returns

`string`

#### Source

[contract/wrappers.ts:54](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/wrappers.ts#L54)

## Methods

### getBlock()

```ts theme={null}
getBlock(shard): Promise<Block>
```

Returns the block that this log occurred in.

#### Parameters

| Parameter | Type                                       | Description                        |
| :-------- | :----------------------------------------- | :--------------------------------- |
| `shard`   | [`Shard`](/sdk/content/enumerations/Shard) | The shard to fetch the block from. |

#### Returns

`Promise`\<[`Block`](/sdk/content/classes/Block)>

A promise resolving to the block.

#### Inherited from

[`Log`](/sdk/content/classes/Log).[`getBlock`](/sdk/content/classes/Log#getblock)

#### Source

[providers/provider.ts:1089](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1089)

***

### getTransaction()

```ts theme={null}
getTransaction(): Promise<TransactionResponse>
```

Returns the transaction that this log occurred in.

#### Returns

`Promise`\<[`TransactionResponse`](/sdk/content/type-aliases/TransactionResponse)>

A promise resolving to the transaction.

#### Inherited from

[`Log`](/sdk/content/classes/Log).[`getTransaction`](/sdk/content/classes/Log#gettransaction)

#### Source

[providers/provider.ts:1100](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1100)

***

### getTransactionReceipt()

```ts theme={null}
getTransactionReceipt(): Promise<TransactionReceipt>
```

Returns the transaction receipt fot the transaction that this log occurred in.

#### Returns

`Promise`\<[`TransactionReceipt`](/sdk/content/classes/TransactionReceipt)>

A promise resolving to the transaction receipt.

#### Inherited from

[`Log`](/sdk/content/classes/Log).[`getTransactionReceipt`](/sdk/content/classes/Log#gettransactionreceipt)

#### Source

[providers/provider.ts:1111](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1111)

***

### toJSON()

```ts theme={null}
toJSON(): any
```

Returns a JSON-compatible object.

#### Returns

`any`

#### Inherited from

[`Log`](/sdk/content/classes/Log).[`toJSON`](/sdk/content/classes/Log#tojson)

#### Source

[providers/provider.ts:1065](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1065)


# FallbackFragment
Source: https://docs.qu.ai/sdk/content/classes/FallbackFragment



A Fragment which represents a method.

## Extends

* [`Fragment`](/sdk/content/classes/Fragment)

## Properties

| Property  | Modifier   | Type                                                      | Description                                          | Inherited from                                       |
| :-------- | :--------- | :-------------------------------------------------------- | :--------------------------------------------------- | :--------------------------------------------------- |
| `inputs`  | `readonly` | readonly [`ParamType`](/sdk/content/classes/ParamType)\[] | The inputs for the fragment.                         | [`Fragment`](/sdk/content/classes/Fragment).`inputs` |
| `payable` | `readonly` | `boolean`                                                 | If the function can be sent value during invocation. | -                                                    |
| `type`    | `readonly` | [`FragmentType`](/sdk/content/type-aliases/FragmentType)  | The type of the fragment.                            | [`Fragment`](/sdk/content/classes/Fragment).`type`   |

## Methods

### format()

```ts theme={null}
format(format?): string
```

Returns a string representation of this fallback as `format`.

#### Parameters

| Parameter | Type                                                 |
| :-------- | :--------------------------------------------------- |
| `format`? | [`FormatType`](/sdk/content/type-aliases/FormatType) |

#### Returns

`string`

#### Overrides

[`Fragment`](/sdk/content/classes/Fragment).[`format`](/sdk/content/classes/Fragment#format)

#### Source

[abi/fragments.ts:1479](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1479)

***

### from()

```ts theme={null}
static from(obj): FallbackFragment
```

Returns a new **FallbackFragment** for `obj`.

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `obj`     | `any` |

#### Returns

[`FallbackFragment`](/sdk/content/classes/FallbackFragment)

#### Overrides

[`Fragment`](/sdk/content/classes/Fragment).[`from`](/sdk/content/classes/Fragment#from)

#### Source

[abi/fragments.ts:1493](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1493)

***

### isConstructor()

```ts theme={null}
static isConstructor(value): value is ConstructorFragment
```

Returns true if `value` is a [**ConstructorFragment**](/sdk/content/classes/ConstructorFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is ConstructorFragment`

#### Inherited from

[`Fragment`](/sdk/content/classes/Fragment).[`isConstructor`](/sdk/content/classes/Fragment#isconstructor)

#### Source

[abi/fragments.ts:1122](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1122)

***

### isError()

```ts theme={null}
static isError(value): value is ErrorFragment
```

Returns true if `value` is an [**ErrorFragment**](/sdk/content/classes/ErrorFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is ErrorFragment`

#### Inherited from

[`Fragment`](/sdk/content/classes/Fragment).[`isError`](/sdk/content/classes/Fragment#iserror)

#### Source

[abi/fragments.ts:1129](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1129)

***

### isEvent()

```ts theme={null}
static isEvent(value): value is EventFragment
```

Returns true if `value` is an [**EventFragment**](/sdk/content/classes/EventFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is EventFragment`

#### Inherited from

[`Fragment`](/sdk/content/classes/Fragment).[`isEvent`](/sdk/content/classes/Fragment#isevent)

#### Source

[abi/fragments.ts:1136](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1136)

***

### isFragment()

```ts theme={null}
static isFragment(value): value is FallbackFragment
```

Returns `true` and provides a type guard if `value` is a **FallbackFragment**.

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is FallbackFragment`

#### Source

[abi/fragments.ts:1574](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1574)

***

### isFunction()

```ts theme={null}
static isFunction(value): value is FunctionFragment
```

Returns true if `value` is a [**FunctionFragment**](/sdk/content/classes/FunctionFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is FunctionFragment`

#### Inherited from

[`Fragment`](/sdk/content/classes/Fragment).[`isFunction`](/sdk/content/classes/Fragment#isfunction)

#### Source

[abi/fragments.ts:1143](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1143)

***

### isStruct()

```ts theme={null}
static isStruct(value): value is StructFragment
```

Returns true if `value` is a [**StructFragment**](/sdk/content/classes/StructFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is StructFragment`

#### Inherited from

[`Fragment`](/sdk/content/classes/Fragment).[`isStruct`](/sdk/content/classes/Fragment#isstruct)

#### Source

[abi/fragments.ts:1150](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1150)


# Fragment
Source: https://docs.qu.ai/sdk/content/classes/Fragment



An abstract class to represent An individual fragment from a parse ABI.

## Extended by

* [`ConstructorFragment`](/sdk/content/classes/ConstructorFragment)
* [`FallbackFragment`](/sdk/content/classes/FallbackFragment)
* [`NamedFragment`](/sdk/content/classes/NamedFragment)

## Properties

| Property | Modifier   | Type                                                      | Description                  |
| :------- | :--------- | :-------------------------------------------------------- | :--------------------------- |
| `inputs` | `readonly` | readonly [`ParamType`](/sdk/content/classes/ParamType)\[] | The inputs for the fragment. |
| `type`   | `readonly` | [`FragmentType`](/sdk/content/type-aliases/FragmentType)  | The type of the fragment.    |

## Methods

### format()

```ts theme={null}
abstract format(format?): string
```

Returns a string representation of this fragment as `format`.

#### Parameters

| Parameter | Type                                                 |
| :-------- | :--------------------------------------------------- |
| `format`? | [`FormatType`](/sdk/content/type-aliases/FormatType) |

#### Returns

`string`

#### Source

[abi/fragments.ts:1055](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1055)

***

### from()

```ts theme={null}
static from(obj): Fragment
```

Creates a new **Fragment** for `obj`, wich can be any supported ABI frgament type.

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `obj`     | `any` |

#### Returns

[`Fragment`](/sdk/content/classes/Fragment)

#### Source

[abi/fragments.ts:1060](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1060)

***

### isConstructor()

```ts theme={null}
static isConstructor(value): value is ConstructorFragment
```

Returns true if `value` is a [**ConstructorFragment**](/sdk/content/classes/ConstructorFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is ConstructorFragment`

#### Source

[abi/fragments.ts:1122](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1122)

***

### isError()

```ts theme={null}
static isError(value): value is ErrorFragment
```

Returns true if `value` is an [**ErrorFragment**](/sdk/content/classes/ErrorFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is ErrorFragment`

#### Source

[abi/fragments.ts:1129](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1129)

***

### isEvent()

```ts theme={null}
static isEvent(value): value is EventFragment
```

Returns true if `value` is an [**EventFragment**](/sdk/content/classes/EventFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is EventFragment`

#### Source

[abi/fragments.ts:1136](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1136)

***

### isFunction()

```ts theme={null}
static isFunction(value): value is FunctionFragment
```

Returns true if `value` is a [**FunctionFragment**](/sdk/content/classes/FunctionFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is FunctionFragment`

#### Source

[abi/fragments.ts:1143](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1143)

***

### isStruct()

```ts theme={null}
static isStruct(value): value is StructFragment
```

Returns true if `value` is a [**StructFragment**](/sdk/content/classes/StructFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is StructFragment`

#### Source

[abi/fragments.ts:1150](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1150)


# FunctionFragment
Source: https://docs.qu.ai/sdk/content/classes/FunctionFragment



A Fragment which represents a method.

## Extends

* [`NamedFragment`](/sdk/content/classes/NamedFragment)

## Properties

| Property          | Modifier   | Type                                                      | Description                                                           | Inherited from                                                 |
| :---------------- | :--------- | :-------------------------------------------------------- | :-------------------------------------------------------------------- | :------------------------------------------------------------- |
| `constant`        | `readonly` | `boolean`                                                 | If the function is constant (e.g. `pure` or `view` functions).        | -                                                              |
| `gas`             | `readonly` | `null` \| `bigint`                                        | The recommended gas limit to send when calling this function.         | -                                                              |
| `inputs`          | `readonly` | readonly [`ParamType`](/sdk/content/classes/ParamType)\[] | The inputs for the fragment.                                          | [`NamedFragment`](/sdk/content/classes/NamedFragment).`inputs` |
| `name`            | `readonly` | `string`                                                  | The name of the fragment.                                             | [`NamedFragment`](/sdk/content/classes/NamedFragment).`name`   |
| `outputs`         | `readonly` | readonly [`ParamType`](/sdk/content/classes/ParamType)\[] | The returned types for the result of calling this function.           | -                                                              |
| `payable`         | `readonly` | `boolean`                                                 | If the function can be sent value during invocation.                  | -                                                              |
| `stateMutability` | `readonly` | `"payable"` \| `"nonpayable"` \| `"view"` \| `"pure"`     | The state mutability (e.g. `payable`, `nonpayable`, `view` or `pure`) | -                                                              |
| `type`            | `readonly` | [`FragmentType`](/sdk/content/type-aliases/FragmentType)  | The type of the fragment.                                             | [`NamedFragment`](/sdk/content/classes/NamedFragment).`type`   |

## Accessors

### selector

```ts theme={null}
get selector(): string
```

The Function selector.

#### Returns

`string`

#### Source

[abi/fragments.ts:1632](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1632)

## Methods

### format()

```ts theme={null}
format(format?): string
```

Returns a string representation of this function as `format`.

#### Parameters

| Parameter | Type                                                 |
| :-------- | :--------------------------------------------------- |
| `format`? | [`FormatType`](/sdk/content/type-aliases/FormatType) |

#### Returns

`string`

#### Overrides

[`NamedFragment`](/sdk/content/classes/NamedFragment).[`format`](/sdk/content/classes/NamedFragment#format)

#### Source

[abi/fragments.ts:1639](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1639)

***

### from()

```ts theme={null}
static from(obj): FunctionFragment
```

Returns a new **FunctionFragment** for `obj`.

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `obj`     | `any` |

#### Returns

[`FunctionFragment`](/sdk/content/classes/FunctionFragment)

#### Overrides

[`NamedFragment`](/sdk/content/classes/NamedFragment).[`from`](/sdk/content/classes/NamedFragment#from)

#### Source

[abi/fragments.ts:1693](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1693)

***

### getSelector()

```ts theme={null}
static getSelector(name, params?): string
```

Return the selector for a function with `name` and `params`.

#### Parameters

| Parameter | Type     |
| :-------- | :------- |
| `name`    | `string` |
| `params`? | `any`\[] |

#### Returns

`string`

#### Source

[abi/fragments.ts:1684](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1684)

***

### isConstructor()

```ts theme={null}
static isConstructor(value): value is ConstructorFragment
```

Returns true if `value` is a [**ConstructorFragment**](/sdk/content/classes/ConstructorFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is ConstructorFragment`

#### Inherited from

[`NamedFragment`](/sdk/content/classes/NamedFragment).[`isConstructor`](/sdk/content/classes/NamedFragment#isconstructor)

#### Source

[abi/fragments.ts:1122](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1122)

***

### isError()

```ts theme={null}
static isError(value): value is ErrorFragment
```

Returns true if `value` is an [**ErrorFragment**](/sdk/content/classes/ErrorFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is ErrorFragment`

#### Inherited from

[`NamedFragment`](/sdk/content/classes/NamedFragment).[`isError`](/sdk/content/classes/NamedFragment#iserror)

#### Source

[abi/fragments.ts:1129](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1129)

***

### isEvent()

```ts theme={null}
static isEvent(value): value is EventFragment
```

Returns true if `value` is an [**EventFragment**](/sdk/content/classes/EventFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is EventFragment`

#### Inherited from

[`NamedFragment`](/sdk/content/classes/NamedFragment).[`isEvent`](/sdk/content/classes/NamedFragment#isevent)

#### Source

[abi/fragments.ts:1136](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1136)

***

### isFragment()

```ts theme={null}
static isFragment(value): value is FunctionFragment
```

Returns `true` and provides a type guard if `value` is a **FunctionFragment**.

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is FunctionFragment`

#### Source

[abi/fragments.ts:1756](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1756)

***

### isFunction()

```ts theme={null}
static isFunction(value): value is FunctionFragment
```

Returns true if `value` is a [**FunctionFragment**](/sdk/content/classes/FunctionFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is FunctionFragment`

#### Inherited from

[`NamedFragment`](/sdk/content/classes/NamedFragment).[`isFunction`](/sdk/content/classes/NamedFragment#isfunction)

#### Source

[abi/fragments.ts:1143](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1143)

***

### isStruct()

```ts theme={null}
static isStruct(value): value is StructFragment
```

Returns true if `value` is a [**StructFragment**](/sdk/content/classes/StructFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is StructFragment`

#### Inherited from

[`NamedFragment`](/sdk/content/classes/NamedFragment).[`isStruct`](/sdk/content/classes/NamedFragment#isstruct)

#### Source

[abi/fragments.ts:1150](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1150)


# Indexed
Source: https://docs.qu.ai/sdk/content/classes/Indexed



An **Indexed** is used as a value when a value that does not fit within a topic (i.e. not a fixed-length, 32-byte
type). It is the `keccak256` of the value, and used for types such as arrays, tuples, bytes and strings.

## Properties

| Property | Modifier   | Type               | Description                          |
| :------- | :--------- | :----------------- | :----------------------------------- |
| `hash`   | `readonly` | `null` \| `string` | The `keccak256` of the value logged. |

## Methods

### isIndexed()

```ts theme={null}
static isIndexed(value): value is Indexed
```

Check if a value is an **Indexed** This provides a Type Guard for property access.

#### Parameters

| Parameter | Type  | Description         |
| :-------- | :---- | :------------------ |
| `value`   | `any` | The value to check. |

#### Returns

`value is Indexed`

`true` if the value is an **Indexed**.

#### Source

[abi/interface.ts:221](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/interface.ts#L221)


# Interface
Source: https://docs.qu.ai/sdk/content/classes/Interface



An Interface abstracts many of the low-level details for encoding and decoding the data on the blockchain.

An ABI provides information on how to encode data to send to a Contract, how to decode the results and events and how
to interpret revert errors.

The ABI can be specified by [any supported format](/sdk/content/type-aliases/InterfaceAbi).

## Constructors

### new Interface()

```ts theme={null}
new Interface(fragments): Interface
```

Create a new Interface for the fragments.

#### Parameters

| Parameter   | Type                                                     | Description        |
| :---------- | :------------------------------------------------------- | :----------------- |
| `fragments` | [`InterfaceAbi`](/sdk/content/type-aliases/InterfaceAbi) | The ABI fragments. |

#### Returns

[`Interface`](/sdk/content/classes/Interface)

#### Source

[abi/interface.ts:342](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/interface.ts#L342)

## Properties

| Property    | Modifier   | Type                                                                  | Description                                                       |
| :---------- | :--------- | :-------------------------------------------------------------------- | :---------------------------------------------------------------- |
| `deploy`    | `readonly` | [`ConstructorFragment`](/sdk/content/classes/ConstructorFragment)     | The Contract constructor.                                         |
| `fallback`  | `readonly` | `null` \| [`FallbackFragment`](/sdk/content/classes/FallbackFragment) | The Fallback method, if any.                                      |
| `fragments` | `readonly` | readonly [`Fragment`](/sdk/content/classes/Fragment)\[]               | All the Contract ABI members (i.e. methods, events, errors, etc). |
| `receive`   | `readonly` | `boolean`                                                             | If receiving ether is supported.                                  |

## Methods

### decodeErrorResult()

```ts theme={null}
decodeErrorResult(fragment, data): Result
```

Decodes the result `data` (e.g. from an `quai_call`) for the specified error (see [**getError**](/sdk/content/classes/Interface#geterror)
for valid values for `key`).

Most developers should prefer the parseCallResult | **parseCallResult** method instead, which will
automatically detect a `CALL_EXCEPTION` and throw the corresponding error.

#### Parameters

| Parameter  | Type                                                              |
| :--------- | :---------------------------------------------------------------- |
| `fragment` | `string` \| [`ErrorFragment`](/sdk/content/classes/ErrorFragment) |
| `data`     | [`BytesLike`](/sdk/content/type-aliases/BytesLike)                |

#### Returns

[`Result`](/sdk/content/classes/Result)

#### Source

[abi/interface.ts:826](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/interface.ts#L826)

***

### decodeFunctionData()

```ts theme={null}
decodeFunctionData(fragment, data): Result
```

Decodes the `data` from a transaction `tx.data` for the function specified (see
[**getFunction**](/sdk/content/classes/Interface#getfunction) for valid values for `fragment`).

Most developers should prefer the [**parseTransaction**](/sdk/content/classes/Interface#parsetransaction) method instead, which will
automatically detect the fragment.

#### Parameters

| Parameter  | Type                                                                    |
| :--------- | :---------------------------------------------------------------------- |
| `fragment` | `string` \| [`FunctionFragment`](/sdk/content/classes/FunctionFragment) |
| `data`     | [`BytesLike`](/sdk/content/type-aliases/BytesLike)                      |

#### Returns

[`Result`](/sdk/content/classes/Result)

#### Source

[abi/interface.ts:866](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/interface.ts#L866)

***

### decodeFunctionResult()

```ts theme={null}
decodeFunctionResult(fragment, data): Result
```

Decodes the result `data` (e.g. from an `quai_call`) for the specified function (see
[**getFunction**](/sdk/content/classes/Interface#getfunction) for valid values for `key`).

Most developers should prefer the parseCallResult | **parseCallResult** method instead, which will
automatically detect a `CALL_EXCEPTION` and throw the corresponding error.

#### Parameters

| Parameter  | Type                                                                    |
| :--------- | :---------------------------------------------------------------------- |
| `fragment` | `string` \| [`FunctionFragment`](/sdk/content/classes/FunctionFragment) |
| `data`     | [`BytesLike`](/sdk/content/type-aliases/BytesLike)                      |

#### Returns

[`Result`](/sdk/content/classes/Result)

#### Source

[abi/interface.ts:904](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/interface.ts#L904)

***

### encodeDeploy()

```ts theme={null}
encodeDeploy(values?): string
```

Encodes a `tx.data` object for deploying the Contract with the `values` as the constructor arguments.

#### Parameters

| Parameter | Type              |
| :-------- | :---------------- |
| `values`? | readonly `any`\[] |

#### Returns

`string`

#### Source

[abi/interface.ts:815](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/interface.ts#L815)

***

### encodeErrorResult()

```ts theme={null}
encodeErrorResult(fragment, values?): string
```

Encodes the transaction revert data for a call result that reverted from the the Contract with the sepcified
`error` (see [**getError**](/sdk/content/classes/Interface#geterror) for valid values for `fragment`) with the `values`.

This is generally not used by most developers, unless trying to mock a result from a Contract.

#### Parameters

| Parameter  | Type                                                              |
| :--------- | :---------------------------------------------------------------- |
| `fragment` | `string` \| [`ErrorFragment`](/sdk/content/classes/ErrorFragment) |
| `values`?  | readonly `any`\[]                                                 |

#### Returns

`string`

#### Source

[abi/interface.ts:849](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/interface.ts#L849)

***

### encodeFunctionData()

```ts theme={null}
encodeFunctionData(fragment, values?): string
```

Encodes the `tx.data` for a transaction that calls the function specified (see
[**getFunction**](/sdk/content/classes/Interface#getfunction) for valid values for `fragment`) with the `values`.

#### Parameters

| Parameter  | Type                                                                    |
| :--------- | :---------------------------------------------------------------------- |
| `fragment` | `string` \| [`FunctionFragment`](/sdk/content/classes/FunctionFragment) |
| `values`?  | readonly `any`\[]                                                       |

#### Returns

`string`

#### Source

[abi/interface.ts:887](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/interface.ts#L887)

***

### encodeFunctionResult()

```ts theme={null}
encodeFunctionResult(fragment, values?): string
```

Encodes the result data (e.g. from an `quai_call`) for the specified function (see
[**getFunction**](/sdk/content/classes/Interface#getfunction) for valid values for `fragment`) with `values`.

This is generally not used by most developers, unless trying to mock a result from a Contract.

#### Parameters

| Parameter  | Type                                                                    |
| :--------- | :---------------------------------------------------------------------- |
| `fragment` | `string` \| [`FunctionFragment`](/sdk/content/classes/FunctionFragment) |
| `values`?  | readonly `any`\[]                                                       |

#### Returns

`string`

#### Source

[abi/interface.ts:975](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/interface.ts#L975)

***

### forEachError()

```ts theme={null}
forEachError(callback): void
```

Iterate over all errors, calling `callback`, sorted by their name.

#### Parameters

| Parameter  | Type                        |
| :--------- | :-------------------------- |
| `callback` | (`func`, `index`) => `void` |

#### Returns

`void`

#### Source

[abi/interface.ts:789](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/interface.ts#L789)

***

### forEachEvent()

```ts theme={null}
forEachEvent(callback): void
```

Iterate over all events, calling `callback`, sorted by their name.

#### Parameters

| Parameter  | Type                        |
| :--------- | :-------------------------- |
| `callback` | (`func`, `index`) => `void` |

#### Returns

`void`

#### Source

[abi/interface.ts:708](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/interface.ts#L708)

***

### forEachFunction()

```ts theme={null}
forEachFunction(callback): void
```

Iterate over all functions, calling `callback`, sorted by their name.

#### Parameters

| Parameter  | Type                        |
| :--------- | :-------------------------- |
| `callback` | (`func`, `index`) => `void` |

#### Returns

`void`

#### Source

[abi/interface.ts:595](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/interface.ts#L595)

***

### format()

```ts theme={null}
format(minimal?): string[]
```

Returns the entire Human-Readable ABI, as an array of signatures, optionally as `minimal` strings, which removes
parameter names and unneceesary spaces.

#### Parameters

| Parameter  | Type      |
| :--------- | :-------- |
| `minimal`? | `boolean` |

#### Returns

`string`\[]

#### Source

[abi/interface.ts:438](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/interface.ts#L438)

***

### formatJson()

```ts theme={null}
formatJson(): string
```

Return the JSON-encoded ABI. This is the format Solidiy returns.

#### Returns

`string`

#### Source

[abi/interface.ts:447](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/interface.ts#L447)

***

### getAbiCoder()

```ts theme={null}
getAbiCoder(): AbiCoder
```

The ABI coder that will be used to encode and decode binary data.

#### Returns

[`AbiCoder`](/sdk/content/classes/AbiCoder)

#### Source

[abi/interface.ts:457](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/interface.ts#L457)

***

### getError()

```ts theme={null}
getError(key, values?): null | ErrorFragment
```

Get the [**ErroFragment**](/sdk/content/classes/ErrorFragment) for `key`, which may be an error selector, error name or error
signature that belongs to the ABI.

If `values` is provided, it will use the Typed API to handle ambiguous cases where multiple errors match by name.

If the `key` and `values` do not refine to a single error in the ABI, this will throw.

#### Parameters

| Parameter | Type     |
| :-------- | :------- |
| `key`     | `string` |
| `values`? | `any`\[] |

#### Returns

`null` | [`ErrorFragment`](/sdk/content/classes/ErrorFragment)

#### Source

[abi/interface.ts:727](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/interface.ts#L727)

***

### getEvent()

```ts theme={null}
getEvent(key, values?): null | EventFragment
```

Get the [**EventFragment**](/sdk/content/classes/EventFragment) for `key`, which may be a topic hash, event name or event
signature that belongs to the ABI.

If `values` is provided, it will use the Typed API to handle ambiguous cases where multiple events match by name.

If the `key` and `values` do not refine to a single event in the ABI, this will throw.

#### Parameters

| Parameter | Type     |
| :-------- | :------- |
| `key`     | `string` |
| `values`? | `any`\[] |

#### Returns

`null` | [`EventFragment`](/sdk/content/classes/EventFragment)

#### Source

[abi/interface.ts:701](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/interface.ts#L701)

***

### getEventName()

```ts theme={null}
getEventName(key): string
```

Get the event name for `key`, which may be a topic hash, event name or event signature that belongs to the ABI.

#### Parameters

| Parameter | Type     |
| :-------- | :------- |
| `key`     | `string` |

#### Returns

`string`

#### Source

[abi/interface.ts:676](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/interface.ts#L676)

***

### getFunction()

```ts theme={null}
getFunction(key, values?): null | FunctionFragment
```

Get the [**FunctionFragment**](/sdk/content/classes/FunctionFragment) for `key`, which may be a function selector, function name
or function signature that belongs to the ABI.

If `values` is provided, it will use the Typed API to handle ambiguous cases where multiple functions match by
name.

If the `key` and `values` do not refine to a single function in the ABI, this will throw.

#### Parameters

| Parameter | Type     |
| :-------- | :------- |
| `key`     | `string` |
| `values`? | `any`\[] |

#### Returns

`null` | [`FunctionFragment`](/sdk/content/classes/FunctionFragment)

#### Source

[abi/interface.ts:588](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/interface.ts#L588)

***

### getFunctionName()

```ts theme={null}
getFunctionName(key): string
```

Get the function name for `key`, which may be a function selector, function name or function signature that
belongs to the ABI.

#### Parameters

| Parameter | Type     |
| :-------- | :------- |
| `key`     | `string` |

#### Returns

`string`

#### Source

[abi/interface.ts:563](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/interface.ts#L563)

***

### hasEvent()

```ts theme={null}
hasEvent(key): boolean
```

Returns true if `key` (an event topic hash, event name or event signature) is present in the ABI.

In the case of an event name, the name may be ambiguous, so accessing the
[**EventFragment**](/sdk/content/classes/EventFragment) may require refinement.

#### Parameters

| Parameter | Type     |
| :-------- | :------- |
| `key`     | `string` |

#### Returns

`boolean`

#### Source

[abi/interface.ts:689](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/interface.ts#L689)

***

### hasFunction()

```ts theme={null}
hasFunction(key): boolean
```

Returns true if `key` (a function selector, function name or function signature) is present in the ABI.

In the case of a function name, the name may be ambiguous, so accessing the
[**FunctionFragment**](/sdk/content/classes/FunctionFragment) may require refinement.

#### Parameters

| Parameter | Type     |
| :-------- | :------- |
| `key`     | `string` |

#### Returns

`boolean`

#### Source

[abi/interface.ts:575](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/interface.ts#L575)

***

### parseError()

```ts theme={null}
parseError(data): null | ErrorDescription
```

Parses a revert data, finding the matching error and extracts the parameter values along with other useful error
details.

If the matching error cannot be found, returns null.

#### Parameters

| Parameter | Type                                               |
| :-------- | :------------------------------------------------- |
| `data`    | [`BytesLike`](/sdk/content/type-aliases/BytesLike) |

#### Returns

`null` | [`ErrorDescription`](/sdk/content/classes/ErrorDescription)

#### Source

[abi/interface.ts:1241](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/interface.ts#L1241)

***

### parseLog()

```ts theme={null}
parseLog(log): null | LogDescription
```

Parses a receipt log, finding the matching event and extracts the parameter values along with other useful event
details.

If the matching event cannot be found, returns null.

#### Parameters

| Parameter    | Type        |
| :----------- | :---------- |
| `log`        | `object`    |
| `log.data`   | `string`    |
| `log.topics` | `string`\[] |

#### Returns

`null` | [`LogDescription`](/sdk/content/classes/LogDescription)

#### Source

[abi/interface.ts:1221](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/interface.ts#L1221)

***

### parseTransaction()

```ts theme={null}
parseTransaction(tx): null | TransactionDescription
```

Parses a transaction, finding the matching function and extracts the parameter values along with other useful
function details.

If the matching function cannot be found, return null.

#### Parameters

| Parameter   | Type                                                     |
| :---------- | :------------------------------------------------------- |
| `tx`        | `object`                                                 |
| `tx.data`   | `string`                                                 |
| `tx.value`? | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) |

#### Returns

`null` | [`TransactionDescription`](/sdk/content/classes/TransactionDescription)

#### Source

[abi/interface.ts:1195](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/interface.ts#L1195)

***

### from()

```ts theme={null}
static from(value): Interface
```

Creates a new [**Interface**](/sdk/content/classes/Interface) from the ABI `value`.

The `value` may be provided as an existing [**Interface**](/sdk/content/classes/Interface) object, a JSON-encoded ABI or any
Human-Readable ABI format.

#### Parameters

| Parameter | Type                                                                                                      |
| :-------- | :-------------------------------------------------------------------------------------------------------- |
| `value`   | [`Interface`](/sdk/content/classes/Interface) \| [`InterfaceAbi`](/sdk/content/type-aliases/InterfaceAbi) |

#### Returns

[`Interface`](/sdk/content/classes/Interface)

#### Source

[abi/interface.ts:1260](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/interface.ts#L1260)


# LogDescription
Source: https://docs.qu.ai/sdk/content/classes/LogDescription



When using the [**Interface.parseLog**](/sdk/content/classes/Interface#parselog) to automatically match a Log to its event for
parsing, a **LogDescription** is returned.

## Properties

| Property    | Modifier   | Type                                                  | Description                                      |
| :---------- | :--------- | :---------------------------------------------------- | :----------------------------------------------- |
| `args`      | `readonly` | [`Result`](/sdk/content/classes/Result)               | The arguments passed into the Event with `emit`. |
| `fragment`  | `readonly` | [`EventFragment`](/sdk/content/classes/EventFragment) | The matching fragment for the `topic0`.          |
| `name`      | `readonly` | `string`                                              | The name of the Event.                           |
| `signature` | `readonly` | `string`                                              | The full Event signature.                        |
| `topic`     | `readonly` | `string`                                              | The topic hash for the Event.                    |


# NamedFragment
Source: https://docs.qu.ai/sdk/content/classes/NamedFragment



An abstract class to represent An individual fragment which has a name from a parse ABI.

## Extends

* [`Fragment`](/sdk/content/classes/Fragment)

## Extended by

* [`ErrorFragment`](/sdk/content/classes/ErrorFragment)
* [`EventFragment`](/sdk/content/classes/EventFragment)
* [`FunctionFragment`](/sdk/content/classes/FunctionFragment)
* [`StructFragment`](/sdk/content/classes/StructFragment)

## Properties

| Property | Modifier   | Type                                                      | Description                  | Inherited from                                       |
| :------- | :--------- | :-------------------------------------------------------- | :--------------------------- | :--------------------------------------------------- |
| `inputs` | `readonly` | readonly [`ParamType`](/sdk/content/classes/ParamType)\[] | The inputs for the fragment. | [`Fragment`](/sdk/content/classes/Fragment).`inputs` |
| `name`   | `readonly` | `string`                                                  | The name of the fragment.    | -                                                    |
| `type`   | `readonly` | [`FragmentType`](/sdk/content/type-aliases/FragmentType)  | The type of the fragment.    | [`Fragment`](/sdk/content/classes/Fragment).`type`   |

## Methods

### format()

```ts theme={null}
abstract format(format?): string
```

Returns a string representation of this fragment as `format`.

#### Parameters

| Parameter | Type                                                 |
| :-------- | :--------------------------------------------------- |
| `format`? | [`FormatType`](/sdk/content/type-aliases/FormatType) |

#### Returns

`string`

#### Inherited from

[`Fragment`](/sdk/content/classes/Fragment).[`format`](/sdk/content/classes/Fragment#format)

#### Source

[abi/fragments.ts:1055](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1055)

***

### from()

```ts theme={null}
static from(obj): Fragment
```

Creates a new **Fragment** for `obj`, wich can be any supported ABI frgament type.

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `obj`     | `any` |

#### Returns

[`Fragment`](/sdk/content/classes/Fragment)

#### Inherited from

[`Fragment`](/sdk/content/classes/Fragment).[`from`](/sdk/content/classes/Fragment#from)

#### Source

[abi/fragments.ts:1060](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1060)

***

### isConstructor()

```ts theme={null}
static isConstructor(value): value is ConstructorFragment
```

Returns true if `value` is a [**ConstructorFragment**](/sdk/content/classes/ConstructorFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is ConstructorFragment`

#### Inherited from

[`Fragment`](/sdk/content/classes/Fragment).[`isConstructor`](/sdk/content/classes/Fragment#isconstructor)

#### Source

[abi/fragments.ts:1122](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1122)

***

### isError()

```ts theme={null}
static isError(value): value is ErrorFragment
```

Returns true if `value` is an [**ErrorFragment**](/sdk/content/classes/ErrorFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is ErrorFragment`

#### Inherited from

[`Fragment`](/sdk/content/classes/Fragment).[`isError`](/sdk/content/classes/Fragment#iserror)

#### Source

[abi/fragments.ts:1129](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1129)

***

### isEvent()

```ts theme={null}
static isEvent(value): value is EventFragment
```

Returns true if `value` is an [**EventFragment**](/sdk/content/classes/EventFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is EventFragment`

#### Inherited from

[`Fragment`](/sdk/content/classes/Fragment).[`isEvent`](/sdk/content/classes/Fragment#isevent)

#### Source

[abi/fragments.ts:1136](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1136)

***

### isFunction()

```ts theme={null}
static isFunction(value): value is FunctionFragment
```

Returns true if `value` is a [**FunctionFragment**](/sdk/content/classes/FunctionFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is FunctionFragment`

#### Inherited from

[`Fragment`](/sdk/content/classes/Fragment).[`isFunction`](/sdk/content/classes/Fragment#isfunction)

#### Source

[abi/fragments.ts:1143](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1143)

***

### isStruct()

```ts theme={null}
static isStruct(value): value is StructFragment
```

Returns true if `value` is a [**StructFragment**](/sdk/content/classes/StructFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is StructFragment`

#### Inherited from

[`Fragment`](/sdk/content/classes/Fragment).[`isStruct`](/sdk/content/classes/Fragment#isstruct)

#### Source

[abi/fragments.ts:1150](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1150)


# ParamType
Source: https://docs.qu.ai/sdk/content/classes/ParamType



Each input and output of a [**Fragment**](/sdk/content/classes/Fragment) is an Array of [**ParamType**](/sdk/content/classes/ParamType).

## Properties

| Property        | Modifier   | Type                                                                | Description                                                                                           |
| :-------------- | :--------- | :------------------------------------------------------------------ | :---------------------------------------------------------------------------------------------------- |
| `arrayChildren` | `readonly` | `null` \| [`ParamType`](/sdk/content/classes/ParamType)             | The type of each child in the array.<br /><br />For non-array types this is `null`.                   |
| `arrayLength`   | `readonly` | `null` \| `number`                                                  | The array length, or `-1` for dynamic-lengthed arrays.<br /><br />For non-array types this is `null`. |
| `baseType`      | `readonly` | `string`                                                            | The base type (e.g. `"address"`, `"tuple"`, `"array"`)                                                |
| `components`    | `readonly` | `null` \| readonly [`ParamType`](/sdk/content/classes/ParamType)\[] | The components for the tuple.<br /><br />For non-tuple types this is `null`.                          |
| `indexed`       | `readonly` | `null` \| `boolean`                                                 | True if the parameters is indexed.<br /><br />For non-indexable types this is `null`.                 |
| `name`          | `readonly` | `string`                                                            | The local name of the parameter (or `""` if unbound)                                                  |
| `type`          | `readonly` | `string`                                                            | The fully qualified type (e.g. `"address"`, `"tuple(address)"`, `"uint256[3][]"`)                     |

## Methods

### format()

```ts theme={null}
format(format?): string
```

Return a string representation of this type.

For example,

`sighash" => "(uint256,address)"`

`"minimal" => "tuple(uint256,address) indexed"`

`"full" => "tuple(uint256 foo, address bar) indexed baz"`

#### Parameters

| Parameter | Type                                                 |
| :-------- | :--------------------------------------------------- |
| `format`? | [`FormatType`](/sdk/content/type-aliases/FormatType) |

#### Returns

`string`

The formatted type.

#### Source

[abi/fragments.ts:707](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L707)

***

### isArray()

```ts theme={null}
isArray(): this is ParamType & Object
```

This provides a type guard ensuring that [**arrayChildren**](/sdk/content/classes/ParamType) and
[**arrayLength**](/sdk/content/classes/ParamType) are non-null.

#### Returns

`this is ParamType & Object`

True if this is an Array type.

#### Source

[abi/fragments.ts:768](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L768)

***

### isIndexable()

```ts theme={null}
isIndexable(): this is ParamType & Object
```

This provides a type guard ensuring that [**indexed**](/sdk/content/classes/ParamType) is non-null.

#### Returns

`this is ParamType & Object`

True if this is an Indexable type.

#### Source

[abi/fragments.ts:786](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L786)

***

### isTuple()

```ts theme={null}
isTuple(): this is ParamType & Object
```

This provides a type guard ensuring that [**components**](/sdk/content/classes/ParamType) is non-null.

#### Returns

`this is ParamType & Object`

True if this is a Tuple type.

#### Source

[abi/fragments.ts:777](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L777)

***

### walk()

```ts theme={null}
walk(value, process): any
```

Walks the **ParamType** with `value`, calling `process` on each type, destructing the `value` recursively.

#### Parameters

| Parameter | Type                                                               |
| :-------- | :----------------------------------------------------------------- |
| `value`   | `any`                                                              |
| `process` | [`ParamTypeWalkFunc`](/sdk/content/type-aliases/ParamTypeWalkFunc) |

#### Returns

`any`

#### Source

[abi/fragments.ts:793](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L793)

***

### walkAsync()

```ts theme={null}
walkAsync(value, process): Promise<any>
```

Walks the **ParamType** with `value`, asynchronously calling `process` on each type, destructing the `value`
recursively.

This can be used to resolve ENS naes by walking and resolving each `"address"` type.

#### Parameters

| Parameter | Type                                                                         |
| :-------- | :--------------------------------------------------------------------------- |
| `value`   | `any`                                                                        |
| `process` | [`ParamTypeWalkAsyncFunc`](/sdk/content/type-aliases/ParamTypeWalkAsyncFunc) |

#### Returns

`Promise`\<`any`>

#### Source

[abi/fragments.ts:903](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L903)

***

### from()

```ts theme={null}
static from(obj, allowIndexed?): ParamType
```

Creates a new **ParamType** for `obj`.

If `allowIndexed` then the `indexed` keyword is permitted, otherwise the `indexed` keyword will throw an error.

#### Parameters

| Parameter       | Type      |
| :-------------- | :-------- |
| `obj`           | `any`     |
| `allowIndexed`? | `boolean` |

#### Returns

[`ParamType`](/sdk/content/classes/ParamType)

#### Source

[abi/fragments.ts:920](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L920)

***

### isParamType()

```ts theme={null}
static isParamType(value): value is ParamType
```

Returns true if `value` is a **ParamType**.

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is ParamType`

#### Source

[abi/fragments.ts:1015](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1015)


# Result
Source: https://docs.qu.ai/sdk/content/classes/Result



A [**Result**](/sdk/content/classes/Result) is a sub-class of Array, which allows accessing any of its values either positionally by
its index or, if keys are provided by its name.

## Extends

* `Array`\<`any`>

## Methods

### getValue()

```ts theme={null}
getValue(name): any
```

Returns the value for `name`.

Since it is possible to have a key whose name conflicts with a method on a [**Result**](/sdk/content/classes/Result) or its
superclass Array, or any JavaScript keyword, this ensures all named values are still accessible by name.

#### Parameters

| Parameter | Type     | Description                        |
| :-------- | :------- | :--------------------------------- |
| `name`    | `string` | The name of the value to retrieve. |

#### Returns

`any`

The value for `name`.

#### Source

[abi/coders/abstract-coder.ts:270](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/coders/abstract-coder.ts#L270)

***

### toArray()

```ts theme={null}
toArray(): any[]
```

Returns the Result as a normal Array.

This will throw if there are any outstanding deferred errors.

#### Returns

`any`\[]

#### Source

[abi/coders/abstract-coder.ts:149](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/coders/abstract-coder.ts#L149)

***

### toObject()

```ts theme={null}
toObject(): Record<string, any>
```

Returns the Result as an Object with each name-value pair.

This will throw if any value is unnamed, or if there are any outstanding deferred errors.

#### Returns

`Record`\<`string`, `any`>

#### Source

[abi/coders/abstract-coder.ts:165](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/coders/abstract-coder.ts#L165)

***

### fromItems()

```ts theme={null}
static fromItems(items, keys?): Result
```

Creates a new [**Result**](/sdk/content/classes/Result) for `items` with each entry also accessible by its corresponding name in
`keys`.

#### Parameters

| Parameter | Type                    | Description                         |
| :-------- | :---------------------- | :---------------------------------- |
| `items`   | `any`\[]                | The items to include in the Result. |
| `keys`?   | (`null` \| `string`)\[] | The names for each item in `items`. |

#### Returns

[`Result`](/sdk/content/classes/Result)

The new Result.

#### Source

[abi/coders/abstract-coder.ts:294](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/coders/abstract-coder.ts#L294)


# Signature
Source: https://docs.qu.ai/sdk/content/classes/Signature



A Signature

## TODO

## Accessors

### compactSerialized

```ts theme={null}
get compactSerialized(): string
```

The [EIP-2098](https://eips.ethereum.org/EIPS/eip-2098) compact representation.

#### Returns

`string`

#### Source

[crypto/signature.ts:161](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/signature.ts#L161)

***

### legacyChainId

```ts theme={null}
get legacyChainId(): null | bigint
```

The chain ID for EIP-155 legacy transactions. For non-legacy transactions, this value is `null`.

#### Returns

`null` | `bigint`

#### Source

[crypto/signature.ts:128](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/signature.ts#L128)

***

### networkV

```ts theme={null}
get networkV(): null | bigint
```

The EIP-155 `v` for legacy transactions. For non-legacy transactions, this value is `null`.

#### Returns

`null` | `bigint`

#### Source

[crypto/signature.ts:121](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/signature.ts#L121)

***

### r

```ts theme={null}
get r(): string
```

The `r` value for a signautre.

This represents the `x` coordinate of a "reference" or challenge point, from which the `y` can be computed.

#### Returns

`string`

#### Source

[crypto/signature.ts:80](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/signature.ts#L80)

***

### s

```ts theme={null}
get s(): string
```

The `s` value for a signature.

#### Returns

`string`

#### Source

[crypto/signature.ts:91](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/signature.ts#L91)

***

### serialized

```ts theme={null}
get serialized(): string
```

The serialized representation.

#### Returns

`string`

#### Source

[crypto/signature.ts:168](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/signature.ts#L168)

***

### v

```ts theme={null}
get v(): 27 | 28
```

The `v` value for a signature.

Since a given `x` value for `r` has two possible values for its correspondin `y`, the `v` indicates which of the
two `y` values to use.

It is normalized to the values `27` or `28` for legacy purposes.

#### Returns

`27` | `28`

#### Source

[crypto/signature.ts:109](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/signature.ts#L109)

***

### yParity

```ts theme={null}
get yParity(): 0 | 1
```

The `yParity` for the signature.

See `v` for more details on how this value is used.

#### Returns

`0` | `1`

#### Source

[crypto/signature.ts:141](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/signature.ts#L141)

***

### yParityAndS

```ts theme={null}
get yParityAndS(): string
```

The [EIP-2098](https://eips.ethereum.org/EIPS/eip-2098) compact representation of the `yParity` and `s` compacted
into a single `bytes32`.

#### Returns

`string`

#### Source

[crypto/signature.ts:149](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/signature.ts#L149)

## Methods

### clone()

```ts theme={null}
clone(): Signature
```

Returns a new identical [**Signature**](/sdk/content/classes/Signature).

#### Returns

[`Signature`](/sdk/content/classes/Signature)

#### Source

[crypto/signature.ts:190](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/signature.ts#L190)

***

### toJSON()

```ts theme={null}
toJSON(): any
```

Returns a representation that is compatible with `JSON.stringify`.

#### Returns

`any`

#### Source

[crypto/signature.ts:201](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/signature.ts#L201)

***

### from()

```ts theme={null}
static from(sig?): Signature
```

Creates a new [**Signature**](/sdk/content/classes/Signature).

If no `sig` is provided, a new [**Signature**](/sdk/content/classes/Signature) is created with default values.

If `sig` is a string, it is parsed.

#### Parameters

| Parameter | Type                                                       | Description              |
| :-------- | :--------------------------------------------------------- | :----------------------- |
| `sig`?    | [`SignatureLike`](/sdk/content/type-aliases/SignatureLike) | The signature to create. |

#### Returns

[`Signature`](/sdk/content/classes/Signature)

The new signature.

#### Source

[crypto/signature.ts:312](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/signature.ts#L312)

***

### getChainId()

```ts theme={null}
static getChainId(v): bigint
```

Compute the chain ID from the `v` in a legacy EIP-155 transactions.

#### Parameters

| Parameter | Type                                                     | Description                       |
| :-------- | :------------------------------------------------------- | :-------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The `v` value from the signature. |

#### Returns

`bigint`

The chain ID.

#### Example

```ts theme={null}
Signature.getChainId(45);

Signature.getChainId(46);
```

#### Source

[crypto/signature.ts:226](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/signature.ts#L226)

***

### getChainIdV()

```ts theme={null}
static getChainIdV(chainId, v): bigint
```

Compute the `v` for a chain ID for a legacy EIP-155 transactions.

Legacy transactions which use [EIP-155](https://eips.ethereum.org/EIPS/eip-155) hijack the `v` property to
include the chain ID.

#### Parameters

| Parameter | Type                                                     | Description    |
| :-------- | :------------------------------------------------------- | :------------- |
| `chainId` | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The chain ID.  |
| `v`       | `27` \| `28`                                             | The `v` value. |

#### Returns

`bigint`

The `v` value.

#### Example

```ts theme={null}
Signature.getChainIdV(5, 27);

Signature.getChainIdV(5, 28);
```

#### Source

[crypto/signature.ts:258](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/signature.ts#L258)

***

### getNormalizedV()

```ts theme={null}
static getNormalizedV(v): 27 | 28
```

Compute the normalized legacy transaction `v` from a `yParirty`, a legacy transaction `v` or a legacy
[EIP-155](https://eips.ethereum.org/EIPS/eip-155) transaction.

#### Parameters

| Parameter | Type                                                     | Description    |
| :-------- | :------------------------------------------------------- | :------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The `v` value. |

#### Returns

`27` | `28`

The normalized `v` value.

#### Example

```ts theme={null}
// The values 0 and 1 imply v is actually yParity
Signature.getNormalizedV(0);

// Legacy non-EIP-1559 transaction (i.e. 27 or 28)
Signature.getNormalizedV(27);

// Legacy EIP-155 transaction (i.e. >= 35)
Signature.getNormalizedV(46);

// Invalid values throw
Signature.getNormalizedV(5);
```

#### Throws

Thrown if the `v` is invalid.

#### Source

[crypto/signature.ts:286](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/signature.ts#L286)


# SigningKey
Source: https://docs.qu.ai/sdk/content/classes/SigningKey



A **SigningKey** provides high-level access to the elliptic curve cryptography (ECC) operations and key management.

## Constructors

### new SigningKey()

```ts theme={null}
new SigningKey(privateKey): SigningKey
```

Creates a new **SigningKey** for `privateKey`.

#### Parameters

| Parameter    | Type                                               |
| :----------- | :------------------------------------------------- |
| `privateKey` | [`BytesLike`](/sdk/content/type-aliases/BytesLike) |

#### Returns

[`SigningKey`](/sdk/content/classes/SigningKey)

#### Source

[crypto/signing-key.ts:26](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/signing-key.ts#L26)

## Accessors

### compressedPublicKey

```ts theme={null}
get compressedPublicKey(): string
```

The compressed public key.

This will always begin with either the prefix `0x02` or `0x03` and be 68 characters long (the `0x` prefix and 33
hexadecimal nibbles)

#### Returns

`string`

#### Source

[crypto/signing-key.ts:54](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/signing-key.ts#L54)

***

### privateKey

```ts theme={null}
get privateKey(): string
```

The private key.

#### Returns

`string`

#### Source

[crypto/signing-key.ts:34](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/signing-key.ts#L34)

***

### publicKey

```ts theme={null}
get publicKey(): string
```

The uncompressed public key.

This will always begin with the prefix `0x04` and be 132 characters long (the `0x` prefix and 130 hexadecimal
nibbles).

#### Returns

`string`

#### Source

[crypto/signing-key.ts:44](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/signing-key.ts#L44)

## Methods

### computeSharedSecret()

```ts theme={null}
computeSharedSecret(other): string
```

Returns the [ECDH](https://en.wikipedia.org/wiki/Elliptic-curve_Diffie-Hellman) shared secret between this
private key and the `other` key.

The `other` key may be any type of key, a raw public key, a compressed/uncompressed pubic key or aprivate key.

Best practice is usually to use a cryptographic hash on the returned value before using it as a symetric secret.

#### Parameters

| Parameter | Type                                               | Description                                      |
| :-------- | :------------------------------------------------- | :----------------------------------------------- |
| `other`   | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The other key to compute the shared secret with. |

#### Returns

`string`

The shared secret.

#### Example

```ts theme={null}
sign1 = new SigningKey(id('some-secret-1'));
sign2 = new SigningKey(id('some-secret-2'));

// Notice that privA.computeSharedSecret(pubB)...
sign1.computeSharedSecret(sign2.publicKey);

// ...is equal to privB.computeSharedSecret(pubA).
sign2.computeSharedSecret(sign1.publicKey);
```

#### Source

[crypto/signing-key.ts:103](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/signing-key.ts#L103)

***

### sign()

```ts theme={null}
sign(digest): Signature
```

Return the signature of the signed `digest`.

#### Parameters

| Parameter | Type                                               | Description       |
| :-------- | :------------------------------------------------- | :---------------- |
| `digest`  | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The data to sign. |

#### Returns

[`Signature`](/sdk/content/classes/Signature)

The signature of the data.

#### Throws

If the digest is not 32 bytes long.

#### Source

[crypto/signing-key.ts:65](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/signing-key.ts#L65)

***

### addPoints()

```ts theme={null}
static addPoints(
   p0, 
   p1, 
   compressed?): string
```

Returns the point resulting from adding the ellipic curve points `p0` and `p1`.

This is not a common function most developers should require, but can be useful for certain privacy-specific
techniques.

For example, it is used by [**QuaiHDWallet**](../classes/QuaiHDWallet) to compute child addresses from parent
public keys and chain codes.

#### Parameters

| Parameter     | Type                                               | Description                                  |
| :------------ | :------------------------------------------------- | :------------------------------------------- |
| `p0`          | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The first point to add.                      |
| `p1`          | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The second point to add.                     |
| `compressed`? | `boolean`                                          | Whether to return the compressed public key. |

#### Returns

`string`

The sum of the points.

#### Source

[crypto/signing-key.ts:205](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/signing-key.ts#L205)

***

### computePublicKey()

```ts theme={null}
static computePublicKey(key, compressed?): string
```

Compute the public key for `key`, optionally `compressed`.

The `key` may be any type of key, a raw public key, a compressed/uncompressed public key or private key.

#### Parameters

| Parameter     | Type                                               | Description                                  |
| :------------ | :------------------------------------------------- | :------------------------------------------- |
| `key`         | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The key to compute the public key for.       |
| `compressed`? | `boolean`                                          | Whether to return the compressed public key. |

#### Returns

`string`

The public key.

#### Example

```ts theme={null}
sign = new SigningKey(id('some-secret'));

// Compute the uncompressed public key for a private key
SigningKey.computePublicKey(sign.privateKey);

// Compute the compressed public key for a private key
SigningKey.computePublicKey(sign.privateKey, true);

// Compute the uncompressed public key
SigningKey.computePublicKey(sign.publicKey, false);

// Compute the Compressed a public key
SigningKey.computePublicKey(sign.publicKey, true);
```

#### Source

[crypto/signing-key.ts:135](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/signing-key.ts#L135)

***

### recoverPublicKey()

```ts theme={null}
static recoverPublicKey(digest, signature): string
```

Returns the public key for the private key which produced the `signature` for the given `digest`.

#### Parameters

| Parameter   | Type                                                       | Description                |
| :---------- | :--------------------------------------------------------- | :------------------------- |
| `digest`    | [`BytesLike`](/sdk/content/type-aliases/BytesLike)         | The data that was signed.  |
| `signature` | [`SignatureLike`](/sdk/content/type-aliases/SignatureLike) | The signature of the data. |

#### Returns

`string`

The public key.

#### Example

```ts theme={null}
key = new SigningKey(id('some-secret'));
digest = id('hello world');
sig = key.sign(digest);

// Notice the signer public key...
key.publicKey;

// ...is equal to the recovered public key
SigningKey.recoverPublicKey(digest, sig);
```

#### Source

[crypto/signing-key.ts:177](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/signing-key.ts#L177)


# StructFragment
Source: https://docs.qu.ai/sdk/content/classes/StructFragment



A Fragment which represents a structure.

## Extends

* [`NamedFragment`](/sdk/content/classes/NamedFragment)

## Properties

| Property | Modifier   | Type                                                      | Description                  | Inherited from                                                 |
| :------- | :--------- | :-------------------------------------------------------- | :--------------------------- | :------------------------------------------------------------- |
| `inputs` | `readonly` | readonly [`ParamType`](/sdk/content/classes/ParamType)\[] | The inputs for the fragment. | [`NamedFragment`](/sdk/content/classes/NamedFragment).`inputs` |
| `name`   | `readonly` | `string`                                                  | The name of the fragment.    | [`NamedFragment`](/sdk/content/classes/NamedFragment).`name`   |
| `type`   | `readonly` | [`FragmentType`](/sdk/content/type-aliases/FragmentType)  | The type of the fragment.    | [`NamedFragment`](/sdk/content/classes/NamedFragment).`type`   |

## Methods

### format()

```ts theme={null}
format(): string
```

Returns a string representation of this struct as `format`.

#### Returns

`string`

#### Overrides

[`NamedFragment`](/sdk/content/classes/NamedFragment).[`format`](/sdk/content/classes/NamedFragment#format)

#### Source

[abi/fragments.ts:1778](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1778)

***

### from()

```ts theme={null}
static from(obj): StructFragment
```

Returns a new **StructFragment** for `obj`.

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `obj`     | `any` |

#### Returns

[`StructFragment`](/sdk/content/classes/StructFragment)

#### Overrides

[`NamedFragment`](/sdk/content/classes/NamedFragment).[`from`](/sdk/content/classes/NamedFragment#from)

#### Source

[abi/fragments.ts:1785](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1785)

***

### isConstructor()

```ts theme={null}
static isConstructor(value): value is ConstructorFragment
```

Returns true if `value` is a [**ConstructorFragment**](/sdk/content/classes/ConstructorFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is ConstructorFragment`

#### Inherited from

[`NamedFragment`](/sdk/content/classes/NamedFragment).[`isConstructor`](/sdk/content/classes/NamedFragment#isconstructor)

#### Source

[abi/fragments.ts:1122](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1122)

***

### isError()

```ts theme={null}
static isError(value): value is ErrorFragment
```

Returns true if `value` is an [**ErrorFragment**](/sdk/content/classes/ErrorFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is ErrorFragment`

#### Inherited from

[`NamedFragment`](/sdk/content/classes/NamedFragment).[`isError`](/sdk/content/classes/NamedFragment#iserror)

#### Source

[abi/fragments.ts:1129](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1129)

***

### isEvent()

```ts theme={null}
static isEvent(value): value is EventFragment
```

Returns true if `value` is an [**EventFragment**](/sdk/content/classes/EventFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is EventFragment`

#### Inherited from

[`NamedFragment`](/sdk/content/classes/NamedFragment).[`isEvent`](/sdk/content/classes/NamedFragment#isevent)

#### Source

[abi/fragments.ts:1136](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1136)

***

### isFragment()

```ts theme={null}
static isFragment(value): value is FunctionFragment
```

Returns `true` and provides a type guard if `value` is a **StructFragment**.

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is FunctionFragment`

#### Source

[abi/fragments.ts:1806](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1806)

***

### isFunction()

```ts theme={null}
static isFunction(value): value is FunctionFragment
```

Returns true if `value` is a [**FunctionFragment**](/sdk/content/classes/FunctionFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is FunctionFragment`

#### Inherited from

[`NamedFragment`](/sdk/content/classes/NamedFragment).[`isFunction`](/sdk/content/classes/NamedFragment#isfunction)

#### Source

[abi/fragments.ts:1143](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1143)

***

### isStruct()

```ts theme={null}
static isStruct(value): value is StructFragment
```

Returns true if `value` is a [**StructFragment**](/sdk/content/classes/StructFragment).

#### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

#### Returns

`value is StructFragment`

#### Inherited from

[`NamedFragment`](/sdk/content/classes/NamedFragment).[`isStruct`](/sdk/content/classes/NamedFragment#isstruct)

#### Source

[abi/fragments.ts:1150](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1150)


# TransactionDescription
Source: https://docs.qu.ai/sdk/content/classes/TransactionDescription



When using the [**Interface.parseTransaction**](/sdk/content/classes/Interface#parsetransaction) to automatically match a
transaction data to its function for parsing, a **TransactionDescription** is returned.

## Properties

| Property    | Modifier   | Type                                                        | Description                                                       |
| :---------- | :--------- | :---------------------------------------------------------- | :---------------------------------------------------------------- |
| `args`      | `readonly` | [`Result`](/sdk/content/classes/Result)                     | The arguments passed to the Function from the transaction `data`. |
| `fragment`  | `readonly` | [`FunctionFragment`](/sdk/content/classes/FunctionFragment) | The matching fragment from the transaction `data`.                |
| `name`      | `readonly` | `string`                                                    | The name of the Function from the transaction `data`.             |
| `selector`  | `readonly` | `string`                                                    | The selector for the Function from the transaction `data`.        |
| `signature` | `readonly` | `string`                                                    | The full Function signature from the transaction `data`.          |
| `value`     | `readonly` | `bigint`                                                    | The `value` (in wei) from the transaction.                        |


# Typed
Source: https://docs.qu.ai/sdk/content/classes/Typed



The **Typed** class to wrap values providing explicit type information.

## Properties

| Property | Modifier   | Type     | Description                              |
| :------- | :--------- | :------- | :--------------------------------------- |
| `type`   | `readonly` | `string` | The type, as a Solidity-compatible type. |
| `value`  | `readonly` | `any`    | The actual value.                        |

## Accessors

### arrayLength

```ts theme={null}
get arrayLength(): null | number
```

Returns the length of a typed array.

#### Throws

If this is not an array.

#### Returns

`null` | `number`

The length of the array type or `-1` if it is dynamic.

#### Source

[abi/typed.ts:241](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L241)

***

### tupleName

```ts theme={null}
get tupleName(): null | string
```

Returns the tuple name.

#### Throws

If this is not a tuple.

#### Returns

`null` | `string`

The tuple name if this is a tuple.

#### Source

[abi/typed.ts:228](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L228)

## Methods

### defaultValue()

```ts theme={null}
defaultValue(): string | number | bigint | Result
```

The default value returned by this type.

#### Returns

`string` | `number` | `bigint` | [`Result`](/sdk/content/classes/Result)

The default value for this type.

#### Source

[abi/typed.ts:173](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L173)

***

### format()

```ts theme={null}
format(): string
```

Format the type as a Human-Readable type.

#### Returns

`string`

The human-readable type for the provided type.

#### Throws

If the type is array or dynamic array.

#### Source

[abi/typed.ts:156](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L156)

***

### isBigInt()

```ts theme={null}
isBigInt(): this is TypedBigInt
```

Returns whether this is a TypedBigInt | **TypedBigInt**. If true, a type guard is provided.

#### Returns

`this is TypedBigInt`

`true` if this is a big integer.

#### Source

[abi/typed.ts:200](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L200)

***

### isData()

```ts theme={null}
isData(): this is TypedData
```

Returns whether this is a TypedData | **TypedData**. If true, a type guard is provided.

#### Returns

`this is TypedData`

`true` if this is a number.

#### Source

[abi/typed.ts:209](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L209)

***

### isString()

```ts theme={null}
isString(): this is TypedString
```

Return whether this is a TypedString | **TypedString**. If true, a type guard is provided.

#### Returns

`this is TypedString`

`true` if this is a string.

#### Source

[abi/typed.ts:218](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L218)

***

### maxValue()

```ts theme={null}
maxValue(): string | number | bigint
```

The maximum value for numeric types.

#### Returns

`string` | `number` | `bigint`

The maximum value for the provided numeric type.

#### Source

[abi/typed.ts:191](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L191)

***

### minValue()

```ts theme={null}
minValue(): string | number | bigint
```

The minimum value for numeric types.

#### Returns

`string` | `number` | `bigint`

The minimum value for the provided numeric type.

#### Source

[abi/typed.ts:182](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L182)

***

### address()

```ts theme={null}
static address(v): Typed
```

Return a new `address` type for `v`.

#### Parameters

| Parameter | Type                                                             | Description                           |
| :-------- | :--------------------------------------------------------------- | :------------------------------------ |
| `v`       | `string` \| [`Addressable`](/sdk/content/interfaces/Addressable) | The value to convert to an `address`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `address` type for `v`.

#### Source

[abi/typed.ts:1250](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1250)

***

### array()

```ts theme={null}
static array(v, dynamic?): Typed
```

Return a new `array` type for v, allowing dynamic length.

#### Parameters

| Parameter  | Type                | Description                         |
| :--------- | :------------------ | :---------------------------------- |
| `v`        | `any`\[]            | The value to convert to an `array`. |
| `dynamic`? | `null` \| `boolean` | Whether the array is dynamic.       |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `array` type for `v`.

#### Source

[abi/typed.ts:1291](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1291)

***

### bool()

```ts theme={null}
static bool(v): Typed
```

Return a new `bool` type for `v`.

#### Parameters

| Parameter | Type  | Description                       |
| :-------- | :---- | :-------------------------------- |
| `v`       | `any` | The value to convert to a `bool`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bool` type for `v`.

#### Source

[abi/typed.ts:1260](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1260)

***

### bytes()

```ts theme={null}
static bytes(v): Typed
```

Return a new `bytes` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                        |
| :-------- | :------------------------------------------------- | :--------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes` type for `v`.

#### Source

[abi/typed.ts:1270](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1270)

***

### bytes1()

```ts theme={null}
static bytes1(v): Typed
```

Return a new `bytes1` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                         |
| :-------- | :------------------------------------------------- | :---------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes1`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes1` type for `v`.

#### Source

[abi/typed.ts:930](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L930)

***

### bytes10()

```ts theme={null}
static bytes10(v): Typed
```

Return a new `bytes10` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                          |
| :-------- | :------------------------------------------------- | :----------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes10`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes10` type for `v`.

#### Source

[abi/typed.ts:1020](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1020)

***

### bytes11()

```ts theme={null}
static bytes11(v): Typed
```

Return a new `bytes11` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                          |
| :-------- | :------------------------------------------------- | :----------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes11`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes11` type for `v`.

#### Source

[abi/typed.ts:1030](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1030)

***

### bytes12()

```ts theme={null}
static bytes12(v): Typed
```

Return a new `bytes12` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                          |
| :-------- | :------------------------------------------------- | :----------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes12`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes12` type for `v`.

#### Source

[abi/typed.ts:1040](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1040)

***

### bytes13()

```ts theme={null}
static bytes13(v): Typed
```

Return a new `bytes13` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                          |
| :-------- | :------------------------------------------------- | :----------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes13`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes13` type for `v`.

#### Source

[abi/typed.ts:1050](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1050)

***

### bytes14()

```ts theme={null}
static bytes14(v): Typed
```

Return a new `bytes14` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                          |
| :-------- | :------------------------------------------------- | :----------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes14`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes14` type for `v`.

#### Source

[abi/typed.ts:1060](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1060)

***

### bytes15()

```ts theme={null}
static bytes15(v): Typed
```

Return a new `bytes15` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                          |
| :-------- | :------------------------------------------------- | :----------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes15`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes15` type for `v`.

#### Source

[abi/typed.ts:1070](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1070)

***

### bytes16()

```ts theme={null}
static bytes16(v): Typed
```

Return a new `bytes16` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                          |
| :-------- | :------------------------------------------------- | :----------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes16`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes16` type for `v`.

#### Source

[abi/typed.ts:1080](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1080)

***

### bytes17()

```ts theme={null}
static bytes17(v): Typed
```

Return a new `bytes17` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                          |
| :-------- | :------------------------------------------------- | :----------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes17`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes17` type for `v`.

#### Source

[abi/typed.ts:1090](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1090)

***

### bytes18()

```ts theme={null}
static bytes18(v): Typed
```

Return a new `bytes18` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                          |
| :-------- | :------------------------------------------------- | :----------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes18`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes18` type for `v`.

#### Source

[abi/typed.ts:1100](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1100)

***

### bytes19()

```ts theme={null}
static bytes19(v): Typed
```

Return a new `bytes19` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                          |
| :-------- | :------------------------------------------------- | :----------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes19`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes19` type for `v`.

#### Source

[abi/typed.ts:1110](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1110)

***

### bytes2()

```ts theme={null}
static bytes2(v): Typed
```

Return a new `bytes2` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                         |
| :-------- | :------------------------------------------------- | :---------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes2`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes2` type for `v`.

#### Source

[abi/typed.ts:940](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L940)

***

### bytes20()

```ts theme={null}
static bytes20(v): Typed
```

Return a new `bytes20` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                          |
| :-------- | :------------------------------------------------- | :----------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes20`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes20` type for `v`.

#### Source

[abi/typed.ts:1120](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1120)

***

### bytes21()

```ts theme={null}
static bytes21(v): Typed
```

Return a new `bytes21` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                          |
| :-------- | :------------------------------------------------- | :----------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes21`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes21` type for `v`.

#### Source

[abi/typed.ts:1130](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1130)

***

### bytes22()

```ts theme={null}
static bytes22(v): Typed
```

Return a new `bytes22` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                          |
| :-------- | :------------------------------------------------- | :----------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes22`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes22` type for `v`.

#### Source

[abi/typed.ts:1140](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1140)

***

### bytes23()

```ts theme={null}
static bytes23(v): Typed
```

Return a new `bytes23` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                          |
| :-------- | :------------------------------------------------- | :----------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes23`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes23` type for `v`.

#### Source

[abi/typed.ts:1150](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1150)

***

### bytes24()

```ts theme={null}
static bytes24(v): Typed
```

Return a new `bytes24` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                          |
| :-------- | :------------------------------------------------- | :----------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes24`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes24` type for `v`.

#### Source

[abi/typed.ts:1160](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1160)

***

### bytes25()

```ts theme={null}
static bytes25(v): Typed
```

Return a new `bytes25` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                          |
| :-------- | :------------------------------------------------- | :----------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes25`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes25` type for `v`.

#### Source

[abi/typed.ts:1170](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1170)

***

### bytes26()

```ts theme={null}
static bytes26(v): Typed
```

Return a new `bytes26` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                          |
| :-------- | :------------------------------------------------- | :----------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes26`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes26` type for `v`.

#### Source

[abi/typed.ts:1180](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1180)

***

### bytes27()

```ts theme={null}
static bytes27(v): Typed
```

Return a new `bytes27` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                          |
| :-------- | :------------------------------------------------- | :----------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes27`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes27` type for `v`.

#### Source

[abi/typed.ts:1190](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1190)

***

### bytes28()

```ts theme={null}
static bytes28(v): Typed
```

Return a new `bytes28` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                          |
| :-------- | :------------------------------------------------- | :----------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes28`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes28` type for `v`.

#### Source

[abi/typed.ts:1200](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1200)

***

### bytes29()

```ts theme={null}
static bytes29(v): Typed
```

Return a new `bytes29` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                          |
| :-------- | :------------------------------------------------- | :----------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes29`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes29` type for `v`.

#### Source

[abi/typed.ts:1210](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1210)

***

### bytes3()

```ts theme={null}
static bytes3(v): Typed
```

Return a new `bytes3` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                         |
| :-------- | :------------------------------------------------- | :---------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes3`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes3` type for `v`.

#### Source

[abi/typed.ts:950](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L950)

***

### bytes30()

```ts theme={null}
static bytes30(v): Typed
```

Return a new `bytes30` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                          |
| :-------- | :------------------------------------------------- | :----------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes30`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes30` type for `v`.

#### Source

[abi/typed.ts:1220](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1220)

***

### bytes31()

```ts theme={null}
static bytes31(v): Typed
```

Return a new `bytes31` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                          |
| :-------- | :------------------------------------------------- | :----------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes31`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes31` type for `v`.

#### Source

[abi/typed.ts:1230](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1230)

***

### bytes32()

```ts theme={null}
static bytes32(v): Typed
```

Return a new `bytes32` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                          |
| :-------- | :------------------------------------------------- | :----------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes32`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes32` type for `v`.

#### Source

[abi/typed.ts:1240](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1240)

***

### bytes4()

```ts theme={null}
static bytes4(v): Typed
```

Return a new `bytes4` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                         |
| :-------- | :------------------------------------------------- | :---------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes4`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes4` type for `v`.

#### Source

[abi/typed.ts:960](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L960)

***

### bytes5()

```ts theme={null}
static bytes5(v): Typed
```

Return a new `bytes5` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                         |
| :-------- | :------------------------------------------------- | :---------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes5`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes5` type for `v`.

#### Source

[abi/typed.ts:970](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L970)

***

### bytes6()

```ts theme={null}
static bytes6(v): Typed
```

Return a new `bytes6` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                         |
| :-------- | :------------------------------------------------- | :---------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes6`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes6` type for `v`.

#### Source

[abi/typed.ts:980](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L980)

***

### bytes7()

```ts theme={null}
static bytes7(v): Typed
```

Return a new `bytes7` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                         |
| :-------- | :------------------------------------------------- | :---------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes7`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes7` type for `v`.

#### Source

[abi/typed.ts:990](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L990)

***

### bytes8()

```ts theme={null}
static bytes8(v): Typed
```

Return a new `bytes8` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                         |
| :-------- | :------------------------------------------------- | :---------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes8`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes8` type for `v`.

#### Source

[abi/typed.ts:1000](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1000)

***

### bytes9()

```ts theme={null}
static bytes9(v): Typed
```

Return a new `bytes9` type for `v`.

#### Parameters

| Parameter | Type                                               | Description                         |
| :-------- | :------------------------------------------------- | :---------------------------------- |
| `v`       | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a `bytes9`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `bytes9` type for `v`.

#### Source

[abi/typed.ts:1010](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1010)

***

### dereference()

```ts theme={null}
static dereference<T>(value, type): T
```

If the value is a [**Typed**](/sdk/content/classes/Typed) instance, validates the underlying value and returns it, otherwise
returns value directly.

This is useful for functions that with to accept either a [**Typed**](/sdk/content/classes/Typed) object or values.

#### Type parameters

| Type parameter |
| :------------- |
| `T`            |

#### Parameters

| Parameter | Type                                         | Description               |
| :-------- | :------------------------------------------- | :------------------------ |
| `value`   | [`Typed`](/sdk/content/classes/Typed) \| `T` | The value to dereference. |
| `type`    | `string`                                     | The dereferenced value.   |

#### Returns

`T`

#### Source

[abi/typed.ts:1337](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1337)

***

### from()

```ts theme={null}
static from(type, value): Typed
```

Returns a new **Typed** of `type` with the `value`.

#### Parameters

| Parameter | Type     | Description       |
| :-------- | :------- | :---------------- |
| `type`    | `string` | The type to use.  |
| `value`   | `any`    | The value to use. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

#### Source

[abi/typed.ts:260](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L260)

***

### int()

```ts theme={null}
static int(v): Typed
```

Return a new `int256` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int256`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int256` type for `v`.

#### Source

[abi/typed.ts:920](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L920)

***

### int104()

```ts theme={null}
static int104(v): Typed
```

Return a new `int104` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int104`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int104` type for `v`.

#### Source

[abi/typed.ts:720](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L720)

***

### int112()

```ts theme={null}
static int112(v): Typed
```

Return a new `int112` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int112`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int112` type for `v`.

#### Source

[abi/typed.ts:730](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L730)

***

### int120()

```ts theme={null}
static int120(v): Typed
```

Return a new `int120` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int120`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int120` type for `v`.

#### Source

[abi/typed.ts:740](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L740)

***

### int128()

```ts theme={null}
static int128(v): Typed
```

Return a new `int128` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int128`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int128` type for `v`.

#### Source

[abi/typed.ts:750](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L750)

***

### int136()

```ts theme={null}
static int136(v): Typed
```

Return a new `int136` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int136`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int136` type for `v`.

#### Source

[abi/typed.ts:760](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L760)

***

### int144()

```ts theme={null}
static int144(v): Typed
```

Return a new `int144` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int144`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int144` type for `v`.

#### Source

[abi/typed.ts:770](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L770)

***

### int152()

```ts theme={null}
static int152(v): Typed
```

Return a new `int152` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int152`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int152` type for `v`.

#### Source

[abi/typed.ts:780](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L780)

***

### int16()

```ts theme={null}
static int16(v): Typed
```

Return a new `int16` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                         |
| :-------- | :------------------------------------------------------- | :---------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int16`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int16` type for `v`.

#### Source

[abi/typed.ts:610](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L610)

***

### int160()

```ts theme={null}
static int160(v): Typed
```

Return a new `int160` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int160`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int160` type for `v`.

#### Source

[abi/typed.ts:790](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L790)

***

### int168()

```ts theme={null}
static int168(v): Typed
```

Return a new `int168` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int168`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int168` type for `v`.

#### Source

[abi/typed.ts:800](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L800)

***

### int176()

```ts theme={null}
static int176(v): Typed
```

Return a new `int176` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int176`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int176` type for `v`.

#### Source

[abi/typed.ts:810](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L810)

***

### int184()

```ts theme={null}
static int184(v): Typed
```

Return a new `int184` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int184`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int184` type for `v`.

#### Source

[abi/typed.ts:820](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L820)

***

### int192()

```ts theme={null}
static int192(v): Typed
```

Return a new `int192` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int192`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int192` type for `v`.

#### Source

[abi/typed.ts:830](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L830)

***

### int200()

```ts theme={null}
static int200(v): Typed
```

Return a new `int200` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int200`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int200` type for `v`.

#### Source

[abi/typed.ts:840](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L840)

***

### int208()

```ts theme={null}
static int208(v): Typed
```

Return a new `int208` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int208`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int208` type for `v`.

#### Source

[abi/typed.ts:850](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L850)

***

### int216()

```ts theme={null}
static int216(v): Typed
```

Return a new `int216` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int216`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int216` type for `v`.

#### Source

[abi/typed.ts:860](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L860)

***

### int224()

```ts theme={null}
static int224(v): Typed
```

Return a new `int224` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int224`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int224` type for `v`.

#### Source

[abi/typed.ts:870](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L870)

***

### int232()

```ts theme={null}
static int232(v): Typed
```

Return a new `int232` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int232`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int232` type for `v`.

#### Source

[abi/typed.ts:880](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L880)

***

### int24()

```ts theme={null}
static int24(v): Typed
```

Return a new `int24` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                         |
| :-------- | :------------------------------------------------------- | :---------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int24`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int24` type for `v`.

#### Source

[abi/typed.ts:620](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L620)

***

### int240()

```ts theme={null}
static int240(v): Typed
```

Return a new `int240` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int240`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int240` type for `v`.

#### Source

[abi/typed.ts:890](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L890)

***

### int248()

```ts theme={null}
static int248(v): Typed
```

Return a new `int248` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int248`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int248` type for `v`.

#### Source

[abi/typed.ts:900](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L900)

***

### int256()

```ts theme={null}
static int256(v): Typed
```

Return a new `int256` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int256`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int256` type for `v`.

#### Source

[abi/typed.ts:910](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L910)

***

### int32()

```ts theme={null}
static int32(v): Typed
```

Return a new `int32` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                         |
| :-------- | :------------------------------------------------------- | :---------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int32`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int32` type for `v`.

#### Source

[abi/typed.ts:630](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L630)

***

### int40()

```ts theme={null}
static int40(v): Typed
```

Return a new `int40` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                         |
| :-------- | :------------------------------------------------------- | :---------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int40`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int40` type for `v`.

#### Source

[abi/typed.ts:640](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L640)

***

### int48()

```ts theme={null}
static int48(v): Typed
```

Return a new `int48` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                         |
| :-------- | :------------------------------------------------------- | :---------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int48`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int48` type for `v`.

#### Source

[abi/typed.ts:650](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L650)

***

### int56()

```ts theme={null}
static int56(v): Typed
```

Return a new `int56` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                         |
| :-------- | :------------------------------------------------------- | :---------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int56`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int56` type for `v`.

#### Source

[abi/typed.ts:660](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L660)

***

### int64()

```ts theme={null}
static int64(v): Typed
```

Return a new `int64` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                         |
| :-------- | :------------------------------------------------------- | :---------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int64`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int64` type for `v`.

#### Source

[abi/typed.ts:670](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L670)

***

### int72()

```ts theme={null}
static int72(v): Typed
```

Return a new `int72` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                         |
| :-------- | :------------------------------------------------------- | :---------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int72`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int72` type for `v`.

#### Source

[abi/typed.ts:680](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L680)

***

### int8()

```ts theme={null}
static int8(v): Typed
```

Return a new `int8` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                        |
| :-------- | :------------------------------------------------------- | :--------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int8`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int8` type for `v`.

#### Source

[abi/typed.ts:600](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L600)

***

### int80()

```ts theme={null}
static int80(v): Typed
```

Return a new `int80` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                         |
| :-------- | :------------------------------------------------------- | :---------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int80`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int80` type for `v`.

#### Source

[abi/typed.ts:690](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L690)

***

### int88()

```ts theme={null}
static int88(v): Typed
```

Return a new `int88` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                         |
| :-------- | :------------------------------------------------------- | :---------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int88`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int88` type for `v`.

#### Source

[abi/typed.ts:700](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L700)

***

### int96()

```ts theme={null}
static int96(v): Typed
```

Return a new `int96` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                         |
| :-------- | :------------------------------------------------------- | :---------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to an `int96`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `int96` type for `v`.

#### Source

[abi/typed.ts:710](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L710)

***

### isTyped()

```ts theme={null}
static isTyped(value): value is Typed
```

Returns true only if `value` is a [**Typed**](/sdk/content/classes/Typed) instance.

#### Parameters

| Parameter | Type  | Description         |
| :-------- | :---- | :------------------ |
| `value`   | `any` | The value to check. |

#### Returns

`value is Typed`

True if `value` is a [**Typed**](/sdk/content/classes/Typed) instance.

#### Source

[abi/typed.ts:1324](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1324)

***

### overrides()

```ts theme={null}
static overrides(v): Typed
```

Return a new `overrides` type with the provided properties.

#### Parameters

| Parameter | Type                       | Description                                                                |
| :-------- | :------------------------- | :------------------------------------------------------------------------- |
| `v`       | `Record`\<`string`, `any`> | A record containing the properties to be included in the `overrides` type. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `overrides` type with the given properties.

#### Source

[abi/typed.ts:1314](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1314)

***

### string()

```ts theme={null}
static string(v): Typed
```

Return a new `string` type for `v`.

#### Parameters

| Parameter | Type     | Description                         |
| :-------- | :------- | :---------------------------------- |
| `v`       | `string` | The value to convert to a `string`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `string` type for `v`.

#### Source

[abi/typed.ts:1280](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1280)

***

### tuple()

```ts theme={null}
static tuple(v, name?): Typed
```

Return a new `tuple` type for v, with the optional name.

#### Parameters

| Parameter | Type                                   | Description                        |
| :-------- | :------------------------------------- | :--------------------------------- |
| `v`       | `any`\[] \| `Record`\<`string`, `any`> | The value to convert to a `tuple`. |
| `name`?   | `string`                               | The name of the tuple.             |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `tuple` type for `v`.

#### Source

[abi/typed.ts:1303](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L1303)

***

### uint()

```ts theme={null}
static uint(v): Typed
```

Return a new `uint256` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint256`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint256` type for `v`.

#### Source

[abi/typed.ts:590](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L590)

***

### uint104()

```ts theme={null}
static uint104(v): Typed
```

Return a new `uint104` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint104`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint104` type for `v`.

#### Source

[abi/typed.ts:390](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L390)

***

### uint112()

```ts theme={null}
static uint112(v): Typed
```

Return a new `uint112` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint112`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint112` type for `v`.

#### Source

[abi/typed.ts:400](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L400)

***

### uint120()

```ts theme={null}
static uint120(v): Typed
```

Return a new `uint120` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint120`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint120` type for `v`.

#### Source

[abi/typed.ts:410](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L410)

***

### uint128()

```ts theme={null}
static uint128(v): Typed
```

Return a new `uint128` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint128`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint128` type for `v`.

#### Source

[abi/typed.ts:420](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L420)

***

### uint136()

```ts theme={null}
static uint136(v): Typed
```

Return a new `uint136` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint136`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint136` type for `v`.

#### Source

[abi/typed.ts:430](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L430)

***

### uint144()

```ts theme={null}
static uint144(v): Typed
```

Return a new `uint144` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint144`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint144` type for `v`.

#### Source

[abi/typed.ts:440](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L440)

***

### uint152()

```ts theme={null}
static uint152(v): Typed
```

Return a new `uint152` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint152`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint152` type for `v`.

#### Source

[abi/typed.ts:450](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L450)

***

### uint16()

```ts theme={null}
static uint16(v): Typed
```

Return a new `uint16` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                         |
| :-------- | :------------------------------------------------------- | :---------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint16`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint16` type for `v`.

#### Source

[abi/typed.ts:280](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L280)

***

### uint160()

```ts theme={null}
static uint160(v): Typed
```

Return a new `uint160` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint160`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint160` type for `v`.

#### Source

[abi/typed.ts:460](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L460)

***

### uint168()

```ts theme={null}
static uint168(v): Typed
```

Return a new `uint168` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint168`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint168` type for `v`.

#### Source

[abi/typed.ts:470](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L470)

***

### uint176()

```ts theme={null}
static uint176(v): Typed
```

Return a new `uint176` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint176`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint176` type for `v`.

#### Source

[abi/typed.ts:480](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L480)

***

### uint184()

```ts theme={null}
static uint184(v): Typed
```

Return a new `uint184` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint184`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint184` type for `v`.

#### Source

[abi/typed.ts:490](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L490)

***

### uint192()

```ts theme={null}
static uint192(v): Typed
```

Return a new `uint192` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint192`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint192` type for `v`.

#### Source

[abi/typed.ts:500](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L500)

***

### uint200()

```ts theme={null}
static uint200(v): Typed
```

Return a new `uint200` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint200`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint200` type for `v`.

#### Source

[abi/typed.ts:510](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L510)

***

### uint208()

```ts theme={null}
static uint208(v): Typed
```

Return a new `uint208` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint208`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint208` type for `v`.

#### Source

[abi/typed.ts:520](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L520)

***

### uint216()

```ts theme={null}
static uint216(v): Typed
```

Return a new `uint216` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint216`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint216` type for `v`.

#### Source

[abi/typed.ts:530](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L530)

***

### uint224()

```ts theme={null}
static uint224(v): Typed
```

Return a new `uint224` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint224`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint224` type for `v`.

#### Source

[abi/typed.ts:540](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L540)

***

### uint232()

```ts theme={null}
static uint232(v): Typed
```

Return a new `uint232` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint232`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint232` type for `v`.

#### Source

[abi/typed.ts:550](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L550)

***

### uint24()

```ts theme={null}
static uint24(v): Typed
```

Return a new `uint24` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                         |
| :-------- | :------------------------------------------------------- | :---------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint24`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint24` type for `v`.

#### Source

[abi/typed.ts:290](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L290)

***

### uint240()

```ts theme={null}
static uint240(v): Typed
```

Return a new `uint240` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint240`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint240` type for `v`.

#### Source

[abi/typed.ts:560](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L560)

***

### uint248()

```ts theme={null}
static uint248(v): Typed
```

Return a new `uint248` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint248`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint248` type for `v`.

#### Source

[abi/typed.ts:570](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L570)

***

### uint256()

```ts theme={null}
static uint256(v): Typed
```

Return a new `uint256` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                          |
| :-------- | :------------------------------------------------------- | :----------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint256`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint256` type for `v`.

#### Source

[abi/typed.ts:580](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L580)

***

### uint32()

```ts theme={null}
static uint32(v): Typed
```

Return a new `uint32` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                         |
| :-------- | :------------------------------------------------------- | :---------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint32`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint32` type for `v`.

#### Source

[abi/typed.ts:300](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L300)

***

### uint40()

```ts theme={null}
static uint40(v): Typed
```

Return a new `uint40` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                         |
| :-------- | :------------------------------------------------------- | :---------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint40`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint40` type for `v`.

#### Source

[abi/typed.ts:310](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L310)

***

### uint48()

```ts theme={null}
static uint48(v): Typed
```

Return a new `uint48` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                         |
| :-------- | :------------------------------------------------------- | :---------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint48`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint48` type for `v`.

#### Source

[abi/typed.ts:320](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L320)

***

### uint56()

```ts theme={null}
static uint56(v): Typed
```

Return a new `uint56` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                         |
| :-------- | :------------------------------------------------------- | :---------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint56`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint56` type for `v`.

#### Source

[abi/typed.ts:330](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L330)

***

### uint64()

```ts theme={null}
static uint64(v): Typed
```

Return a new `uint64` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                         |
| :-------- | :------------------------------------------------------- | :---------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint64`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint64` type for `v`.

#### Source

[abi/typed.ts:340](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L340)

***

### uint72()

```ts theme={null}
static uint72(v): Typed
```

Return a new `uint72` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                         |
| :-------- | :------------------------------------------------------- | :---------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint72`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint72` type for `v`.

#### Source

[abi/typed.ts:350](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L350)

***

### uint8()

```ts theme={null}
static uint8(v): Typed
```

Return a new `uint8` type for v.

#### Parameters

| Parameter | Type                                                     | Description                        |
| :-------- | :------------------------------------------------------- | :--------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint8`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint8` type for `v`.

#### Source

[abi/typed.ts:270](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L270)

***

### uint80()

```ts theme={null}
static uint80(v): Typed
```

Return a new `uint80` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                         |
| :-------- | :------------------------------------------------------- | :---------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint80`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint80` type for `v`.

#### Source

[abi/typed.ts:360](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L360)

***

### uint88()

```ts theme={null}
static uint88(v): Typed
```

Return a new `uint88` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                         |
| :-------- | :------------------------------------------------------- | :---------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint88`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint88` type for `v`.

#### Source

[abi/typed.ts:370](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L370)

***

### uint96()

```ts theme={null}
static uint96(v): Typed
```

Return a new `uint96` type for `v`.

#### Parameters

| Parameter | Type                                                     | Description                         |
| :-------- | :------------------------------------------------------- | :---------------------------------- |
| `v`       | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert to a `uint96`. |

#### Returns

[`Typed`](/sdk/content/classes/Typed)

A new `uint96` type for `v`.

#### Source

[abi/typed.ts:380](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/typed.ts#L380)


# UndecodedEventLog
Source: https://docs.qu.ai/sdk/content/classes/UndecodedEventLog



An **EventLog** contains additional properties parsed from the [**Log**](/sdk/content/classes/Log).

## Extends

* [`Log`](/sdk/content/classes/Log)

## Properties

| Property           | Modifier   | Type                                           | Description                                                                                                                                                                                                                                                                 | Inherited from                                       |
| :----------------- | :--------- | :--------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------- |
| `address`          | `readonly` | `string`                                       | The address of the contract that emitted this log.                                                                                                                                                                                                                          | [`Log`](/sdk/content/classes/Log).`address`          |
| `blockHash`        | `readonly` | `string`                                       | The block hash of the block this log occurred in. Use the [**Log.getBlock**](/sdk/content/classes/Log#getblock) to get the<br />[**Block**](/sdk/content/classes/Block).                                                                                                    | [`Log`](/sdk/content/classes/Log).`blockHash`        |
| `blockNumber`      | `readonly` | `number`                                       | The block number of the block this log occurred in. It is preferred to use the Block.hash \| **Block.hash**<br />when fetching the related [**Block**](/sdk/content/classes/Block), since in the case of an orphaned block, the block at that<br />height may have changed. | [`Log`](/sdk/content/classes/Log).`blockNumber`      |
| `data`             | `readonly` | `string`                                       | The data included in this log when it was emitted.                                                                                                                                                                                                                          | [`Log`](/sdk/content/classes/Log).`data`             |
| `error`            | `readonly` | `Error`                                        | The error encounted when trying to decode the log.                                                                                                                                                                                                                          | -                                                    |
| `index`            | `readonly` | `number`                                       | The index within the block this log occurred at. This is generally not useful to developers, but can be used with<br />the various roots to proof inclusion within a block.                                                                                                 | [`Log`](/sdk/content/classes/Log).`index`            |
| `provider`         | `readonly` | [`Provider`](/sdk/content/interfaces/Provider) | The provider connected to the log used to fetch additional details if necessary.                                                                                                                                                                                            | [`Log`](/sdk/content/classes/Log).`provider`         |
| `removed`          | `readonly` | `boolean`                                      | If the **Log** represents a block that was removed due to an orphaned block, this will be true.<br /><br />This can only happen within an orphan event listener.                                                                                                            | [`Log`](/sdk/content/classes/Log).`removed`          |
| `topics`           | `readonly` | readonly `string`\[]                           | The indexed topics included in this log when it was emitted.<br /><br />All topics are included in the bloom filters, so they can be efficiently filtered using the<br />[**Provider.getLogs**](/sdk/content/interfaces/Provider#getlogs) method.                           | [`Log`](/sdk/content/classes/Log).`topics`           |
| `transactionHash`  | `readonly` | `string`                                       | The transaction hash of the transaction this log occurred in. Use the<br />[**Log.getTransaction**](/sdk/content/classes/Log#gettransaction) to get the<br />[\*\*TransactionResponse](/sdk/content/type-aliases/TransactionResponse).                                      | [`Log`](/sdk/content/classes/Log).`transactionHash`  |
| `transactionIndex` | `readonly` | `number`                                       | The index within the transaction of this log.                                                                                                                                                                                                                               | [`Log`](/sdk/content/classes/Log).`transactionIndex` |

## Methods

### getBlock()

```ts theme={null}
getBlock(shard): Promise<Block>
```

Returns the block that this log occurred in.

#### Parameters

| Parameter | Type                                       | Description                        |
| :-------- | :----------------------------------------- | :--------------------------------- |
| `shard`   | [`Shard`](/sdk/content/enumerations/Shard) | The shard to fetch the block from. |

#### Returns

`Promise`\<[`Block`](/sdk/content/classes/Block)>

A promise resolving to the block.

#### Inherited from

[`Log`](/sdk/content/classes/Log).[`getBlock`](/sdk/content/classes/Log#getblock)

#### Source

[providers/provider.ts:1089](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1089)

***

### getTransaction()

```ts theme={null}
getTransaction(): Promise<TransactionResponse>
```

Returns the transaction that this log occurred in.

#### Returns

`Promise`\<[`TransactionResponse`](/sdk/content/type-aliases/TransactionResponse)>

A promise resolving to the transaction.

#### Inherited from

[`Log`](/sdk/content/classes/Log).[`getTransaction`](/sdk/content/classes/Log#gettransaction)

#### Source

[providers/provider.ts:1100](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1100)

***

### getTransactionReceipt()

```ts theme={null}
getTransactionReceipt(): Promise<TransactionReceipt>
```

Returns the transaction receipt fot the transaction that this log occurred in.

#### Returns

`Promise`\<[`TransactionReceipt`](/sdk/content/classes/TransactionReceipt)>

A promise resolving to the transaction receipt.

#### Inherited from

[`Log`](/sdk/content/classes/Log).[`getTransactionReceipt`](/sdk/content/classes/Log#gettransactionreceipt)

#### Source

[providers/provider.ts:1111](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1111)

***

### toJSON()

```ts theme={null}
toJSON(): any
```

Returns a JSON-compatible object.

#### Returns

`any`

#### Inherited from

[`Log`](/sdk/content/classes/Log).[`toJSON`](/sdk/content/classes/Log#tojson)

#### Source

[providers/provider.ts:1065](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1065)


# Shard
Source: https://docs.qu.ai/sdk/content/enumerations/Shard



A shard represents a chain within the Quai network hierarchy. A shard refer to the Prime chain, a region under the
Prime chain, or a Zone within a region. The value is a hexadecimal string representing the encoded value of the
shard. Read more [here](https://github.com/quai-network/qips/blob/master/qip-0002.md).

## Enumeration Members

### Cyprus

```ts theme={null}
Cyprus: "0x0";
```

#### Source

[constants/shards.ts:11](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/constants/shards.ts#L11)

***

### Cyprus1

```ts theme={null}
Cyprus1: "0x00";
```

#### Source

[constants/shards.ts:12](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/constants/shards.ts#L12)

***

### Cyprus2

```ts theme={null}
Cyprus2: "0x01";
```

#### Source

[constants/shards.ts:13](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/constants/shards.ts#L13)

***

### Cyprus3

```ts theme={null}
Cyprus3: "0x02";
```

#### Source

[constants/shards.ts:14](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/constants/shards.ts#L14)

***

### Hydra

```ts theme={null}
Hydra: "0x2";
```

#### Source

[constants/shards.ts:19](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/constants/shards.ts#L19)

***

### Hydra1

```ts theme={null}
Hydra1: "0x20";
```

#### Source

[constants/shards.ts:20](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/constants/shards.ts#L20)

***

### Hydra2

```ts theme={null}
Hydra2: "0x21";
```

#### Source

[constants/shards.ts:21](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/constants/shards.ts#L21)

***

### Hydra3

```ts theme={null}
Hydra3: "0x22";
```

#### Source

[constants/shards.ts:22](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/constants/shards.ts#L22)

***

### Paxos

```ts theme={null}
Paxos: "0x1";
```

#### Source

[constants/shards.ts:15](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/constants/shards.ts#L15)

***

### Paxos1

```ts theme={null}
Paxos1: "0x10";
```

#### Source

[constants/shards.ts:16](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/constants/shards.ts#L16)

***

### Paxos2

```ts theme={null}
Paxos2: "0x11";
```

#### Source

[constants/shards.ts:17](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/constants/shards.ts#L17)

***

### Paxos3

```ts theme={null}
Paxos3: "0x12";
```

#### Source

[constants/shards.ts:18](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/constants/shards.ts#L18)

***

### Prime

```ts theme={null}
Prime: "0x";
```

#### Source

[constants/shards.ts:23](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/constants/shards.ts#L23)


# Zone
Source: https://docs.qu.ai/sdk/content/enumerations/Zone



A zone is the lowest level shard within the Quai network hierarchy. Zones are the only shards in the network that
accept user transactions. The value is a hexadecimal string representing the encoded value of the zone. Read more
[here](https://github.com/quai-network/qips/blob/master/qip-0002.md).

## Enumeration Members

### Cyprus1

```ts theme={null}
Cyprus1: "0x00";
```

#### Source

[constants/zones.ts:9](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/constants/zones.ts#L9)

***

### Cyprus2

```ts theme={null}
Cyprus2: "0x01";
```

#### Source

[constants/zones.ts:10](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/constants/zones.ts#L10)

***

### Cyprus3

```ts theme={null}
Cyprus3: "0x02";
```

#### Source

[constants/zones.ts:11](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/constants/zones.ts#L11)

***

### Hydra1

```ts theme={null}
Hydra1: "0x20";
```

#### Source

[constants/zones.ts:15](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/constants/zones.ts#L15)

***

### Hydra2

```ts theme={null}
Hydra2: "0x21";
```

#### Source

[constants/zones.ts:16](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/constants/zones.ts#L16)

***

### Hydra3

```ts theme={null}
Hydra3: "0x22";
```

#### Source

[constants/zones.ts:17](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/constants/zones.ts#L17)

***

### Paxos1

```ts theme={null}
Paxos1: "0x10";
```

#### Source

[constants/zones.ts:12](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/constants/zones.ts#L12)

***

### Paxos2

```ts theme={null}
Paxos2: "0x11";
```

#### Source

[constants/zones.ts:13](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/constants/zones.ts#L13)

***

### Paxos3

```ts theme={null}
Paxos3: "0x12";
```

#### Source

[constants/zones.ts:14](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/constants/zones.ts#L14)


# checkResultErrors
Source: https://docs.qu.ai/sdk/content/functions/checkResultErrors



```ts theme={null}
function checkResultErrors(result): {
  "error": Error;
  "path": (string | number)[];
 }[]
```

Returns all errors found in a [**Result**](/sdk/content/classes/Result).

Since certain errors encountered when creating a [**Result**](/sdk/content/classes/Result) do not impact the ability to continue
parsing data, they are deferred until they are actually accessed. Hence a faulty string in an Event that is never
used does not impact the program flow.

However, sometimes it may be useful to access, identify or validate correctness of a [**Result**](/sdk/content/classes/Result).

## Parameters

| Parameter | Type                                    | Description                     |
| :-------- | :-------------------------------------- | :------------------------------ |
| `result`  | [`Result`](/sdk/content/classes/Result) | The Result to check for errors. |

## Returns

\{
`"error"`: `Error`;
`"path"`: (`string` | `number`)\[];
}\[]

An array of objects with the path to the error and the error itself.

## Source

[abi/coders/abstract-coder.ts:313](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/coders/abstract-coder.ts#L313)


# computeAddress
Source: https://docs.qu.ai/sdk/content/functions/computeAddress



```ts theme={null}
function computeAddress(key): string
```

Returns the address for the `key`.

The key may be any standard form of public key or a private key.

## Parameters

| Parameter | Type                                                        | Description                         |
| :-------- | :---------------------------------------------------------- | :---------------------------------- |
| `key`     | `string` \| [`SigningKey`](/sdk/content/classes/SigningKey) | The key to compute the address for. |

## Returns

`string`

The address.

## Source

[address/address.ts:107](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/address/address.ts#L107)


# computeHmac
Source: https://docs.qu.ai/sdk/content/functions/computeHmac



```ts theme={null}
function computeHmac(
   algorithm, 
   _key, 
   _data): string
```

Return the HMAC for `data` using the `key` key with the underlying `algo` used for compression.

## Parameters

| Parameter   | Type                                               | Description                           |
| :---------- | :------------------------------------------------- | :------------------------------------ |
| `algorithm` | `"sha256"` \| `"sha512"`                           | The algorithm to use for compression. |
| `_key`      | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The key to use for the HMAC.          |
| `_data`     | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The data to authenticate.             |

## Returns

`string`

The HMAC of the data.

## Example

```js theme={null}
key = id('some-secret');

// Compute the HMAC
computeHmac('sha256', key, '0x1337');

// To compute the HMAC of UTF-8 data, the data must be
// converted to UTF-8 bytes
computeHmac('sha256', key, toUtf8Bytes('Hello World'));
```

## Source

[crypto/hmac.ts:41](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/hmac.ts#L41)


# decodeBase58
Source: https://docs.qu.ai/sdk/content/functions/decodeBase58



```ts theme={null}
function decodeBase58(value): bigint
```

Decode the Base58-encoded `value`.

## Parameters

| Parameter | Type     | Description               |
| :-------- | :------- | :------------------------ |
| `value`   | `string` | The Base58-encoded value. |

## Returns

`bigint`

The decoded value.

## Source

[encoding/base58.ts:70](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/encoding/base58.ts#L70)


# decodeBase64
Source: https://docs.qu.ai/sdk/content/functions/decodeBase64



```ts theme={null}
function decodeBase64(value): Uint8Array
```

Decodes the base-64 encoded `value`.

## Parameters

| Parameter | Type     | Description                |
| :-------- | :------- | :------------------------- |
| `value`   | `string` | The base-64 encoded value. |

## Returns

`Uint8Array`

The decoded binary data.

## Example

```ts theme={null}
// The decoded value is always binary data...
result = decodeBase64('SGVsbG8gV29ybGQhIQ==');

// ...use toUtf8String to convert it to a string.
toUtf8String(result);

// Decoding binary data
decodeBase64('EjQ=');
```

## Source

[encoding/base64.ts:30](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/encoding/base64.ts#L30)


# decodeBytes32
Source: https://docs.qu.ai/sdk/content/functions/decodeBytes32



```ts theme={null}
function decodeBytes32(_bytes): string
```

Decodes a Bytes32-encoded string into a regular string. This is used to decode ABI-encoded data.

## Parameters

| Parameter | Type                                               | Description               |
| :-------- | :------------------------------------------------- | :------------------------ |
| `_bytes`  | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The Bytes32-encoded data. |

## Returns

`string`

The decoded string.

## Throws

If the input is not exactly 32 bytes long or lacks a null terminator.

## Source

[encoding/bytes32.ts:41](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/encoding/bytes32.ts#L41)


# encodeBase58
Source: https://docs.qu.ai/sdk/content/functions/encodeBase58



```ts theme={null}
function encodeBase58(_value): string
```

Encode `value` as a Base58-encoded string.

## Parameters

| Parameter | Type                                               | Description          |
| :-------- | :------------------------------------------------- | :------------------- |
| `_value`  | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to encode. |

## Returns

`string`

The Base58-encoded string.

## Source

[encoding/base58.ts:42](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/encoding/base58.ts#L42)


# encodeBase64
Source: https://docs.qu.ai/sdk/content/functions/encodeBase64



```ts theme={null}
function encodeBase64(data): string
```

Encodes `data` as a base-64 encoded string.

## Parameters

| Parameter | Type                                               | Description         |
| :-------- | :------------------------------------------------- | :------------------ |
| `data`    | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The data to encode. |

## Returns

`string`

The base-64 encoded string.

## Example

```ts theme={null}
// Encoding binary data as a hexstring
encodeBase64('0x1234');

// Encoding binary data as a Uint8Array
encodeBase64(new Uint8Array([0x12, 0x34]));

// The input MUST be data...
encodeBase64('Hello World!!');

// ...use toUtf8Bytes for this.
encodeBase64(toUtf8Bytes('Hello World!!'));
```

## Source

[encoding/base64.ts:57](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/encoding/base64.ts#L57)


# getAddress
Source: https://docs.qu.ai/sdk/content/functions/getAddress



```ts theme={null}
function getAddress(address): string
```

Returns a normalized and checksumed address for `address`. This accepts non-checksum addressesa and checksum
addresses.

The checksum in Quai uses the capitalization (upper-case vs lower-case) of the characters within an address to encode
its checksum, which offers, on average, a checksum of 15-bits.

If `address` contains both upper-case and lower-case, it is assumed to already be a checksum address and its checksum
is validated, and if the address fails its expected checksum an error is thrown.

If you wish the checksum of `address` to be ignore, it should be converted to lower-case (i.e. `.toLowercase()`)
before being passed in. This should be a very rare situation though, that you wish to bypass the safeguards in place
to protect against an address that has been incorrectly copied from another source.

## Parameters

| Parameter | Type     |
| :-------- | :------- |
| `address` | `string` |

## Returns

`string`

## Example

```js theme={null}
// Adds the checksum (via upper-casing specific letters)
getAddress('0x8ba1f109551bd432803012645ac136ddd64dba72');

// Throws an error if an address contains mixed case,
// but the checksum fails
getAddress('0x8Ba1f109551bD432803012645Ac136ddd64DBA72');
```

## Source

[address/address.ts:67](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/address/address.ts#L67)


# getCreate2Address
Source: https://docs.qu.ai/sdk/content/functions/getCreate2Address



```ts theme={null}
function getCreate2Address(
   _from, 
   _salt, 
   _initCodeHash): string
```

Returns the address that would result from a `CREATE2` operation with the given `from`, `salt` and `initCodeHash`.

To compute the `initCodeHash` from a contract's init code, use the [**keccak256**](../functions/keccak256) function.

For a quick overview and example of `CREATE2`, see [Wisps: The Magical World of
Create2](https://blog.ricmoo.com/wisps-the-magical-world-of-create2-5c2177027604).

## Parameters

| Parameter       | Type                                               | Description                |
| :-------------- | :------------------------------------------------- | :------------------------- |
| `_from`         | `string`                                           | The address of the sender. |
| `_salt`         | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The salt value.            |
| `_initCodeHash` | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The hash of the init code. |

## Returns

`string`

The computed address.

## Example

```js theme={null}
// The address of the contract
from = '0x8ba1f109551bD432803012645Ac136ddd64DBA72';

// The salt
salt = id('HelloWorld');

// The hash of the initCode
initCode = '0x6394198df16000526103ff60206004601c335afa6040516060f3';
initCodeHash = keccak256(initCode);

getCreate2Address(from, salt, initCodeHash);
```

## Throws

If the salt is not exactly 32 bytes long.

## Throws

If the initCodeHash is not exactly 32 bytes long.

## Source

[address/contract-address.ts:79](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/address/contract-address.ts#L79)


# getCreateAddress
Source: https://docs.qu.ai/sdk/content/functions/getCreateAddress



```ts theme={null}
function getCreateAddress(tx): string
```

Returns the address that would result from a `CREATE` for `tx`.

This can be used to compute the address a contract will be deployed to by an EOA when sending a deployment
transaction (i.e. when the `to` address is `null`).

This can also be used to compute the address a contract will be deployed to by a contract, by using the contract's
address as the `to` and the contract's nonce.

## Parameters

| Parameter  | Type                                                     | Description                  |
| :--------- | :------------------------------------------------------- | :--------------------------- |
| `tx`       | `object`                                                 | The transaction object.      |
| `tx.data`  | `null` \| `string`                                       | The data of the transaction. |
| `tx.from`  | `string`                                                 | The address of the sender.   |
| `tx.nonce` | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The nonce of the sender.     |

## Returns

`string`

## Example

```js theme={null}
from = '0x8ba1f109551bD432803012645Ac136ddd64DBA72';
nonce = 5;

getCreateAddress({ from, nonce });
```

## Source

[address/contract-address.ts:34](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/address/contract-address.ts#L34)


# isAddress
Source: https://docs.qu.ai/sdk/content/functions/isAddress



```ts theme={null}
function isAddress(value): value is string
```

Returns true if `value` is a valid address.

## Parameters

| Parameter | Type  | Description         |
| :-------- | :---- | :------------------ |
| `value`   | `any` | The value to check. |

## Returns

`value is string`

True if the value is a valid address.

## Example

```js theme={null}
// Valid address
isAddress('0x8ba1f109551bD432803012645Ac136ddd64DBA72');

// Invalid checksum
isAddress('0x8Ba1f109551bD432803012645Ac136ddd64DBa72');
```

## Source

[address/checks.ts:46](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/address/checks.ts#L46)


# isAddressable
Source: https://docs.qu.ai/sdk/content/functions/isAddressable



```ts theme={null}
function isAddressable(value): value is Addressable
```

Returns true if `value` is an object which implements the [**Addressable**](../interfaces/Addressable) interface.

## Parameters

| Parameter | Type  | Description         |
| :-------- | :---- | :------------------ |
| `value`   | `any` | The value to check. |

## Returns

`value is Addressable`

True if the value is an Addressable.

## Example

```js theme={null}
// Wallets and AbstractSigner sub-classes
isAddressable(Wallet.createRandom());

// Contracts
contract = new Contract('0x643aA0A61eADCC9Cc202D1915D942d35D005400C', [], provider);
isAddressable(contract);
```

## Source

[address/checks.ts:25](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/address/checks.ts#L25)


# isQiAddress
Source: https://docs.qu.ai/sdk/content/functions/isQiAddress



```ts theme={null}
function isQiAddress(address): boolean
```

Checks whether a given address is in the Qi ledger scope by checking the 9th bit of the address.

## Parameters

| Parameter | Type     | Description          |
| :-------- | :------- | :------------------- |
| `address` | `string` | The address to check |

## Returns

`boolean`

True if the address is in the Qi ledger scope, false otherwise.

## Source

[address/checks.ts:126](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/address/checks.ts#L126)


# isQuaiAddress
Source: https://docs.qu.ai/sdk/content/functions/isQuaiAddress



```ts theme={null}
function isQuaiAddress(address): boolean
```

Checks whether a given address is in the Quai ledger scope by checking the 9th bit of the address.

## Parameters

| Parameter | Type     | Description          |
| :-------- | :------- | :------------------- |
| `address` | `string` | The address to check |

## Returns

`boolean`

True if the address is in the Quai ledger scope, false otherwise.

## Source

[address/checks.ts:141](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/address/checks.ts#L141)


# keccak256
Source: https://docs.qu.ai/sdk/content/functions/keccak256



```ts theme={null}
function keccak256(_data): string
```

Compute the cryptographic KECCAK256 hash of `data`.

The `data` **must** be a data representation, to compute the hash of UTF-8 data use the \[**id**}(../functions/id)
function.

## Parameters

| Parameter | Type                                               | Description       |
| :-------- | :------------------------------------------------- | :---------------- |
| `_data`   | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The data to hash. |

## Returns

`string`

DataHexstring

The hash of the data.

## Example

```ts theme={null}
keccak256('0x');

keccak256('0x1337');

keccak256(new Uint8Array([0x13, 0x37]));

// Strings are assumed to be DataHexString, otherwise it will
// throw. To hash UTF-8 data, see the note above.
keccak256('Hello World');
```

## Source

[crypto/keccak.ts:44](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/keccak.ts#L44)


# lock
Source: https://docs.qu.ai/sdk/content/functions/lock



```ts theme={null}
function lock(): void
```

Once called, prevents any future change to the underlying cryptographic primitives using the `.register` feature for
hooks.

## Returns

`void`

## Source

[crypto/index.ts:27](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/index.ts#L27)


# pbkdf2
Source: https://docs.qu.ai/sdk/content/functions/pbkdf2



```ts theme={null}
function pbkdf2(
   _password, 
   _salt, 
   iterations, 
   keylen, 
   algo): string
```

Return the [PBKDF2](https://en.wikipedia.org/wiki/PBKDF2) for `keylen` bytes for `password` using the `salt` and
using `iterations` of `algo`.

This PBKDF is outdated and should not be used in new projects, but is required to decrypt older files.

## Parameters

| Parameter    | Type                                               | Description                        |
| :----------- | :------------------------------------------------- | :--------------------------------- |
| `_password`  | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The password to use.               |
| `_salt`      | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The salt to use.                   |
| `iterations` | `number`                                           | The number of iterations to use.   |
| `keylen`     | `number`                                           | The length of the key to generate. |
| `algo`       | `"sha256"` \| `"sha512"`                           | The algorithm to use.              |

## Returns

`string`

The key derived from the password.

## Example

```ts theme={null}
// The password must be converted to bytes, and it is generally
// best practices to ensure the string has been normalized. Many
// formats explicitly indicate the normalization form to use.
password = 'hello';
passwordBytes = toUtf8Bytes(password, 'NFKC');

salt = id('some-salt');

// Compute the PBKDF2
pbkdf2(passwordBytes, salt, 1024, 16, 'sha256');
```

## Source

[crypto/pbkdf2.ts:55](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/pbkdf2.ts#L55)


# randomBytes
Source: https://docs.qu.ai/sdk/content/functions/randomBytes



```ts theme={null}
function randomBytes(length): Uint8Array
```

Return `length` bytes of cryptographically secure random data.

## Parameters

| Parameter | Type     | Description                      |
| :-------- | :------- | :------------------------------- |
| `length`  | `number` | The number of bytes to generate. |

## Returns

`Uint8Array`

The random bytes.

## Example

```ts theme={null}
randomBytes(8);
```

## Source

[crypto/random.ts:29](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/random.ts#L29)


# recoverAddress
Source: https://docs.qu.ai/sdk/content/functions/recoverAddress



```ts theme={null}
function recoverAddress(digest, signature): string
```

Returns the recovered address for the private key that was used to sign `digest` that resulted in `signature`.

## Parameters

| Parameter   | Type                                                       | Description                |
| :---------- | :--------------------------------------------------------- | :------------------------- |
| `digest`    | [`BytesLike`](/sdk/content/type-aliases/BytesLike)         | The digest of the message. |
| `signature` | [`SignatureLike`](/sdk/content/type-aliases/SignatureLike) | The signature.             |

## Returns

`string`

The address.

## Source

[address/address.ts:125](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/address/address.ts#L125)


# resolveAddress
Source: https://docs.qu.ai/sdk/content/functions/resolveAddress



```ts theme={null}
function resolveAddress(target): string | Promise<string>
```

Resolves to an address for the `target`, which may be any supported address type, an
[**Addressable**](../interfaces/Addressable) or a Promise which resolves to an address.

## Parameters

| Parameter | Type                                                   | Description                          |
| :-------- | :----------------------------------------------------- | :----------------------------------- |
| `target`  | [`AddressLike`](/sdk/content/type-aliases/AddressLike) | The target to resolve to an address. |

## Returns

`string` | `Promise`\<`string`>

The resolved address.

## Example

```js theme={null}
addr = '0x6B175474E89094C44Da98b954EedeAC495271d0F';

// Addresses are return synchronously
resolveAddress(addr, provider);

// Address promises are resolved asynchronously
resolveAddress(Promise.resolve(addr));

// Addressable objects are resolved asynchronously
contract = new Contract(addr, []);
resolveAddress(contract, provider);
```

## Source

[address/checks.ts:87](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/address/checks.ts#L87)


# ripemd160
Source: https://docs.qu.ai/sdk/content/functions/ripemd160



```ts theme={null}
function ripemd160(_data): string
```

Compute the cryptographic RIPEMD-160 hash of `data`.

## Parameters

| Parameter | Type                                               | Description       |
| :-------- | :------------------------------------------------- | :---------------- |
| `_data`   | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The data to hash. |

## Returns

`string`

DataHexstring

The hash of the data.

## Example

```ts theme={null}
ripemd160('0x');

ripemd160('0x1337');

ripemd160(new Uint8Array([0x13, 0x37]));
```

## Source

[crypto/ripemd160.ts:33](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/ripemd160.ts#L33)


# scrypt
Source: https://docs.qu.ai/sdk/content/functions/scrypt



```ts theme={null}
function scrypt(
   _passwd, 
   _salt, 
   N, 
   r, 
   p, 
   dkLen, 
progress?): Promise<string>
```

The [scrypt PBKDF](https://en.wikipedia.org/wiki/Scrypt) uses a memory and cpu hard method of derivation to increase
the resource cost to brute-force a password for a given key.

This means this algorithm is intentionally slow, and can be tuned to become slower. As computation and memory speed
improve over time, increasing the difficulty maintains the cost of an attacker.

For example, if a target time of 5 seconds is used, a legitimate user which knows their password requires only 5
seconds to unlock their account. A 6 character password has 68 billion possibilities, which would require an attacker
to invest over 10,000 years of CPU time. This is of course a crude example (as password generally aren't random), but
demonstrates to value of imposing large costs to decryption.

For this reason, if building a UI which involved decrypting or encrypting datsa using scrypt, it is recommended to
use a [**ProgressCallback**](../types-aliases/ProgressCallback) (as event short periods can seem lik an eternity if
the UI freezes). Including the phrase //"decrypting"// in the UI can also help, assuring the user their waiting is
for a good reason.

## Parameters

| Parameter   | Type                                                             | Description                        |
| :---------- | :--------------------------------------------------------------- | :--------------------------------- |
| `_passwd`   | [`BytesLike`](/sdk/content/type-aliases/BytesLike)               | The password to use.               |
| `_salt`     | [`BytesLike`](/sdk/content/type-aliases/BytesLike)               | The salt to use.                   |
| `N`         | `number`                                                         | The CPU/memory cost parameter.     |
| `r`         | `number`                                                         | The block size parameter.          |
| `p`         | `number`                                                         | The parallelization parameter.     |
| `dkLen`     | `number`                                                         | The length of the key to generate. |
| `progress`? | [`ProgressCallback`](/sdk/content/type-aliases/ProgressCallback) | A callback to update the progress. |

## Returns

`Promise`\<`string`>

The key derived from the password.

## Example

```ts theme={null}
// The password must be converted to bytes, and it is generally
// best practices to ensure the string has been normalized. Many
// formats explicitly indicate the normalization form to use.
password = 'hello';
passwordBytes = toUtf8Bytes(password, 'NFKC');

salt = id('some-salt');

// Compute the scrypt
scrypt(passwordBytes, salt, 1024, 8, 1, 16);
```

## Source

[crypto/scrypt.ts:88](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/scrypt.ts#L88)


# scryptSync
Source: https://docs.qu.ai/sdk/content/functions/scryptSync



```ts theme={null}
function scryptSync(
   _passwd, 
   _salt, 
   N, 
   r, 
   p, 
   dkLen): string
```

Provides a synchronous variant of [**scrypt**](/sdk/content/functions/scrypt).

This will completely lock up and freeze the UI in a browser and will prevent any event loop from progressing. For
this reason, it is preferred to use the [async variant](scrypt).

## Parameters

| Parameter | Type                                               | Description                        |
| :-------- | :------------------------------------------------- | :--------------------------------- |
| `_passwd` | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The password to use.               |
| `_salt`   | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The salt to use.                   |
| `N`       | `number`                                           | The CPU/memory cost parameter.     |
| `r`       | `number`                                           | The block size parameter.          |
| `p`       | `number`                                           | The parallelization parameter.     |
| `dkLen`   | `number`                                           | The length of the key to generate. |

## Returns

`string`

The key derived from the password.

## Example

```ts theme={null}
// The password must be converted to bytes, and it is generally
// best practices to ensure the string has been normalized. Many
// formats explicitly indicate the normalization form to use.
password = 'hello';
passwordBytes = toUtf8Bytes(password, 'NFKC');

salt = id('some-salt');

// Compute the scrypt
scryptSync(passwordBytes, salt, 1024, 8, 1, 16);
```

## Source

[crypto/scrypt.ts:153](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/scrypt.ts#L153)


# sha256
Source: https://docs.qu.ai/sdk/content/functions/sha256



```ts theme={null}
function sha256(_data): string
```

Compute the cryptographic SHA2-256 hash of `data`.

## Parameters

| Parameter | Type                                               | Description       |
| :-------- | :------------------------------------------------- | :---------------- |
| `_data`   | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The data to hash. |

## Returns

`string`

The hash of the data.

## Example

```ts theme={null}
sha256('0x');

sha256('0x1337');

sha256(new Uint8Array([0x13, 0x37]));
```

## Source

[crypto/sha2.ts:38](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/sha2.ts#L38)


# sha512
Source: https://docs.qu.ai/sdk/content/functions/sha512



```ts theme={null}
function sha512(_data): string
```

Compute the cryptographic SHA2-512 hash of `data`.

## Parameters

| Parameter | Type                                               | Description       |
| :-------- | :------------------------------------------------- | :---------------- |
| `_data`   | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The data to hash. |

## Returns

`string`

The hash of the data.

## Example

```ts theme={null}
sha512('0x');

sha512('0x1337');

sha512(new Uint8Array([0x13, 0x37]));
```

## Source

[crypto/sha2.ts:71](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/sha2.ts#L71)


# validateAddress
Source: https://docs.qu.ai/sdk/content/functions/validateAddress



```ts theme={null}
function validateAddress(address): void
```

Checks if the address is a valid mixed case checksummed address.

## Parameters

| Parameter | Type     | Description              |
| :-------- | :------- | :----------------------- |
| `address` | `string` | The address to validate. |

## Returns

`void`

True if the address is a valid mixed case checksummed address.

## Source

[address/checks.ts:108](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/address/checks.ts#L108)


# Addressable
Source: https://docs.qu.ai/sdk/content/interfaces/Addressable



An interface for objects which have an address, and can resolve it asyncronously.

This allows objects such as [Signer](Signer) or [Contract](../classes/Contract) to be used most places an address can
be, for example getting the [balance](../interfaces/Provider#getBalance).

## Extended by

* [`Signer`](/sdk/content/interfaces/Signer)

## Methods

### getAddress()

```ts theme={null}
getAddress(): Promise<string>
```

Get the object address.

#### Returns

`Promise`\<`string`>

#### Source

[address/index.ts:24](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/address/index.ts#L24)


# BaseContractMethod
Source: https://docs.qu.ai/sdk/content/interfaces/BaseContractMethod



A Contract method can be called directly, or used in various ways.

## Extended by

* [`ContractMethod`](/sdk/content/interfaces/ContractMethod)

## Type parameters

| Type parameter                                                                                         | Value                                                                                    |
| :----------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------- |
| `A` *extends* `any`\[]                                                                                 | `any`\[]                                                                                 |
| `R`                                                                                                    | `any`                                                                                    |
| `D` *extends* `R` \| [`ContractTransactionResponse`](/sdk/content/classes/ContractTransactionResponse) | `R` \| [`ContractTransactionResponse`](/sdk/content/classes/ContractTransactionResponse) |

```ts theme={null}
interface BaseContractMethod(...args): Promise<D>
```

Call the contract method with arguments.

## Parameters

| Parameter | Type                       | Description                            |
| :-------- | :------------------------- | :------------------------------------- |
| ...`args` | `ContractMethodArgs`\<`A`> | The arguments to call the method with. |

## Returns

`Promise`\<`D`>

A promise resolving to the result of the call.

## Source

[contract/types.ts:137](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/types.ts#L137)

## Properties

| Property   | Type                                                        | Description                                                                     |
| :--------- | :---------------------------------------------------------- | :------------------------------------------------------------------------------ |
| `fragment` | [`FunctionFragment`](/sdk/content/classes/FunctionFragment) | The fragment of the Contract method. This will throw on ambiguous method names. |
| `name`     | `string`                                                    | The name of the Contract method.                                                |

## Methods

### estimateGas()

```ts theme={null}
estimateGas(...args): Promise<bigint>
```

Estimate the gas to send the contract method with `args`.

#### Parameters

| Parameter | Type                       | Description                            |
| :-------- | :------------------------- | :------------------------------------- |
| ...`args` | `ContractMethodArgs`\<`A`> | The arguments to call the method with. |

#### Returns

`Promise`\<`bigint`>

A promise resolving to the estimated gas.

#### Source

[contract/types.ts:190](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/types.ts#L190)

***

### getFragment()

```ts theme={null}
getFragment(...args): FunctionFragment
```

Returns the fragment constrained by `args`. This can be used to resolve ambiguous method names.

#### Parameters

| Parameter | Type                       | Description                                 |
| :-------- | :------------------------- | :------------------------------------------ |
| ...`args` | `ContractMethodArgs`\<`A`> | The arguments to constrain the fragment by. |

#### Returns

[`FunctionFragment`](/sdk/content/classes/FunctionFragment)

The constrained fragment.

#### Source

[contract/types.ts:155](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/types.ts#L155)

***

### populateTransaction()

```ts theme={null}
populateTransaction(...args): Promise<ContractTransaction>
```

Returns a populated transaction that can be used to perform the contract method with `args`.

#### Parameters

| Parameter | Type                       | Description                                     |
| :-------- | :------------------------- | :---------------------------------------------- |
| ...`args` | `ContractMethodArgs`\<`A`> | The arguments to populate the transaction with. |

#### Returns

`Promise`\<[`ContractTransaction`](/sdk/content/interfaces/ContractTransaction)>

A promise resolving to the populated transaction.

#### Source

[contract/types.ts:163](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/types.ts#L163)

***

### send()

```ts theme={null}
send(...args): Promise<ContractTransactionResponse>
```

Send a transaction for the contract method with `args`.

#### Parameters

| Parameter | Type                       | Description                            |
| :-------- | :------------------------- | :------------------------------------- |
| ...`args` | `ContractMethodArgs`\<`A`> | The arguments to call the method with. |

#### Returns

`Promise`\<[`ContractTransactionResponse`](/sdk/content/classes/ContractTransactionResponse)>

A promise resolving to the transaction response.

#### Source

[contract/types.ts:182](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/types.ts#L182)

***

### staticCall()

```ts theme={null}
staticCall(...args): Promise<R>
```

Call the contract method with `args` and return the value.

If the return value is a single type, it will be dereferenced and returned directly, otherwise the full Result
will be returned.

#### Parameters

| Parameter | Type                       | Description                            |
| :-------- | :------------------------- | :------------------------------------- |
| ...`args` | `ContractMethodArgs`\<`A`> | The arguments to call the method with. |

#### Returns

`Promise`\<`R`>

A promise resolving to the result of the static call.

#### Source

[contract/types.ts:174](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/types.ts#L174)

***

### staticCallResult()

```ts theme={null}
staticCallResult(...args): Promise<Result>
```

Call the contract method with `args` and return the Result without any dereferencing.

#### Parameters

| Parameter | Type                       | Description                            |
| :-------- | :------------------------- | :------------------------------------- |
| ...`args` | `ContractMethodArgs`\<`A`> | The arguments to call the method with. |

#### Returns

`Promise`\<[`Result`](/sdk/content/classes/Result)>

A promise resolving to the Result of the static call.

#### Source

[contract/types.ts:198](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/types.ts#L198)


# ConstantContractMethod
Source: https://docs.qu.ai/sdk/content/interfaces/ConstantContractMethod



A pure or view method on a Contract.

## Extends

* [`ContractMethod`](/sdk/content/interfaces/ContractMethod)\<`A`, `R`, `R`>

## Type parameters

| Type parameter         | Value |
| :--------------------- | :---- |
| `A` *extends* `any`\[] | -     |
| `R`                    | `any` |

```ts theme={null}
interface ConstantContractMethod(...args): Promise<R>
```

Call the contract method with arguments.

## Parameters

| Parameter | Type                       | Description                            |
| :-------- | :------------------------- | :------------------------------------- |
| ...`args` | `ContractMethodArgs`\<`A`> | The arguments to call the method with. |

## Returns

`Promise`\<`R`>

A promise resolving to the result of the call.

## Source

[contract/types.ts:217](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/types.ts#L217)

## Properties

| Property   | Type                                                        | Description                                                                     | Inherited from                                                        |
| :--------- | :---------------------------------------------------------- | :------------------------------------------------------------------------------ | :-------------------------------------------------------------------- |
| `fragment` | [`FunctionFragment`](/sdk/content/classes/FunctionFragment) | The fragment of the Contract method. This will throw on ambiguous method names. | [`ContractMethod`](/sdk/content/interfaces/ContractMethod).`fragment` |
| `name`     | `string`                                                    | The name of the Contract method.                                                | [`ContractMethod`](/sdk/content/interfaces/ContractMethod).`name`     |

## Methods

### estimateGas()

```ts theme={null}
estimateGas(...args): Promise<bigint>
```

Estimate the gas to send the contract method with `args`.

#### Parameters

| Parameter | Type                       | Description                            |
| :-------- | :------------------------- | :------------------------------------- |
| ...`args` | `ContractMethodArgs`\<`A`> | The arguments to call the method with. |

#### Returns

`Promise`\<`bigint`>

A promise resolving to the estimated gas.

#### Inherited from

[`ContractMethod`](/sdk/content/interfaces/ContractMethod).[`estimateGas`](/sdk/content/interfaces/ContractMethod#estimategas)

#### Source

[contract/types.ts:190](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/types.ts#L190)

***

### getFragment()

```ts theme={null}
getFragment(...args): FunctionFragment
```

Returns the fragment constrained by `args`. This can be used to resolve ambiguous method names.

#### Parameters

| Parameter | Type                       | Description                                 |
| :-------- | :------------------------- | :------------------------------------------ |
| ...`args` | `ContractMethodArgs`\<`A`> | The arguments to constrain the fragment by. |

#### Returns

[`FunctionFragment`](/sdk/content/classes/FunctionFragment)

The constrained fragment.

#### Inherited from

[`ContractMethod`](/sdk/content/interfaces/ContractMethod).[`getFragment`](/sdk/content/interfaces/ContractMethod#getfragment)

#### Source

[contract/types.ts:155](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/types.ts#L155)

***

### populateTransaction()

```ts theme={null}
populateTransaction(...args): Promise<ContractTransaction>
```

Returns a populated transaction that can be used to perform the contract method with `args`.

#### Parameters

| Parameter | Type                       | Description                                     |
| :-------- | :------------------------- | :---------------------------------------------- |
| ...`args` | `ContractMethodArgs`\<`A`> | The arguments to populate the transaction with. |

#### Returns

`Promise`\<[`ContractTransaction`](/sdk/content/interfaces/ContractTransaction)>

A promise resolving to the populated transaction.

#### Inherited from

[`ContractMethod`](/sdk/content/interfaces/ContractMethod).[`populateTransaction`](/sdk/content/interfaces/ContractMethod#populatetransaction)

#### Source

[contract/types.ts:163](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/types.ts#L163)

***

### send()

```ts theme={null}
send(...args): Promise<ContractTransactionResponse>
```

Send a transaction for the contract method with `args`.

#### Parameters

| Parameter | Type                       | Description                            |
| :-------- | :------------------------- | :------------------------------------- |
| ...`args` | `ContractMethodArgs`\<`A`> | The arguments to call the method with. |

#### Returns

`Promise`\<[`ContractTransactionResponse`](/sdk/content/classes/ContractTransactionResponse)>

A promise resolving to the transaction response.

#### Inherited from

[`ContractMethod`](/sdk/content/interfaces/ContractMethod).[`send`](/sdk/content/interfaces/ContractMethod#send)

#### Source

[contract/types.ts:182](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/types.ts#L182)

***

### staticCall()

```ts theme={null}
staticCall(...args): Promise<R>
```

Call the contract method with `args` and return the value.

If the return value is a single type, it will be dereferenced and returned directly, otherwise the full Result
will be returned.

#### Parameters

| Parameter | Type                       | Description                            |
| :-------- | :------------------------- | :------------------------------------- |
| ...`args` | `ContractMethodArgs`\<`A`> | The arguments to call the method with. |

#### Returns

`Promise`\<`R`>

A promise resolving to the result of the static call.

#### Inherited from

[`ContractMethod`](/sdk/content/interfaces/ContractMethod).[`staticCall`](/sdk/content/interfaces/ContractMethod#staticcall)

#### Source

[contract/types.ts:174](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/types.ts#L174)

***

### staticCallResult()

```ts theme={null}
staticCallResult(...args): Promise<Result>
```

Call the contract method with `args` and return the Result without any dereferencing.

#### Parameters

| Parameter | Type                       | Description                            |
| :-------- | :------------------------- | :------------------------------------- |
| ...`args` | `ContractMethodArgs`\<`A`> | The arguments to call the method with. |

#### Returns

`Promise`\<[`Result`](/sdk/content/classes/Result)>

A promise resolving to the Result of the static call.

#### Inherited from

[`ContractMethod`](/sdk/content/interfaces/ContractMethod).[`staticCallResult`](/sdk/content/interfaces/ContractMethod#staticcallresult)

#### Source

[contract/types.ts:198](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/types.ts#L198)


# ContractDeployTransaction
Source: https://docs.qu.ai/sdk/content/interfaces/ContractDeployTransaction



A deployment transaction for a contract.

## Extends

* `Omit`\<[`ContractTransaction`](/sdk/content/interfaces/ContractTransaction), `"to"`>

## Properties

| Property      | Type                                                 | Description                                                                                                                                                                                                                                        | Inherited from    |
| :------------ | :--------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------------- |
| `accessList?` | [`AccessList`](/sdk/content/type-aliases/AccessList) | The [EIP-2930](https://eips.ethereum.org/EIPS/eip-2930) access list. Storage slots included in the access list<br />are warmed by pre-loading them, so their initial cost to fetch is guaranteed, but then each additional access is<br />cheaper. | `Omit.accessList` |
| `blockTag?`   | [`BlockTag`](/sdk/content/type-aliases/BlockTag)     | When using `call` or `estimateGas`, this allows a specific block to be queried. Many backends do not support this<br />and when unsupported errors are silently squelched and `"latest"` is used.                                                  | `Omit.blockTag`   |
| `chainId?`    | `bigint`                                             | The chain ID for the network this transaction is valid on.                                                                                                                                                                                         | `Omit.chainId`    |
| `customData?` | `any`                                                | A custom object, which can be passed along for network-specific values.                                                                                                                                                                            | `Omit.customData` |
| `data`        | `string`                                             | The transaction data.                                                                                                                                                                                                                              | `Omit.data`       |
| `from`        | `string`                                             | The from address, if any.                                                                                                                                                                                                                          | `Omit.from`       |
| `gasLimit?`   | `bigint`                                             | The maximum amount of gas to allow this transaction to consume.                                                                                                                                                                                    | `Omit.gasLimit`   |
| `gasPrice?`   | `bigint`                                             | The gas price to use for the transaction.                                                                                                                                                                                                          | `Omit.gasPrice`   |
| `nonce?`      | `number`                                             | The nonce of the transaction, used to prevent replay attacks.                                                                                                                                                                                      | `Omit.nonce`      |
| `type?`       | `number`                                             | The transaction type.                                                                                                                                                                                                                              | `Omit.type`       |
| `value?`      | `bigint`                                             | The transaction value (in wei).                                                                                                                                                                                                                    | `Omit.value`      |


# ContractEvent
Source: https://docs.qu.ai/sdk/content/interfaces/ContractEvent



A Contract event on a Contract.

## Type parameters

| Type parameter         | Value    |
| :--------------------- | :------- |
| `A` *extends* `any`\[] | `any`\[] |

```ts theme={null}
interface ContractEvent(...args): DeferredTopicFilter
```

Create a deferred topic filter for the event.

## Parameters

| Parameter | Type                      | Description                              |
| :-------- | :------------------------ | :--------------------------------------- |
| ...`args` | `ContractEventArgs`\<`A`> | The arguments to create the filter with. |

## Returns

[`DeferredTopicFilter`](/sdk/content/interfaces/DeferredTopicFilter)

The deferred topic filter.

## Source

[contract/types.ts:238](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/types.ts#L238)

## Properties

| Property   | Type                                                  | Description                                                                    |
| :--------- | :---------------------------------------------------- | :----------------------------------------------------------------------------- |
| `fragment` | [`EventFragment`](/sdk/content/classes/EventFragment) | The fragment of the Contract event. This will throw on ambiguous method names. |
| `name`     | `string`                                              | The name of the Contract event.                                                |

## Methods

### getFragment()

```ts theme={null}
getFragment(...args): EventFragment
```

Returns the fragment constrained by `args`. This can be used to resolve ambiguous event names.

#### Parameters

| Parameter | Type                      | Description                                 |
| :-------- | :------------------------ | :------------------------------------------ |
| ...`args` | `ContractEventArgs`\<`A`> | The arguments to constrain the fragment by. |

#### Returns

[`EventFragment`](/sdk/content/classes/EventFragment)

The constrained fragment.

#### Source

[contract/types.ts:256](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/types.ts#L256)


# ContractInterface
Source: https://docs.qu.ai/sdk/content/interfaces/ContractInterface



A Contract with no method constraints.


# ContractMethod
Source: https://docs.qu.ai/sdk/content/interfaces/ContractMethod



A contract method on a Contract.

## Extends

* [`BaseContractMethod`](/sdk/content/interfaces/BaseContractMethod)\<`A`, `R`, `D`>

## Extended by

* [`ConstantContractMethod`](/sdk/content/interfaces/ConstantContractMethod)

## Type parameters

| Type parameter                                                                                         | Value                                                                                    |
| :----------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------- |
| `A` *extends* `any`\[]                                                                                 | `any`\[]                                                                                 |
| `R`                                                                                                    | `any`                                                                                    |
| `D` *extends* `R` \| [`ContractTransactionResponse`](/sdk/content/classes/ContractTransactionResponse) | `R` \| [`ContractTransactionResponse`](/sdk/content/classes/ContractTransactionResponse) |

```ts theme={null}
interface ContractMethod(...args): Promise<D>
```

Call the contract method with arguments.

## Parameters

| Parameter | Type                       | Description                            |
| :-------- | :------------------------- | :------------------------------------- |
| ...`args` | `ContractMethodArgs`\<`A`> | The arguments to call the method with. |

## Returns

`Promise`\<`D`>

A promise resolving to the result of the call.

## Source

[contract/types.ts:206](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/types.ts#L206)

## Properties

| Property   | Type                                                        | Description                                                                     | Inherited from                                                                |
| :--------- | :---------------------------------------------------------- | :------------------------------------------------------------------------------ | :---------------------------------------------------------------------------- |
| `fragment` | [`FunctionFragment`](/sdk/content/classes/FunctionFragment) | The fragment of the Contract method. This will throw on ambiguous method names. | [`BaseContractMethod`](/sdk/content/interfaces/BaseContractMethod).`fragment` |
| `name`     | `string`                                                    | The name of the Contract method.                                                | [`BaseContractMethod`](/sdk/content/interfaces/BaseContractMethod).`name`     |

## Methods

### estimateGas()

```ts theme={null}
estimateGas(...args): Promise<bigint>
```

Estimate the gas to send the contract method with `args`.

#### Parameters

| Parameter | Type                       | Description                            |
| :-------- | :------------------------- | :------------------------------------- |
| ...`args` | `ContractMethodArgs`\<`A`> | The arguments to call the method with. |

#### Returns

`Promise`\<`bigint`>

A promise resolving to the estimated gas.

#### Inherited from

[`BaseContractMethod`](/sdk/content/interfaces/BaseContractMethod).[`estimateGas`](/sdk/content/interfaces/BaseContractMethod#estimategas)

#### Source

[contract/types.ts:190](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/types.ts#L190)

***

### getFragment()

```ts theme={null}
getFragment(...args): FunctionFragment
```

Returns the fragment constrained by `args`. This can be used to resolve ambiguous method names.

#### Parameters

| Parameter | Type                       | Description                                 |
| :-------- | :------------------------- | :------------------------------------------ |
| ...`args` | `ContractMethodArgs`\<`A`> | The arguments to constrain the fragment by. |

#### Returns

[`FunctionFragment`](/sdk/content/classes/FunctionFragment)

The constrained fragment.

#### Inherited from

[`BaseContractMethod`](/sdk/content/interfaces/BaseContractMethod).[`getFragment`](/sdk/content/interfaces/BaseContractMethod#getfragment)

#### Source

[contract/types.ts:155](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/types.ts#L155)

***

### populateTransaction()

```ts theme={null}
populateTransaction(...args): Promise<ContractTransaction>
```

Returns a populated transaction that can be used to perform the contract method with `args`.

#### Parameters

| Parameter | Type                       | Description                                     |
| :-------- | :------------------------- | :---------------------------------------------- |
| ...`args` | `ContractMethodArgs`\<`A`> | The arguments to populate the transaction with. |

#### Returns

`Promise`\<[`ContractTransaction`](/sdk/content/interfaces/ContractTransaction)>

A promise resolving to the populated transaction.

#### Inherited from

[`BaseContractMethod`](/sdk/content/interfaces/BaseContractMethod).[`populateTransaction`](/sdk/content/interfaces/BaseContractMethod#populatetransaction)

#### Source

[contract/types.ts:163](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/types.ts#L163)

***

### send()

```ts theme={null}
send(...args): Promise<ContractTransactionResponse>
```

Send a transaction for the contract method with `args`.

#### Parameters

| Parameter | Type                       | Description                            |
| :-------- | :------------------------- | :------------------------------------- |
| ...`args` | `ContractMethodArgs`\<`A`> | The arguments to call the method with. |

#### Returns

`Promise`\<[`ContractTransactionResponse`](/sdk/content/classes/ContractTransactionResponse)>

A promise resolving to the transaction response.

#### Inherited from

[`BaseContractMethod`](/sdk/content/interfaces/BaseContractMethod).[`send`](/sdk/content/interfaces/BaseContractMethod#send)

#### Source

[contract/types.ts:182](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/types.ts#L182)

***

### staticCall()

```ts theme={null}
staticCall(...args): Promise<R>
```

Call the contract method with `args` and return the value.

If the return value is a single type, it will be dereferenced and returned directly, otherwise the full Result
will be returned.

#### Parameters

| Parameter | Type                       | Description                            |
| :-------- | :------------------------- | :------------------------------------- |
| ...`args` | `ContractMethodArgs`\<`A`> | The arguments to call the method with. |

#### Returns

`Promise`\<`R`>

A promise resolving to the result of the static call.

#### Inherited from

[`BaseContractMethod`](/sdk/content/interfaces/BaseContractMethod).[`staticCall`](/sdk/content/interfaces/BaseContractMethod#staticcall)

#### Source

[contract/types.ts:174](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/types.ts#L174)

***

### staticCallResult()

```ts theme={null}
staticCallResult(...args): Promise<Result>
```

Call the contract method with `args` and return the Result without any dereferencing.

#### Parameters

| Parameter | Type                       | Description                            |
| :-------- | :------------------------- | :------------------------------------- |
| ...`args` | `ContractMethodArgs`\<`A`> | The arguments to call the method with. |

#### Returns

`Promise`\<[`Result`](/sdk/content/classes/Result)>

A promise resolving to the Result of the static call.

#### Inherited from

[`BaseContractMethod`](/sdk/content/interfaces/BaseContractMethod).[`staticCallResult`](/sdk/content/interfaces/BaseContractMethod#staticcallresult)

#### Source

[contract/types.ts:198](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/types.ts#L198)


# ContractRunner
Source: https://docs.qu.ai/sdk/content/interfaces/ContractRunner



A **ContractRunner** is a generic interface which defines an object capable of interacting with a Contract on the
network.

The more operations supported, the more utility it is capable of.

The most common ContractRunners are [Providers](../classes/Provider) which enable read-only access and
[Signers](../classes/Signer) which enable write-access.

## Extended by

* [`Provider`](/sdk/content/interfaces/Provider)
* [`Signer`](/sdk/content/interfaces/Signer)

## Properties

| Property            | Type                                                                                                                                                               | Description                                                                                                                                                                                         |
| :------------------ | :----------------------------------------------------------------------------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `call?`             | (`tx`: `QuaiTransactionRequest`) => `Promise`\<`string`>                                                                                                           | Required for pure, view or static calls to contracts.                                                                                                                                               |
| `createAccessList?` | (`tx`: `QuaiTransactionRequest`) => `Promise`\<[`AccessList`](/sdk/content/type-aliases/AccessList)>                                                               | Required for populating access lists for state mutating calls                                                                                                                                       |
| `estimateGas?`      | (`tx`: [`TransactionRequest`](/sdk/content/type-aliases/TransactionRequest)) => `Promise`\<`bigint`>                                                               | Required to estimate gas.                                                                                                                                                                           |
| `provider`          | `null` \| [`Provider`](/sdk/content/interfaces/Provider)                                                                                                           | The provider used for necessary state querying operations.<br /><br />This can also point to the **ContractRunner** itself, in the case of an<br />[AbstractProvider](../classes/AbstractProvider). |
| `sendTransaction?`  | (`tx`: [`TransactionRequest`](/sdk/content/type-aliases/TransactionRequest)) => `Promise`\<[`TransactionResponse`](/sdk/content/type-aliases/TransactionResponse)> | Required for state mutating calls                                                                                                                                                                   |


# ContractTransaction
Source: https://docs.qu.ai/sdk/content/interfaces/ContractTransaction



When populating a transaction this type is returned.

## Extends

* `QuaiPreparedTransactionRequest`

## Properties

| Property      | Type                                                 | Description                                                                                                                                                                                                                                        | Overrides                                   | Inherited from                              |
| :------------ | :--------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------ | :------------------------------------------ |
| `accessList?` | [`AccessList`](/sdk/content/type-aliases/AccessList) | The [EIP-2930](https://eips.ethereum.org/EIPS/eip-2930) access list. Storage slots included in the access list<br />are warmed by pre-loading them, so their initial cost to fetch is guaranteed, but then each additional access is<br />cheaper. | `QuaiPreparedTransactionRequest.accessList` | `QuaiPreparedTransactionRequest.accessList` |
| `blockTag?`   | [`BlockTag`](/sdk/content/type-aliases/BlockTag)     | When using `call` or `estimateGas`, this allows a specific block to be queried. Many backends do not support this<br />and when unsupported errors are silently squelched and `"latest"` is used.                                                  | `QuaiPreparedTransactionRequest.blockTag`   | `QuaiPreparedTransactionRequest.blockTag`   |
| `chainId?`    | `bigint`                                             | The chain ID for the network this transaction is valid on.                                                                                                                                                                                         | `QuaiPreparedTransactionRequest.chainId`    | `QuaiPreparedTransactionRequest.chainId`    |
| `customData?` | `any`                                                | A custom object, which can be passed along for network-specific values.                                                                                                                                                                            | `QuaiPreparedTransactionRequest.customData` | `QuaiPreparedTransactionRequest.customData` |
| `data`        | `string`                                             | The transaction data.                                                                                                                                                                                                                              | `QuaiPreparedTransactionRequest.data`       | `QuaiPreparedTransactionRequest.data`       |
| `from`        | `string`                                             | The from address, if any.                                                                                                                                                                                                                          | `QuaiPreparedTransactionRequest.from`       | `QuaiPreparedTransactionRequest.from`       |
| `gasLimit?`   | `bigint`                                             | The maximum amount of gas to allow this transaction to consume.                                                                                                                                                                                    | `QuaiPreparedTransactionRequest.gasLimit`   | `QuaiPreparedTransactionRequest.gasLimit`   |
| `gasPrice?`   | `bigint`                                             | The gas price to use for the transaction.                                                                                                                                                                                                          | `QuaiPreparedTransactionRequest.gasPrice`   | `QuaiPreparedTransactionRequest.gasPrice`   |
| `nonce?`      | `number`                                             | The nonce of the transaction, used to prevent replay attacks.                                                                                                                                                                                      | `QuaiPreparedTransactionRequest.nonce`      | `QuaiPreparedTransactionRequest.nonce`      |
| `to`          | `string`                                             | The target address.                                                                                                                                                                                                                                | `QuaiPreparedTransactionRequest.to`         | `QuaiPreparedTransactionRequest.to`         |
| `type?`       | `number`                                             | The transaction type.                                                                                                                                                                                                                              | `QuaiPreparedTransactionRequest.type`       | `QuaiPreparedTransactionRequest.type`       |
| `value?`      | `bigint`                                             | The transaction value (in wei).                                                                                                                                                                                                                    | `QuaiPreparedTransactionRequest.value`      | `QuaiPreparedTransactionRequest.value`      |


# DeferredTopicFilter
Source: https://docs.qu.ai/sdk/content/interfaces/DeferredTopicFilter



When creating a filter using the `contract.filters`, this is returned.

## Properties

| Property   | Type                                                  | Description                |
| :--------- | :---------------------------------------------------- | :------------------------- |
| `fragment` | [`EventFragment`](/sdk/content/classes/EventFragment) | The fragment of the event. |

## Methods

### getTopicFilter()

```ts theme={null}
getTopicFilter(): Promise<TopicFilter>
```

Get the topic filter.

#### Returns

`Promise`\<[`TopicFilter`](/sdk/content/type-aliases/TopicFilter)>

A promise resolving to the topic filter.

#### Source

[contract/types.ts:56](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/types.ts#L56)


# JsonFragment
Source: https://docs.qu.ai/sdk/content/interfaces/JsonFragment



A fragment for a method, event or error in a [JSON ABI
format](https://docs.soliditylang.org/en/v0.8.19/abi-spec.html#json)

## Properties

| Property           | Modifier   | Type                                                                       | Description                                                        |
| :----------------- | :--------- | :------------------------------------------------------------------------- | :----------------------------------------------------------------- |
| `anonymous?`       | `readonly` | `boolean`                                                                  | If the event is anonymous.                                         |
| `constant?`        | `readonly` | `boolean`                                                                  | If the function is constant.                                       |
| `gas?`             | `readonly` | `string`                                                                   | The gas limit to use when sending a transaction for this function. |
| `inputs?`          | `readonly` | readonly [`JsonFragmentType`](/sdk/content/interfaces/JsonFragmentType)\[] | The input parameters.                                              |
| `name?`            | `readonly` | `string`                                                                   | The name of the error, event, function, etc.                       |
| `outputs?`         | `readonly` | readonly [`JsonFragmentType`](/sdk/content/interfaces/JsonFragmentType)\[] | The output parameters.                                             |
| `payable?`         | `readonly` | `boolean`                                                                  | If the function is payable.                                        |
| `stateMutability?` | `readonly` | `string`                                                                   | The mutability state of the function.                              |
| `type?`            | `readonly` | `string`                                                                   | The type of the fragment (e.g. `event`, `"function"`, etc.)        |


# JsonFragmentType
Source: https://docs.qu.ai/sdk/content/interfaces/JsonFragmentType



A Type description in a [JSON ABI format](https://docs.soliditylang.org/en/v0.8.19/abi-spec.html#json).

## Properties

| Property        | Modifier   | Type                                                                       | Description                  |
| :-------------- | :--------- | :------------------------------------------------------------------------- | :--------------------------- |
| `components?`   | `readonly` | readonly [`JsonFragmentType`](/sdk/content/interfaces/JsonFragmentType)\[] | The components for a tuple.  |
| `indexed?`      | `readonly` | `boolean`                                                                  | If the parameter is indexed. |
| `internalType?` | `readonly` | `string`                                                                   | The internal Solidity type.  |
| `name?`         | `readonly` | `string`                                                                   | The parameter name.          |
| `type?`         | `readonly` | `string`                                                                   | The type of the parameter.   |


# Overrides
Source: https://docs.qu.ai/sdk/content/interfaces/Overrides



The overrides for a contract transaction.

## Extends

* `Omit`\<[`TransactionRequest`](/sdk/content/type-aliases/TransactionRequest), `"to"` | `"data"`>

## Properties

| Property   | Type                                                               | Description                                                | Inherited from |
| :--------- | :----------------------------------------------------------------- | :--------------------------------------------------------- | :------------- |
| `chainId?` | `null` \| [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The chain ID for the network this transaction is valid on. | `Omit.chainId` |
| `type?`    | `null` \| `number`                                                 | The transaction type. Quai transactions are always type 0. | `Omit.type`    |


# WrappedFallback
Source: https://docs.qu.ai/sdk/content/interfaces/WrappedFallback



A Fallback or Receive function on a Contract.

```ts theme={null}
interface WrappedFallback(overrides?): Promise<ContractTransactionResponse>
```

Call the fallback method.

## Parameters

| Parameter    | Type                                                                                  | Description                |
| :----------- | :------------------------------------------------------------------------------------ | :------------------------- |
| `overrides`? | `Omit`\<[`TransactionRequest`](/sdk/content/type-aliases/TransactionRequest), `"to"`> | The transaction overrides. |

## Returns

`Promise`\<[`ContractTransactionResponse`](/sdk/content/classes/ContractTransactionResponse)>

A promise resolving to the transaction response.

## Source

[contract/types.ts:271](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/types.ts#L271)

## Methods

### estimateGas()

```ts theme={null}
estimateGas(overrides?): Promise<bigint>
```

Estimate the gas to send a transaction to the contract fallback.

For non-receive fallback, `data` may be overridden.

#### Parameters

| Parameter    | Type                                                                                  | Description                |
| :----------- | :------------------------------------------------------------------------------------ | :------------------------- |
| `overrides`? | `Omit`\<[`TransactionRequest`](/sdk/content/type-aliases/TransactionRequest), `"to"`> | The transaction overrides. |

#### Returns

`Promise`\<`bigint`>

A promise resolving to the estimated gas.

#### Source

[contract/types.ts:311](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/types.ts#L311)

***

### populateTransaction()

```ts theme={null}
populateTransaction(overrides?): Promise<ContractTransaction>
```

Returns a populated transaction that can be used to perform the fallback method.

For non-receive fallback, `data` may be overridden.

#### Parameters

| Parameter    | Type                                                                                  | Description                |
| :----------- | :------------------------------------------------------------------------------------ | :------------------------- |
| `overrides`? | `Omit`\<[`TransactionRequest`](/sdk/content/type-aliases/TransactionRequest), `"to"`> | The transaction overrides. |

#### Returns

`Promise`\<[`ContractTransaction`](/sdk/content/interfaces/ContractTransaction)>

A promise resolving to the populated transaction.

#### Source

[contract/types.ts:281](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/types.ts#L281)

***

### send()

```ts theme={null}
send(overrides?): Promise<ContractTransactionResponse>
```

Send a transaction to the contract fallback.

For non-receive fallback, `data` may be overridden.

#### Parameters

| Parameter    | Type                                                                                  | Description                |
| :----------- | :------------------------------------------------------------------------------------ | :------------------------- |
| `overrides`? | `Omit`\<[`TransactionRequest`](/sdk/content/type-aliases/TransactionRequest), `"to"`> | The transaction overrides. |

#### Returns

`Promise`\<[`ContractTransactionResponse`](/sdk/content/classes/ContractTransactionResponse)>

A promise resolving to the transaction response.

#### Source

[contract/types.ts:301](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/types.ts#L301)

***

### staticCall()

```ts theme={null}
staticCall(overrides?): Promise<string>
```

Call the contract fallback and return the result.

For non-receive fallback, `data` may be overridden.

#### Parameters

| Parameter    | Type                                                                                  | Description                |
| :----------- | :------------------------------------------------------------------------------------ | :------------------------- |
| `overrides`? | `Omit`\<[`TransactionRequest`](/sdk/content/type-aliases/TransactionRequest), `"to"`> | The transaction overrides. |

#### Returns

`Promise`\<`string`>

A promise resolving to the result of the call.

#### Source

[contract/types.ts:291](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/types.ts#L291)


# AddressLike
Source: https://docs.qu.ai/sdk/content/type-aliases/AddressLike



```ts theme={null}
type AddressLike: string | Promise<string> | Addressable;
```

Anything that can be used to return or resolve an address.

## Source

[address/index.ts:32](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/address/index.ts#L32)


# AllowedCoinType
Source: https://docs.qu.ai/sdk/content/type-aliases/AllowedCoinType



```ts theme={null}
type AllowedCoinType: 969 | 994;
```

Constants that define the coin type for Qi and Quai

## Source

[constants/coins.ts:6](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/constants/coins.ts#L6)


# ContractEventName
Source: https://docs.qu.ai/sdk/content/type-aliases/ContractEventName



```ts theme={null}
type ContractEventName: string | ContractEvent | TopicFilter | DeferredTopicFilter;
```

The name for an event used for subscribing to Contract events.

**`string`** - An event by name. The event must be non-ambiguous. The parameters will be dereferenced when passed
into the listener.

[**ContractEvent**](/sdk/content/interfaces/ContractEvent) - A filter from the `contract.filters`, which will pass only the
EventPayload as a single parameter, which includes a `.signature` property that can be used to further filter the
event.

[**TopicFilter**](/sdk/content/type-aliases/TopicFilter) - A filter defined using the standard Ethereum API which provides the specific
topic hash or topic hashes to watch for along with any additional values to filter by. This will only pass a single
parameter to the listener, the EventPayload which will include additional details to refine by, such as the event
name and signature.

[**DeferredTopicFilter**](/sdk/content/interfaces/DeferredTopicFilter) - A filter created by calling a
[**ContractEvent**](/sdk/content/interfaces/ContractEvent) with parameters, which will create a filter for a specific event signautre
and dereference each parameter when calling the listener.

## Source

[contract/types.ts:34](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/contract/types.ts#L34)


# FormatType
Source: https://docs.qu.ai/sdk/content/type-aliases/FormatType



```ts theme={null}
type FormatType: "sighash" | "minimal" | "full" | "json";
```

The format to serialize the output as.

**`sighash`** - the bare formatting, used to compute the selector or topic hash; this format cannot be reversed (as
it discards `indexed`) so cannot by used to export an [Interface](../classes/Interface).

**`minimal`** - Human-Readable ABI with minimal spacing and without names, so it is compact, but will result in
Result objects that cannot be accessed by name.

**`full`** - Full Human-Readable ABI, with readable spacing and names intact; this is generally the recommended
format.

**`json`** - The [ABI JSON Specification](https://docs.soliditylang.org/en/v0.8.19/abi-spec.html#json).

## Source

[abi/fragments.ts:117](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L117)


# FragmentType
Source: https://docs.qu.ai/sdk/content/type-aliases/FragmentType



```ts theme={null}
type FragmentType: 
  | "constructor"
  | "error"
  | "event"
  | "fallback"
  | "function"
  | "struct";
```

The type of a [**Fragment**](/sdk/content/classes/Fragment).

## Source

[abi/fragments.ts:1025](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L1025)


# InterfaceAbi
Source: https://docs.qu.ai/sdk/content/type-aliases/InterfaceAbi



```ts theme={null}
type InterfaceAbi: string | ReadonlyArray<Fragment | JsonFragment | string>;
```

An **InterfaceAbi** may be any supported ABI format.

A string is expected to be a JSON string, which will be parsed using `JSON.parse`. This means that the value **must**
be a valid JSON string, with no stray commas, etc.

An array may contain any combination of:

* Human-Readable fragments
* Parsed JSON fragment
* [**Fragment**](../classes/Fragment)

A **Human-Readable Fragment** is a string which resembles a Solidity signature and is introduced in [this blog
entry](lhttps://blog.ricmoo.com/human-readable-contract-abis-in-quais-js-141902f4d917). For example, `function
balanceOf(address) view returns (uint)`.

A **Parsed JSON Fragment** is a JavaScript Object desribed in the [Solidity
documentation](https://docs.soliditylang.org/en/v0.8.19/abi-spec.html#json).

## Source

[abi/interface.ts:298](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/interface.ts#L298)


# ParamTypeWalkAsyncFunc
Source: https://docs.qu.ai/sdk/content/type-aliases/ParamTypeWalkAsyncFunc



```ts theme={null}
type ParamTypeWalkAsyncFunc: (type, value) => any | Promise<any>;
```

When [**walking asynchronously**](/sdk/content/classes/ParamType#walkasync) a [**ParamType**](/sdk/content/classes/ParamType), this is called on
each component.

## Parameters

| Parameter | Type     |
| :-------- | :------- |
| `type`    | `string` |
| `value`   | `any`    |

## Returns

`any` | `Promise`\<`any`>

## Source

[abi/fragments.ts:586](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L586)


# ParamTypeWalkFunc
Source: https://docs.qu.ai/sdk/content/type-aliases/ParamTypeWalkFunc



```ts theme={null}
type ParamTypeWalkFunc: (type, value) => any;
```

When [**walking**](/sdk/content/classes/ParamType#walk) a [**ParamType**](/sdk/content/classes/ParamType), this is called on each component.

## Parameters

| Parameter | Type     |
| :-------- | :------- |
| `type`    | `string` |
| `value`   | `any`    |

## Returns

`any`

## Source

[abi/fragments.ts:578](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/abi/fragments.ts#L578)


# ProgressCallback
Source: https://docs.qu.ai/sdk/content/type-aliases/ProgressCallback



```ts theme={null}
type ProgressCallback: (percent) => void;
```

A callback during long-running operations to update any UI or provide programatic access to the progress.

The `percent` is a value between `0` and `1`.

## Parameters

| Parameter | Type     |
| :-------- | :------- |
| `percent` | `number` |

## Returns

`void`

## Source

[crypto/scrypt.ts:14](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/scrypt.ts#L14)


# SignatureLike
Source: https://docs.qu.ai/sdk/content/type-aliases/SignatureLike



```ts theme={null}
type SignatureLike: 
  | Signature
  | string
  | {
  "r": string;
  "s": string;
  "v": BigNumberish;
  "yParity": 0 | 1;
  "yParityAndS": string;
 }
  | {
  "r": string;
  "s": string;
  "v": number;
  "yParity": 0 | 1;
  "yParityAndS": string;
 }
  | {
  "r": string;
  "s": string;
  "v": BigNumberish;
  "yParity": 0 | 1;
  "yParityAndS": string;
};
```

A SignatureLike

## Source

[crypto/signature.ts:35](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/crypto/signature.ts#L35)


# UnicodeNormalizationForm
Source: https://docs.qu.ai/sdk/content/type-aliases/UnicodeNormalizationForm



```ts theme={null}
type UnicodeNormalizationForm: "NFC" | "NFD" | "NFKC" | "NFKD";
```

The stanard normalization forms.

## Source

[encoding/utf8.ts:19](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/encoding/utf8.ts#L19)


# Utf8ErrorFunc
Source: https://docs.qu.ai/sdk/content/type-aliases/Utf8ErrorFunc



```ts theme={null}
type Utf8ErrorFunc: (reason, offset, bytes, output, badCodepoint?) => number;
```

A callback that can be used with [**toUtf8String**](/sdk/content/functions/toUtf8String) to analysis or recovery from invalid UTF-8
data.

Parsing UTF-8 data is done through a simple Finite-State Machine (FSM) which calls the `Utf8ErrorFunc` if a fault is
detected.

The `reason` indicates where in the FSM execution the fault occurred and the `offset` indicates where the input
failed.

The `bytes` represents the raw UTF-8 data that was provided and `output` is the current array of UTF-8 code-points,
which may be updated by the `Utf8ErrorFunc`.

The value of the `badCodepoint` depends on the `reason`. See [**Utf8ErrorReason**](/sdk/content/type-aliases/Utf8ErrorReason) for
details.

The function should return the number of bytes that should be skipped when control resumes to the FSM.

## Parameters

| Parameter       | Type                                                           |
| :-------------- | :------------------------------------------------------------- |
| `reason`        | [`Utf8ErrorReason`](/sdk/content/type-aliases/Utf8ErrorReason) |
| `offset`        | `number`                                                       |
| `bytes`         | `Uint8Array`                                                   |
| `output`        | `number`\[]                                                    |
| `badCodepoint`? | `number`                                                       |

## Returns

`number`

## Source

[encoding/utf8.ts:74](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/encoding/utf8.ts#L74)


# Utf8ErrorReason
Source: https://docs.qu.ai/sdk/content/type-aliases/Utf8ErrorReason



```ts theme={null}
type Utf8ErrorReason: 
  | "UNEXPECTED_CONTINUE"
  | "BAD_PREFIX"
  | "OVERRUN"
  | "MISSING_CONTINUE"
  | "OUT_OF_RANGE"
  | "UTF16_SURROGATE"
  | "OVERLONG";
```

When using the UTF-8 error API the following errors can be intercepted and processed as the `reason` passed to the
[**Utf8ErrorFunc**](/sdk/content/type-aliases/Utf8ErrorFunc).

**`"UNEXPECTED_CONTINUE"`** - a continuation byte was present where there was nothing to continue.

**`"BAD_PREFIX"`** - an invalid (non-continuation) byte to start a UTF-8 codepoint was found.

**`"OVERRUN"`** - the string is too short to process the expected codepoint length.

**`"MISSING_CONTINUE"`** - a missing continuation byte was expected but not found. The `offset` indicates the index
the continuation byte was expected at.

**`"OUT_OF_RANGE"`** - the computed code point is outside the range for UTF-8. The `badCodepoint` indicates the
computed codepoint, which was outside the valid UTF-8 range.

**`"UTF16_SURROGATE"`** - the UTF-8 strings contained a UTF-16 surrogate pair. The `badCodepoint` is the computed
codepoint, which was inside the UTF-16 surrogate range.

**`"OVERLONG"`** - the string is an overlong representation. The `badCodepoint` indicates the computed codepoint,
which has already been bounds checked.

## Source

[encoding/utf8.ts:45](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/encoding/utf8.ts#L45)


# MaxInt256
Source: https://docs.qu.ai/sdk/content/variables/MaxInt256



```ts theme={null}
const MaxInt256: bigint;
```

A constant for the maximum value for an `int256`.

(**i.e.** `0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn`)

## Source

[constants/numbers.ts:45](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/constants/numbers.ts#L45)


# MaxUint256
Source: https://docs.qu.ai/sdk/content/variables/MaxUint256



```ts theme={null}
const MaxUint256: bigint;
```

A constant for the maximum value for a `uint256`.

(**i.e.** `0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn`)

## Source

[constants/numbers.ts:26](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/constants/numbers.ts#L26)


# MessagePrefix
Source: https://docs.qu.ai/sdk/content/variables/MessagePrefix



```ts theme={null}
const MessagePrefix: string = '\x19Ethereum Signed Message:\n';
```

A constant for the Quai Network equivalent of the [EIP-191](https://eips.ethereum.org/EIPS/eip-191) personal message
prefix.

(**i.e.** `"\\x19Quai Signed Message:\\n"`)

## Source

[constants/strings.ts:20](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/constants/strings.ts#L20)


# MinInt256
Source: https://docs.qu.ai/sdk/content/variables/MinInt256



```ts theme={null}
const MinInt256: bigint;
```

A constant for the minimum value for an `int256`.

(**i.e.** `-8000000000000000000000000000000000000000000000000000000000000000n`)

## Source

[constants/numbers.ts:35](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/constants/numbers.ts#L35)


# N
Source: https://docs.qu.ai/sdk/content/variables/N



```ts theme={null}
const N: bigint;
```

A constant for the order N for the secp256k1 curve.

(**i.e.** `0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141n`)

## Source

[constants/numbers.ts:8](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/constants/numbers.ts#L8)


# WeiPerEther
Source: https://docs.qu.ai/sdk/content/variables/WeiPerEther



```ts theme={null}
const WeiPerEther: bigint;
```

A constant for the number of wei in a single ether.

(**i.e.** `1000000000000000000n`)

## Source

[constants/numbers.ts:17](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/constants/numbers.ts#L17)


# ZeroAddress
Source: https://docs.qu.ai/sdk/content/variables/ZeroAddress



```ts theme={null}
const ZeroAddress: string = '0x0000000000000000000000000000000000000000';
```

A constant for the zero address.

(**i.e.** `"0x0000000000000000000000000000000000000000"`)

## Source

[constants/addresses.ts:8](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/constants/addresses.ts#L8)


# ZeroHash
Source: https://docs.qu.ai/sdk/content/variables/ZeroHash



```ts theme={null}
const ZeroHash: string = '0x0000000000000000000000000000000000000000000000000000000000000000';
```

A constant for the zero hash.

(**i.e.** `"0x0000000000000000000000000000000000000000000000000000000000000000"`)

## Source

[constants/hashes.ts:8](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/constants/hashes.ts#L8)


# quaisymbol
Source: https://docs.qu.ai/sdk/content/variables/quaisymbol



```ts theme={null}
const quaisymbol: string = '\u039e';
```

A constant for the ether symbol (normalized using NFKC).

(**i.e.** `"\\u039e"`)

## Source

[constants/strings.ts:10](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/constants/strings.ts#L10)


# Contracts
Source: https://docs.qu.ai/sdk/static/contract

Contract connection and interaction utilities.

## Overview

A Contract object is a meta-class, which **communicates with a deployed smart contract** on the blockchain and provides a simple JavaScript interface to call methods, send transactions, and query historic logs.

Smart contracts only exist on the Quai account based ledger. They are not deployable on the UTXO based Qi ledger.

## Usage

In practice, the contract utilities are used to connect, read, and call state changing functions on the Quai Ledger. The contract class can be used to interact with any type of contract on any zone chain in the network.

### Connect to a Contract

In order to interact with a contract in any read-only capacity, you must "connect" to it using a [Provider](/sdk/content/interfaces/Provider). You'll also need to pass the contract's deployed address and the contract's ABI.

```js theme={null}
// set up a remote node provider
const provider = new quais.JsonRpcProvider(
  "https://rpc.quai.network",
  undefined,
  { usePathing: true }
);

// connect to the contract using the provider
const contract = new quais.Contract(contractAddress, contractABI, provider);
```

### Call Read Methods

Connecting a simple remote node provider to your contract will allow you to read-only methods.

```js theme={null}
// get the contract's symbol
const symbol = await contract.symbol();

// get the contract's name
const name = await contract.name();
```

### Call State Changing Methods

If you want to execute a contract state-changing operation, you'll need to pass a [Signer](/sdk/content/interfaces/Signer) to the contract.

```js theme={null}
// get signer from pelagus provider
const provider = new quais.BrowserProvider(window.pelagus);
const signer = provider.getSigner();

// connect the signer to the contract
const contract = new quais.Contract(contractAddress, contractABI, signer);

// call a state changing contract function
const result = await contract.transferTo(
  "1.0",
  "0x1234567890123456789012345678901234567890"
);
```


# Smart Contracts
Source: https://docs.qu.ai/sdk/static/examples/contract-deploy-interact

How to interact with and configure a smart contract on the Quai Ledger.

<Warning>
  This guide does not cover smart contract deployment. To learn more about deploying a smart contract with Quais and Hardhat, visit the
  [Hardhat Deployment Tutorial](/guides/development/solidity).
</Warning>

## Application Binary Interfaces

All operations that occur on the Quai ledger must be encoded as binary data. To call and interpret data from smart contracts on-chain, we need a simple way to convert between common data types (e.g. strings and numbers) and their binary representaion that the smart contract can understand.

Quais uses ABI fragments to encode and interpret smart contract data, allowing developers to easily pass and read data from smart contracts. There are several common formats that Quais accepts to describe a smart contract's ABI. The Solidity compiler typically provides a JSON ABI for every compiled contract that can be passed to Quais.

```js theme={null}
// JSON ABI
const abi = [
  {
      "constant": true,
      "inputs": [],
      "name": "symbol",
      "outputs": [
          {
              "name": "",
              "type": "string"
          }
      ],
      "payable": false,
      "stateMutability": "view",
      "type": "function"
  },
  ...
]

// use the JSON ABI to create a contract
const contract = new quais.Contract(address, abi, provider)
```

You may also provide the more readable Solidity signature for any relevant methods, errors, or calls to the contract.

```js theme={null}
// simplified Solidity signature ABI
const abi = [
	'function decimals() view returns (uint8)',
	'function symbol() view returns (string)',
	'function balanceOf(address addr) view returns (uint)',
]

// use the simplified ABI to create a contract
const contract = new quais.Contract(address, abi, provider)
```

## Read-only Interactions

Contracts often have read-only methods (view and pure) that can be called to query the state of the smart contract without initiating a transaction. You can call these methods using only a [Provider](/sdk/content/interfaces/Provider).

```js theme={null}
// contract ABI (only includes the methods we care about)
const abi = [
	'function decimals() view returns (uint8)',
	'function symbol() view returns (string)',
	'function balanceOf(address addr) view returns (uint)',
]

// create contract with only a Provider
const contract = new quais.Contract(address, abi, provider)

// get the token symbol
symbol = await contract.symbol() // "ABC"

// get the token decimals
decimals = await contract.decimals() // 18n

// get the balance of an address
balance = await contract.balanceOf('0x1234567890123456789012345678901234567890') // 10000000000000000000n

// format the balance
formatUnits(balance, decimals) // "10.0"
```

## State-changing Interactions

To call a state-changing method, you'll need to pass a [Signer](/sdk/content/interfaces/Signer) or [Wallet](/sdk/content/interfaces/Wallet) to the contract.

```js theme={null}
// contract ABI (only includes the methods we care about)
const abi = ['function transferTo(address to, uint amount)']

// create wallet and pass it to the contract
const wallet = new quais.Wallet(privateKey, provider)
const contract = new quais.Contract(address, abi, wallet)

// transfer some tokens
const tx = await contract.transferTo('0x1234567890123456789012345678901234567890', parseUnits('1.0', 18))

await tx.wait()
```

## Events

### Listening for Events

You can listen for emitted events from a smart contract using event filters.

```js theme={null}
// contract ABI (only includes the events we care about)
const abi = ['event Transfer(address indexed from, address indexed to, uint amount)']

// create contract with only a Provider
const contract = new quais.Contract(address, abi, provider)

// use an event listener to listen for any transfer event
contract.on('Transfer', (from, to, amount, event) => {
	const tokenAmount = formatUnits(amount, 18)
	console.log('Transfer from', from, 'to', to, 'amount', tokenAmount)

	// stop listening for events
	event.removeListener()
})

// use a filter to listen for transfer events from a specific address
const filter = contract.filters.Transfer('0x1234567890123456789012345678901234567890')
contract.on(filter, (from, to, amount, event) => {
	const tokenAmount = formatUnits(amount, 18)
	console.log('Transfer from', from, 'to', to, 'amount', tokenAmount)
})
```

### Query Historic Events

To query historic events, you can use the [queryFilter](/sdk/content/classes/Contract#queryfilter) method.

```js theme={null}
// contract ABI
const abi = ['event Transfer(address indexed from, address indexed to, uint amount)']

// create contract with only a Provider
const contract = new quais.Contract(address, abi, provider)

// query the last 50 blocks for any transfer events
const filter = contract.filters.Transfer
const events = await contract.queryFilter(filter, -50) // returns an array of events

// query all transfer events from a specific address
const filter = contract.filters.Transfer('0x1234567890123456789012345678901234567890')
const events = await contract.queryFilter(filter) // returns an array of events
```


# Send Transactions
Source: https://docs.qu.ai/sdk/static/examples/send-transaction

Sign and send transactions on the Quai and Qi ledgers.

<Tabs>
  <Tab title="Quai Transactions">
    <Steps>
      <Step title="Configure Wallet">
        To send a Quai transaction, you'll first need to connect a [Wallet](/sdk/content/classes/Wallet) or [QuaiHDWallet](/sdk/content/classes/QuaiHDWallet) to a [Provider](/sdk/content/interfaces/Provider).

        ```js theme={null}
        const provider = new quais.JsonRpcProvider('https://rpc.quai.network', undefined, { usePathing: true })

        // initialize wallet
        const wallet = new quais.Wallet(privateKey, provider)

        // initialize HD wallet
        const hdWallet = quais.QuaiHDWallet.fromMnemonic(mnemonic)
        await hdWallet.connect(provider)
        ```
      </Step>

      <Step title="Build Transaction">
        Then, build the transaction you want to send using the [QuaiTransactionRequest](/sdk/content/type-aliases/TransactionRequest) type.

        ```ts theme={null}
        // get to address from wallet
        const from = wallet.getAddress()

        // get to address from HD wallet
        const addressInfo = hdWallet.getAddressNextAddress(0, quais.Zone.Cyprus1)
        const from = addressInfo.address

        // build simple transfer transaction
        const txData: QuaiTransactionRequest{
          from,
          to: "0x002F4783248e2D6FF1aa6482A8C0D7a76de3C329",
          value: quais.parseQuai("1.0"),
        }
        ```

        <Tip>
          The above transaction is a simple value transfer. Additional transaction params for more complex transactions can be found in the [QuaiTransaction](/sdk/content/classes/QuaiTransaction) class.
        </Tip>
      </Step>

      <Step title="Send and Sign Transaction">
        Finally, sign and broadcast the transaction using your wallet of choice.

        ```js theme={null}
        // send transaction with wallet
        const tx = await wallet.sendTransaction(txData)
        const txReceipt = await tx.wait()

        // send transaction with HD wallet
        const tx = await hdWallet.sendTransaction(txData)
        const txReceipt = await tx.wait()
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="Qi Transactions">
    <Steps>
      <Step title="Configure Wallet">
        To send a Qi transaction, you'll first need to connect a [QiHDWallet](/sdk/content/classes/QiHDWallet) to a [Provider](/sdk/content/interfaces/Provider) and sync the UTXO set.

        ```js theme={null}
        const provider = new quais.JsonRpcProvider('https://rpc.quai.network', undefined, { usePathing: true })

        // initialize HD wallet
        const hdWallet = quais.QiHDWallet.fromMnemonic(mnemonic)

        // connect to provider and sync UTXO set
        await hdWallet.connect(provider)
        await hdWallet.scan(quais.Zone.Cyprus1)
        ```

        Syncing the UTXO set will retrieve standard and change addresses, as well as scan the specified account for addresses with unspent outputs. You'll need the wallet outpoints and addresses to build a transaction.
      </Step>

      <Step title="Build Transaction">
        Using the addresses and outpoints from the UTXO set, build the transaction you want to send using the [QiTransactionRequest](/sdk/content/type-aliases/QiTransactionRequest) type.

        ```js theme={null}
        // get from address from HD wallet
        const addressInfo = hdWallet.getAddressNextAddress(0, quais.Zone.Cyprus1)
        const from = addressInfo.address

        // get outpoints for a specified zone
        const outpoints = hdWallet.getOutpoints(quais.Zone.Cyprus1)

        // build transaction
        const txData: QiTransactionRequest = {
          txInputs: outpoints[0]
          txOutputs: { address: "0x002F4783248e2D6FF1aa6482A8C0D7a76de3C329", denomination: 7 },
        }
        ```
      </Step>

      <Step title="Send and Sign Transaction">
        Finally, sign and broadcast the transaction.

        ```js theme={null}
        // send transaction with HD wallet
        const tx = await hdWallet.sendTransaction(txData)
        const txReceipt = await tx.wait()
        ```
      </Step>
    </Steps>
  </Tab>
</Tabs>


# Wallet Management
Source: https://docs.qu.ai/sdk/static/examples/wallet-management

Manage Qi and Quai HD wallets.

<Tip>For more high level overview on what wallets are available in the SDK, see the [Wallet fundamentals page](/sdk/static/wallet).</Tip>

<Tabs>
  <Tab title="Quai Wallets">
    The [QiHDWallet](/sdk/content/classes/QiHDWallet) class provides additional low-level functionality on top of the base [Wallet](/sdk/content/classes/Wallet) class, allowing for more granular control and wallet management.

    ## Initialize a Quai HD Wallet

    You can initialize a Quai HD wallet by creating a new instance from a mnemonic:

    ```js theme={null}
    const quais = require('quais')

    // seed phrase
    const phrase = 'pill tomorrow foster begin walnut borrow virtual kick shift mutual shoe scatter'

    // initialize HD wallet from mnemonic
    const mnemonic = quais.Mnemonic.fromPhrase(phrase)
    const quaiWallet = quais.QuaiHDWallet.fromMnemonic(mnemonic)
    ```

    <Warning>
      It is highly recommended to **import secret phrases securely** from environment variables or files.
    </Warning>

    ## Derive Addresses

    Quai HD wallets allow for derivation of multiple accounts, addresses, and specific zones from a single mnemonic as specified by [BIP-32](https://en.bitcoin.it/wiki/BIP_0032).

    ```js theme={null}
    // derive new address for account '0' in 'Cyprus1' zone
    const addressInfo1 = await quaiWallet.getNextAddress(0, quais.Zone.Cyprus1)

    // derive new address for account '1' in 'Cyrpus2' zone
    const addressInfo2 = await quaiWallet.getNextAddress(1, quais.Zone.Cyprus2)
    ```

    The HD Wallet also provides a number of methods to return data for derived addresses by certain filters:

    ```js theme={null}
    // get address info for account '0' new address '1'
    const addressInfo = quaiWallet.getAddressInfo(addressInfo1.address)

    // get all addresses for account '0' in 'Cyprus1' zone
    const cyprus1addressInfo = quaiWallet.getAddressesForZone(quais.Zone.Cyprus1)

    // get all addresses for account '0'
    const account0Addresses = quaiWallet.getAddressesForAccount(0)
    ```

    ## Storage and Transmission

    Wallet storage and transmission can be securely done using a serialized representation of the wallet. The HD wallet provides functionality for both serializing and deserializing the wallet.

    ```js theme={null}
    // serialize current (account/address) state of the wallet
    const serializedWallet = quaiWallet.serialize()

    // deserialize wallet from serialized data
    const deserializedWallet = quais.QuaiHDWallet.deserialize(serializedWallet)
    ```
  </Tab>

  <Tab title="Qi Wallets">
    The [QiHDWallet](/sdk/content/classes/QiHDWallet) class manages Qi UTXO accounts and addresses.

    ## Initialize a Qi HD Wallet

    You can initialize a Qi HD wallet by creating a new instance from a mnemonic and syncing the UTXO set:

    ```js theme={null}
    const quais = require('quais')

     // seed phrase
    const phrase = 'pill tomorrow foster begin walnut borrow virtual kick shift mutual shoe scatter'

    // initialize provider
    const provider = new quais.JsonRpcProvider('https://rpc.quai.network', undefined, { usePathing: true })

    // initialize HD wallet from mnemonic
    const mnemonic = quais.Mnemonic.fromPhrase(phrase)
    const qiWallet = quais.QiHDWallet.fromMnemonic(mnemonic)

    // connect to provider and sync UTXO set
    await qiWallet.connect(provider)
    await qiWallet.scan(quais.Zone.Cyprus1)
    ```

    To use a Qi HD wallet, you must first connect to a provider and sync the UTXO set. This will retrieve standard and change addresses, as well as scan the specified account for addresses with unspent outputs.

    <Warning>
      It is highly recommended to **import secret phrases securely** from environment variables or files.
    </Warning>

    Once scanning is complete, the addresses and outpoints can be retrieved using the following methods:

    ```js theme={null}
    // get standard and change addresses
    let addresses = qiWallet.getAddressesForZone(quais.Zone.Cyprus1);
    let changeAddresses = qiWallet.getChangeAddressesForZone(quais.Zone.Cyprus1);

    const address1 = addresses[0].address

    // get outpoints for a specified zone
    let zoneOutpoints = qiWallet.getOutpoints(quais.Zone.Cyprus1);
    let addressOutpoints = qiWallet.getOutpointsByAddress(address1);
    ```

    ## Derive Addresses

    Qi HD wallets allow for derivation of multiple accounts, addresses, and specific zones from a single mnemonic as specified by [BIP-32](https://en.bitcoin.it/wiki/BIP_0032).

    ```js theme={null}
      // derive new address for account '0' and zone 'Cyprus1'
    let newAddrInfo = await qiWallet.getNextAddress(0,quais.Zone.Cyprus1);

    // derive new change address for account '1' and zone 'Cyprus2'
    let newChangeAddrInfo = await qiWallet.getNextChangeAddress(1, quais.Zone.Cyprus2);
    ```

    ## Storage and Transmission

    Wallet storage and transmission can be securely done using a serialized representation of the wallet. The HD wallet provides functionality for both serializing and deserializing the wallet.

    ```js theme={null}
    // serialize current (account/address) state of the wallet
    const serializedWallet = qiWallet.serialize()

    // deserialize wallet from serialized data
    const deserializedWallet = quais.QiHDWallet.deserialize(serializedWallet)
    ```
  </Tab>
</Tabs>


# Providers
Source: https://docs.qu.ai/sdk/static/provider

Configure and utilize a Provider to interact with Quai Network.

## Overview

**A Provider establishes a connection to the blockchain**, whch can be used to query its current state, simulate execution and send transactions to update the state.

Providers are one of the most fundamental components of interacting with a blockchain application, and there are many ways to connect, such as *over HTTP*, *WebSockets* or *injected providers such as Pelagus*.

## Usage

There are two types of network providers you can connect to:

* **Remote Node Providers**: any remote node that is open to data requests
* **Browser/Injected Providers**: typically wallet interfaces used in browser Applications

### Remote Node Provider

To connect to a remote node provider, use the [JsonRpcProvider](/sdk/content/classes/JsonRpcProvider) or [WebSocketProvider](/sdk/content/classes/WebSocketProvider) classes. This connects to a remote node using the JSON-RPC interface. **Remote node providers will never have a signer bundled into them**.

Quais providers are configured to first ask the node which shards it is currently running, and then establish a connection to each of those chains. This is done using

* Via [reverse proxy pathing](https://github.com/dominant-strategies/quai-nginx)
  * Available using the Colosseum RPC endpoint with `https` and `wss`

```js theme={null}
import { quais } from 'quais'


// configure a multi-shard JSON-RPC provider using the dev rpc and pathing
const provider = new quais.JsonRpcProvider('https://rpc.quai.network', undefined, { usePathing: true })

// configure a multi-shard WebSocket provider using the dev rpc and pathing
const provider = new quais.WebSocketProvider('wss://rpc.quai.network', undefined, { usePathing: true })
```

### Injected Provider

There are multiple ways to configure a network provider using the [Provider](/sdk/content/interfaces/Provider) interface.

To connect to a browser wallet provider like Pelagus, use the [BrowserProvider](/sdk/content/classes/BrowserProvider) class. Pelagus bundles a Signer into the injected provider that can be used to sign transactions.

```js theme={null}
import { quais } from 'quais'

// configure pelagus as the provider
const provider = new quais.BrowserProvider(window.pelagus)

// get the signer
const signer = provider.getSigner()
```


# Transactions
Source: https://docs.qu.ai/sdk/static/transactions

Build and sign transactions on Quai Network.

## Overview

Transactions are a fundamental piece of Quai Network. **Every state-changing operation within the network requires a signed transaction**.

The Quais SDK provides utilities for building and signing transactions, with support for all 3 types of transactions.

<CardGroup>
  <Card title="Quai Transactions" icon="arrow-right" href="/sdk/content/classes/QuaiTransaction">
    EVM like transactions processed on the Quai Ledger
  </Card>

  <Card title="Qi Transactions" icon="arrow-left" href="/sdk/content/classes/QiTransaction">
    UTXO style transactions processed on the Qi Ledger
  </Card>

  <Card title="External Transactions" href="/learn/advanced-introduction/interoperability/etxs" icon="right-left">
    Either a Quai or Qi transaction moving from one zone chain to another
  </Card>
</CardGroup>

## Usage

In practice, developers will only ever need to compose Quai or Qi transactions. External transactions are created and routed automatically by the network, given the sender and reciever addresses of a given transaction.

### Quai Transaction

The [QuaiTransactionRequest](/sdk/content/type-aliases/TransactionRequest) type is used to build all types of Quai transactions. They can be signed and broadcasted to the network using a [Wallet](/sdk/content/classes/Wallet), [QuaiHDWallet](/sdk/content/classes/QuaiHDWallet), or [Signer](/sdk/content/classes/Signer).

Quai transactions are signed using [ECDSA signatures](https://en.wikipedia.org/wiki/Elliptic_Curve_Digital_Signature_Algorithm).

```ts theme={null}
const tx: QuaiTransactionRequest = {
	to: '0x0012345678901234567890123456789012345678',
	value: parseQuai('1.0'),
	data: '0x',
}

await wallet.sendTransaction(tx)
```

### Qi Transaction

The [QiTransactionRequest](/sdk/content/type-aliases/TransactionRequest) type is used to build Qi UTXO transactions. These transactions can be signed and broadcasted to the network using a [QiHDWallet](/sdk/content/classes/QiHDWallet).

Qi transactions are signed using [MuSig signatures](https://bitcoinops.org/en/topics/musig/).

<Warning>
  Qi transactions are still being developed. They are currently supported by the SDK, but are subject to change.
</Warning>

```ts theme={null}
const tx: QiTransactionRequest = {
  txInputs: [...],
  txOutputs: [...],
}

await QiHDWallet.sendTransaction(tx)
```


# Wallets
Source: https://docs.qu.ai/sdk/static/wallet

A combination of generalized and low-level wallet tools.

## Overview

When interacting with either Qi or Quai, it is necessary to use a private key authenticate actions by signing a payload.

**Wallets are the simplest way** to expose the concept of an Externally Owner Account (EOA) or UTXO account as it wraps a private key and supports high-level methods to sign common types of interaction and send transactions.

The class most developers will want to use is [Wallet](/sdk/content/classes/Wallet), **which can load a private key directly or from any common wallet format**.

The SDK also supports Hierarchical Deterministic (HD) wallets for both Quai and Qi ledgers. Developers who need access to low-level wallet details can opt to use the [QuaiHDWallet](/sdk/content/classes/QuaiHDWallet) and [QiHDWallet](/sdk/content/classes/QiHDWallet) classes.

## Usage

Developers working on the account model Quai ledger have two options for wallet configurations:

* **Base Wallet**: The simplest implementation of a Quai Wallet
* **Quai HD Wallet**: A Hierarchical Deterministic (HD) wallet for the Quai ledger

Developers working on the UTXO model Qi ledger currently have a single option for wallet configuration:

* **Qi HD Wallet**: A Hierarchical Deterministic (HD) wallet for the Qi ledger

### Quai Wallets

Quai wallets can be initialized using either the [Wallet](/sdk/content/classes/Wallet) class or the [QuaiHDWallet](/sdk/content/classes/QuaiHDWallet) class.

The simplest wallet configuration is using the **Wallet** class. All that is needed to initiate a wallet is a private key and a provider. Once configured, the wallet acts similar to a [Signer](/sdk/content/classes/Signer).

```js theme={null}
import { Wallet } from 'quais'

// initialize wallet from private key
const wallet = new Wallet(privateKey, provider)
```

The [QuaiHDWallet](/sdk/content/classes/QuaiHDWallet) class provides additional low-level functionality on top of the base [Wallet](/sdk/content/classes/Wallet) class, allowing for more granular control.

```js theme={null}
import { QuaiHDWallet, Zone } from 'quais'

// initialize HD wallet
const QuaiWallet = new QuaiHDWallet()

// get the first address in Paxos2 zone
const paxos2Address = QuaiWallet.getNextAddress(0, Zone.Paxos2)

// serialize current (account/address) state of the wallet
const serializedWallet = QuaiWallet.serialize() 
```

### Qi Wallets

Qi wallets **can only be initialized** using the [QiHDWallet](/sdk/content/classes/QiHDWallet) class.

```js theme={null}
import { QiHDWallet, Zone } from 'quais'

// initialize HD wallet
const QiWallet = new QiHDWallet()

// get the first address in Cyrpus1 zone
const cyrpus1Address = QiWallet.getNextAddress(0, Zone.Cyrpus1)

// serialize current (account/address) state of the wallet
const serializedWallet = QiWallet.serialize() 
```


# AbstractProvider
Source: https://docs.qu.ai/sdk/content/classes/AbstractProvider



An **AbstractProvider** provides a base class for other sub-classes to implement the [**Provider**](/sdk/content/interfaces/Provider)
API by normalizing input arguments and formatting output results as well as tracking events for consistent behaviour
on an eventually-consistent network.

## Extended by

* [`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider)

## Type parameters

| Type parameter | Value                                               |
| :------------- | :-------------------------------------------------- |
| `C`            | [`FetchRequest`](/sdk/content/classes/FetchRequest) |

## Implements

* [`Provider`](/sdk/content/interfaces/Provider)

## Constructors

### new AbstractProvider()

```ts theme={null}
new AbstractProvider<C>(_network?, options?): AbstractProvider<C>
```

Create a new **AbstractProvider** connected to `network`, or use the various network detection capabilities to
discover the [**Network**](/sdk/content/classes/Network) if necessary.

#### Parameters

| Parameter   | Type                                                 | Description                              |
| :---------- | :--------------------------------------------------- | :--------------------------------------- |
| `_network`? | [`Networkish`](/sdk/content/type-aliases/Networkish) | The network to connect to, or `"any"` to |
| `options`?  | `AbstractProviderOptions`                            | The options to configure the provider.   |

#### Returns

[`AbstractProvider`](/sdk/content/classes/AbstractProvider)\<`C`>

#### Source

[providers/abstract-provider.ts:826](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L826)

## Accessors

### connect

```ts theme={null}
get connect(): FetchRequest[]
```

Get the list of connected FetchRequests.

#### Returns

[`FetchRequest`](/sdk/content/classes/FetchRequest)\[]

The list of connected FetchRequests.

#### Source

[providers/abstract-provider.ts:1026](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1026)

***

### destroyed

```ts theme={null}
get destroyed(): boolean
```

If this provider has been destroyed using the [**destroy**](/sdk/content/classes/AbstractProvider#destroy) method.

Once destroyed, all resources are reclaimed, internal event loops and timers are cleaned up and no further
requests may be sent to the provider.

#### Returns

`boolean`

#### Source

[providers/abstract-provider.ts:2545](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L2545)

***

### paused

```ts theme={null}
get paused(): boolean
```

Whether the provider is currently paused.

A paused provider will not emit any events, and generally should not make any requests to the network, but that
is up to sub-classes to manage.

Setting `paused = true` is identical to calling `.pause(false)`, which will buffer any events that occur while
paused until the provider is unpaused.

#### Returns

`boolean`

Whether the provider is paused.

#### Source

[providers/abstract-provider.ts:2577](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L2577)

***

### pollingInterval

```ts theme={null}
get pollingInterval(): number
```

Get the polling interval.

#### Returns

`number`

The polling interval.

#### Source

[providers/abstract-provider.ts:1183](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1183)

***

### provider

```ts theme={null}
get provider(): this
```

Returns `this`, to allow an **AbstractProvider** to implement the [Contract Runner](../classes/ContractRunner)
interface.

#### Returns

`this`

The provider instance.

#### Source

[providers/abstract-provider.ts:1193](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1193)

## Methods

### \_clearTimeout()

```ts theme={null}
_clearTimeout(timerId): void
```

Clear a timer created using the AbstractProvider.\_setTimeout | **\_setTimeout** method.

#### Parameters

| Parameter | Type     | Description                   |
| :-------- | :------- | :---------------------------- |
| `timerId` | `number` | The ID of the timer to clear. |

#### Returns

`void`

#### Source

[providers/abstract-provider.ts:2221](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L2221)

***

### destroy()

```ts theme={null}
destroy(): void
```

Sub-classes may use this to shutdown any sockets or release their resources and reject any pending requests.

Sub-classes **must** call `super.destroy()`.

#### Returns

`void`

#### Implementation of

[`Provider`](/sdk/content/interfaces/Provider).[`destroy`](/sdk/content/interfaces/Provider#destroy)

#### Source

[providers/abstract-provider.ts:2554](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L2554)

***

### getActiveRegions()

```ts theme={null}
getActiveRegions(): Promise<Shard[]>
```

Get the active region shards based on the protocol expansion number.

#### Returns

`Promise`\<[`Shard`](/sdk/content/enumerations/Shard)\[]>

A promise that resolves to the active shards.

#### Source

[providers/abstract-provider.ts:1110](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1110)

***

### getActiveZones()

```ts theme={null}
getActiveZones(): Promise<Zone[]>
```

Get the active zones for a shard based on the protocol expansion number.

#### Returns

`Promise`\<[`Zone`](/sdk/content/enumerations/Zone)\[]>

A promise that resolves to the active zones.

#### Source

[providers/abstract-provider.ts:1127](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1127)

***

### getLatestQiToQuaiRate()

```ts theme={null}
getLatestQiToQuaiRate(zone, amt?): Promise<bigint>
```

Get the latest Qi rate for a zone.

#### Parameters

| Parameter | Type                                     | Description                                    |
| :-------- | :--------------------------------------- | :--------------------------------------------- |
| `zone`    | [`Zone`](/sdk/content/enumerations/Zone) | The zone to get the rate for.                  |
| `amt`?    | `bigint`                                 | The amount to get the rate for. Default is `1` |

#### Returns

`Promise`\<`bigint`>

A promise that resolves to the latest Qi rate.

#### Implementation of

[`Provider`](/sdk/content/interfaces/Provider).[`getLatestQiToQuaiRate`](/sdk/content/interfaces/Provider#getlatestqitoquairate)

#### Source

[providers/abstract-provider.ts:1149](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1149)

***

### getLatestQuaiToQiRate()

```ts theme={null}
getLatestQuaiToQiRate(zone, amt?): Promise<bigint>
```

Get the latest Quai rate for a zone.

#### Parameters

| Parameter | Type                                     | Description                                             |
| :-------- | :--------------------------------------- | :------------------------------------------------------ |
| `zone`    | [`Zone`](/sdk/content/enumerations/Zone) | The zone to get the rate for.                           |
| `amt`?    | `bigint`                                 | The amount in quais to get the rate for. Default is `1` |

#### Returns

`Promise`\<`bigint`>

A promise that resolves to the latest Quai -> Qi rate for the given amount.

#### Implementation of

[`Provider`](/sdk/content/interfaces/Provider).[`getLatestQuaiToQiRate`](/sdk/content/interfaces/Provider#getlatestquaitoqirate)

#### Source

[providers/abstract-provider.ts:1068](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1068)

***

### getProtocolExpansionNumber()

```ts theme={null}
getProtocolExpansionNumber(): Promise<number>
```

Get the protocol expansion number.

#### Returns

`Promise`\<`number`>

A promise that resolves to the protocol expansion number.

#### Implementation of

[`Provider`](/sdk/content/interfaces/Provider).[`getProtocolExpansionNumber`](/sdk/content/interfaces/Provider#getprotocolexpansionnumber)

#### Source

[providers/abstract-provider.ts:1101](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1101)

***

### getQiToQuaiRateAtBlock()

```ts theme={null}
getQiToQuaiRateAtBlock(
   zone, 
   blockTag, 
amt?): Promise<bigint>
```

Get the Qi rate at a specific block.

#### Parameters

| Parameter  | Type                                             | Description                                    |
| :--------- | :----------------------------------------------- | :--------------------------------------------- |
| `zone`     | [`Zone`](/sdk/content/enumerations/Zone)         | The zone to get the rate for.                  |
| `blockTag` | [`BlockTag`](/sdk/content/type-aliases/BlockTag) | The block tag to get the rate at.              |
| `amt`?     | `bigint`                                         | The amount to get the rate for. Default is `1` |

#### Returns

`Promise`\<`bigint`>

A promise that resolves to the Qi rate at the specified block.

#### Implementation of

[`Provider`](/sdk/content/interfaces/Provider).[`getQiToQuaiRateAtBlock`](/sdk/content/interfaces/Provider#getqitoquairateatblock)

#### Source

[providers/abstract-provider.ts:1162](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1162)

***

### getQuaiToQiRateAtBlock()

```ts theme={null}
getQuaiToQiRateAtBlock(
   zone, 
   blockTag, 
amt?): Promise<bigint>
```

Get the Quai rate at a specific block.

#### Parameters

| Parameter  | Type                                             | Description                                    |
| :--------- | :----------------------------------------------- | :--------------------------------------------- |
| `zone`     | [`Zone`](/sdk/content/enumerations/Zone)         | The zone to get the rate for.                  |
| `blockTag` | [`BlockTag`](/sdk/content/type-aliases/BlockTag) | The block tag to get the rate at.              |
| `amt`?     | `bigint`                                         | The amount to get the rate for. Default is `1` |

#### Returns

`Promise`\<`bigint`>

A promise that resolves to the Quai rate at the specified block.

#### Implementation of

[`Provider`](/sdk/content/interfaces/Provider).[`getQuaiToQiRateAtBlock`](/sdk/content/interfaces/Provider#getquaitoqirateatblock)

#### Source

[providers/abstract-provider.ts:1081](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1081)

***

### initialize()

```ts theme={null}
initialize<U>(urls): Promise<void>
```

Initialize the URL map with the provided URLs.

#### Type parameters

| Type parameter | Value                                                              |
| :------------- | :----------------------------------------------------------------- |
| `U`            | `string`\[] \| [`FetchRequest`](/sdk/content/classes/FetchRequest) |

#### Parameters

| Parameter | Type | Description                          |
| :-------- | :--- | :----------------------------------- |
| `urls`    | `U`  | The URLs to initialize the map with. |

#### Returns

`Promise`\<`void`>

A promise that resolves when the map is initialized.

#### Source

[providers/abstract-provider.ts:874](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L874)

***

### pause()

```ts theme={null}
pause(dropWhilePaused?): void
```

Pause the provider. If `dropWhilePaused`, any events that occur while paused are dropped, otherwise all events
will be emitted once the provider is unpaused.

#### Parameters

| Parameter          | Type      | Description                          |
| :----------------- | :-------- | :----------------------------------- |
| `dropWhilePaused`? | `boolean` | Whether to drop events while paused. |

#### Returns

`void`

#### Source

[providers/abstract-provider.ts:2598](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L2598)

***

### resume()

```ts theme={null}
resume(): void
```

Resume the provider.

#### Returns

`void`

#### Source

[providers/abstract-provider.ts:2627](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L2627)

***

### shardFromHash()

```ts theme={null}
shardFromHash(hash): Shard
```

Get the shard from a hash.

#### Parameters

| Parameter | Type     | Description                     |
| :-------- | :------- | :------------------------------ |
| `hash`    | `string` | The hash to get the shard from. |

#### Returns

[`Shard`](/sdk/content/enumerations/Shard)

The shard.

#### Source

[providers/abstract-provider.ts:1047](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1047)

***

### zoneFromAddress()

```ts theme={null}
zoneFromAddress(_address): Promise<Zone>
```

Get the zone from an address.

#### Parameters

| Parameter  | Type                                                   | Description                       |
| :--------- | :----------------------------------------------------- | :-------------------------------- |
| `_address` | [`AddressLike`](/sdk/content/type-aliases/AddressLike) | The address to get the zone from. |

#### Returns

`Promise`\<[`Zone`](/sdk/content/enumerations/Zone)>

A promise that resolves to the zone.

#### Source

[providers/abstract-provider.ts:1036](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1036)

***

### zoneFromHash()

```ts theme={null}
zoneFromHash(hash): Zone
```

Get the zone from a hash.

#### Parameters

| Parameter | Type     | Description                    |
| :-------- | :------- | :----------------------------- |
| `hash`    | `string` | The hash to get the zone from. |

#### Returns

[`Zone`](/sdk/content/enumerations/Zone)

The zone.

#### Source

[providers/abstract-provider.ts:1057](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1057)


# AbstractSigner
Source: https://docs.qu.ai/sdk/content/classes/AbstractSigner



An **AbstractSigner** includes most of teh functionality required to get a [**Signer**](/sdk/content/interfaces/Signer) working as
expected, but requires a few Signer-specific methods be overridden.

## Extended by

* [`JsonRpcSigner`](/sdk/content/classes/JsonRpcSigner)
* [`VoidSigner`](/sdk/content/classes/VoidSigner)

## Type parameters

| Type parameter                                                         | Value                                                    |
| :--------------------------------------------------------------------- | :------------------------------------------------------- |
| `P` *extends* `null` \| [`Provider`](/sdk/content/interfaces/Provider) | `null` \| [`Provider`](/sdk/content/interfaces/Provider) |

## Implements

* [`Signer`](/sdk/content/interfaces/Signer)

## Constructors

### new AbstractSigner()

```ts theme={null}
new AbstractSigner<P>(provider?): AbstractSigner<P>
```

Creates a new Signer connected to `provider`.

#### Parameters

| Parameter   | Type |
| :---------- | :--- |
| `provider`? | `P`  |

#### Returns

[`AbstractSigner`](/sdk/content/classes/AbstractSigner)\<`P`>

#### Source

[signers/abstract-signer.ts:63](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/signers/abstract-signer.ts#L63)

## Properties

| Property   | Modifier   | Type | Description                               |
| :--------- | :--------- | :--- | :---------------------------------------- |
| `provider` | `readonly` | `P`  | The provider this signer is connected to. |

## Methods

### connect()

```ts theme={null}
abstract connect(provider): Signer
```

Returns the signer connected to `provider`.

This may throw, for example, a Signer connected over a Socket or to a specific instance of a node may not be
transferrable.

#### Parameters

| Parameter  | Type                                                     | Description                 |
| :--------- | :------------------------------------------------------- | :-------------------------- |
| `provider` | `null` \| [`Provider`](/sdk/content/interfaces/Provider) | The provider to connect to. |

#### Returns

[`Signer`](/sdk/content/interfaces/Signer)

The connected signer.

#### Implementation of

[`Signer`](/sdk/content/interfaces/Signer).[`connect`](/sdk/content/interfaces/Signer#connect)

#### Source

[signers/abstract-signer.ts:92](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/signers/abstract-signer.ts#L92)

***

### getAddress()

```ts theme={null}
abstract getAddress(): Promise<string>
```

Resolves to the Signer address.

#### Returns

`Promise`\<`string`>

#### Implementation of

[`Signer`](/sdk/content/interfaces/Signer).[`getAddress`](/sdk/content/interfaces/Signer#getaddress)

#### Source

[signers/abstract-signer.ts:70](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/signers/abstract-signer.ts#L70)


# Block
Source: https://docs.qu.ai/sdk/content/classes/Block



A **Block** represents the data associated with a full block on Ethereum.

## Extended by

* [`MinedBlock`](/sdk/content/interfaces/MinedBlock)

## Implements

* [`BlockParams`](/sdk/content/interfaces/BlockParams)
* `Iterable`\<`string`>

## Constructors

### new Block()

```ts theme={null}
new Block(block, provider): Block
```

Create a new **Block** object.

This should generally not be necessary as the unless implementing a low-level library.

#### Parameters

| Parameter  | Type                                                 | Description           |
| :--------- | :--------------------------------------------------- | :-------------------- |
| `block`    | [`BlockParams`](/sdk/content/interfaces/BlockParams) | The block parameters. |
| `provider` | [`Provider`](/sdk/content/interfaces/Provider)       | The provider.         |

#### Returns

[`Block`](/sdk/content/classes/Block)

#### Source

[providers/provider.ts:627](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L627)

## Properties

| Property   | Modifier   | Type                                           | Description                                                                        |
| :--------- | :--------- | :--------------------------------------------- | :--------------------------------------------------------------------------------- |
| `provider` | `readonly` | [`Provider`](/sdk/content/interfaces/Provider) | The provider connected to the block used to fetch additional details if necessary. |

## Accessors

### date

```ts theme={null}
get date(): null | Date
```

The [Date](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date) this block was
included at.

#### Returns

`null` | `Date`

The date this block was included at, or null if the timestamp is not available.

#### Source

[providers/provider.ts:826](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L826)

***

### length

```ts theme={null}
get length(): number
```

The number of transactions in this block.

#### Returns

`number`

The number of transactions.

#### Source

[providers/provider.ts:816](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L816)

***

### outboundEtxs

```ts theme={null}
get outboundEtxs(): readonly string[]
```

Returns the list of extended transaction hashes, in the order they were executed within the block.

#### Returns

readonly `string`\[]

The list of extended transaction hashes.

#### Source

[providers/provider.ts:689](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L689)

***

### prefetchedExtTransactions

```ts theme={null}
get prefetchedExtTransactions(): ExternalTransactionResponse[]
```

Returns the complete extended transactions, in the order they were executed within the block.

This is only available for blocks which prefetched transactions, by passing `true` to `prefetchTxs` into
[**getBlock**](/sdk/content/interfaces/Provider#getblock).

#### Throws

If the transactions were not prefetched.

#### Returns

`ExternalTransactionResponse`\[]

The list of prefetched extended transactions.

#### Source

[providers/provider.ts:737](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L737)

***

### prefetchedTransactions

```ts theme={null}
get prefetchedTransactions(): TransactionResponse[]
```

Returns the complete transactions, in the order they were executed within the block.

This is only available for blocks which prefetched transactions, by passing `true` to `prefetchTxs` into
[**getBlock**](/sdk/content/interfaces/Provider#getblock).

#### Throws

If the transactions were not prefetched.

#### Returns

[`TransactionResponse`](/sdk/content/type-aliases/TransactionResponse)\[]

The list of prefetched transactions.

#### Source

[providers/provider.ts:707](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L707)

***

### transactions

```ts theme={null}
get transactions(): readonly string[]
```

Returns the list of transaction hashes, in the order they were executed within the block.

#### Returns

readonly `string`\[]

The list of transaction hashes.

#### Source

[providers/provider.ts:675](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L675)

## Methods

### getExtTransaction()

```ts theme={null}
getExtTransaction(indexOrHash): Promise<ExternalTransactionResponse>
```

Get the extended transaction at `index` within this block.

#### Parameters

| Parameter     | Type                 | Description                                    |
| :------------ | :------------------- | :--------------------------------------------- |
| `indexOrHash` | `string` \| `number` | The index or hash of the extended transaction. |

#### Returns

`Promise`\<`ExternalTransactionResponse`>

A promise resolving to the extended transaction.

#### Throws

If the extended transaction is not found.

#### Source

[providers/provider.ts:883](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L883)

***

### getPrefetchedTransaction()

```ts theme={null}
getPrefetchedTransaction(indexOrHash): TransactionResponse
```

If a **Block** was fetched with a request to include the transactions this will allow synchronous access to those
transactions.

If the transactions were not prefetched, this will throw.

#### Parameters

| Parameter     | Type                 | Description                           |
| :------------ | :------------------- | :------------------------------------ |
| `indexOrHash` | `string` \| `number` | The index or hash of the transaction. |

#### Returns

[`TransactionResponse`](/sdk/content/type-aliases/TransactionResponse)

The transaction.

#### Throws

If the transaction is not found.

#### Source

[providers/provider.ts:927](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L927)

***

### getTransaction()

```ts theme={null}
getTransaction(indexOrHash): Promise<TransactionResponse | ExternalTransactionResponse>
```

Get the transaction at `index` within this block.

#### Parameters

| Parameter     | Type                 | Description                           |
| :------------ | :------------------- | :------------------------------------ |
| `indexOrHash` | `string` \| `number` | The index or hash of the transaction. |

#### Returns

`Promise`\<[`TransactionResponse`](/sdk/content/type-aliases/TransactionResponse) | `ExternalTransactionResponse`>

A promise resolving to the transaction.

#### Throws

If the transaction is not found.

#### Source

[providers/provider.ts:842](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L842)

***

### isMined()

```ts theme={null}
isMined(): this is MinedBlock
```

Returns true if this block been mined. This provides a type guard for all properties on a
[**MinedBlock**](/sdk/content/interfaces/MinedBlock).

#### Returns

`this is MinedBlock`

True if the block has been mined.

#### Source

[providers/provider.ts:949](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L949)

***

### toJSON()

```ts theme={null}
toJSON(): BlockParams
```

Returns a JSON-friendly value.

#### Returns

[`BlockParams`](/sdk/content/interfaces/BlockParams)

The JSON-friendly value.

#### Source

[providers/provider.ts:763](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L763)


# BrowserProvider
Source: https://docs.qu.ai/sdk/content/classes/BrowserProvider



A **BrowserProvider** is intended to wrap an injected provider which adheres to the
[EIP-1193](https://eips.ethereum.org/EIPS/eip-1193) standard, which most (if not all) currently do.

## Extends

* [`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider)

## Constructors

### new BrowserProvider()

```ts theme={null}
new BrowserProvider(ethereum, network?): BrowserProvider
```

Connect to the `ethereum` provider, optionally forcing the `network`.

#### Parameters

| Parameter  | Type                                                         | Description                |
| :--------- | :----------------------------------------------------------- | :------------------------- |
| `ethereum` | [`Eip1193Provider`](/sdk/content/interfaces/Eip1193Provider) | The EIP-1193 provider.     |
| `network`? | [`Networkish`](/sdk/content/type-aliases/Networkish)         | The network to connect to. |

#### Returns

[`BrowserProvider`](/sdk/content/classes/BrowserProvider)

#### Overrides

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`constructor`](/sdk/content/classes/JsonRpcApiProvider#constructors)

#### Source

[providers/provider-browser.ts:72](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-browser.ts#L72)

## Accessors

### connect

```ts theme={null}
get connect(): FetchRequest[]
```

Get the list of connected FetchRequests.

#### Returns

[`FetchRequest`](/sdk/content/classes/FetchRequest)\[]

The list of connected FetchRequests.

#### Source

[providers/abstract-provider.ts:1026](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1026)

***

### destroyed

```ts theme={null}
get destroyed(): boolean
```

If this provider has been destroyed using the [**destroy**](/sdk/content/classes/AbstractProvider#destroy) method.

Once destroyed, all resources are reclaimed, internal event loops and timers are cleaned up and no further
requests may be sent to the provider.

#### Returns

`boolean`

#### Source

[providers/abstract-provider.ts:2545](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L2545)

***

### paused

```ts theme={null}
get paused(): boolean
```

Whether the provider is currently paused.

A paused provider will not emit any events, and generally should not make any requests to the network, but that
is up to sub-classes to manage.

Setting `paused = true` is identical to calling `.pause(false)`, which will buffer any events that occur while
paused until the provider is unpaused.

#### Returns

`boolean`

Whether the provider is paused.

#### Source

[providers/abstract-provider.ts:2577](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L2577)

***

### pollingInterval

```ts theme={null}
get pollingInterval(): number
```

Get the polling interval.

#### Returns

`number`

The polling interval.

#### Source

[providers/abstract-provider.ts:1183](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1183)

***

### provider

```ts theme={null}
get provider(): this
```

Returns `this`, to allow an **AbstractProvider** to implement the [Contract Runner](../classes/ContractRunner)
interface.

#### Returns

`this`

The provider instance.

#### Source

[providers/abstract-provider.ts:1193](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1193)

***

### ready

```ts theme={null}
get ready(): boolean
```

Returns true only if the JsonRpcApiProvider.\_start | **\_start** has been called.

#### Returns

`boolean`

True if the provider is ready.

#### Source

[providers/provider-jsonrpc.ts:1117](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L1117)

## Methods

### \_clearTimeout()

```ts theme={null}
_clearTimeout(timerId): void
```

Clear a timer created using the AbstractProvider.\_setTimeout | **\_setTimeout** method.

#### Parameters

| Parameter | Type     | Description                   |
| :-------- | :------- | :---------------------------- |
| `timerId` | `number` | The ID of the timer to clear. |

#### Returns

`void`

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`_clearTimeout`](/sdk/content/classes/JsonRpcApiProvider#_cleartimeout)

#### Source

[providers/abstract-provider.ts:2221](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L2221)

***

### destroy()

```ts theme={null}
destroy(): void
```

Destroys the provider, stopping all processing and canceling all pending requests.

#### Returns

`void`

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`destroy`](/sdk/content/classes/JsonRpcApiProvider#destroy)

#### Source

[providers/provider-jsonrpc.ts:1587](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L1587)

***

### getActiveRegions()

```ts theme={null}
getActiveRegions(): Promise<Shard[]>
```

Get the active region shards based on the protocol expansion number.

#### Returns

`Promise`\<[`Shard`](/sdk/content/enumerations/Shard)\[]>

A promise that resolves to the active shards.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`getActiveRegions`](/sdk/content/classes/JsonRpcApiProvider#getactiveregions)

#### Source

[providers/abstract-provider.ts:1110](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1110)

***

### getActiveZones()

```ts theme={null}
getActiveZones(): Promise<Zone[]>
```

Get the active zones for a shard based on the protocol expansion number.

#### Returns

`Promise`\<[`Zone`](/sdk/content/enumerations/Zone)\[]>

A promise that resolves to the active zones.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`getActiveZones`](/sdk/content/classes/JsonRpcApiProvider#getactivezones)

#### Source

[providers/abstract-provider.ts:1127](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1127)

***

### getLatestQiToQuaiRate()

```ts theme={null}
getLatestQiToQuaiRate(zone, amt?): Promise<bigint>
```

Get the latest Qi rate for a zone.

#### Parameters

| Parameter | Type                                     | Description                                    |
| :-------- | :--------------------------------------- | :--------------------------------------------- |
| `zone`    | [`Zone`](/sdk/content/enumerations/Zone) | The zone to get the rate for.                  |
| `amt`?    | `bigint`                                 | The amount to get the rate for. Default is `1` |

#### Returns

`Promise`\<`bigint`>

A promise that resolves to the latest Qi rate.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`getLatestQiToQuaiRate`](/sdk/content/classes/JsonRpcApiProvider#getlatestqitoquairate)

#### Source

[providers/abstract-provider.ts:1149](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1149)

***

### getLatestQuaiToQiRate()

```ts theme={null}
getLatestQuaiToQiRate(zone, amt?): Promise<bigint>
```

Get the latest Quai rate for a zone.

#### Parameters

| Parameter | Type                                     | Description                                             |
| :-------- | :--------------------------------------- | :------------------------------------------------------ |
| `zone`    | [`Zone`](/sdk/content/enumerations/Zone) | The zone to get the rate for.                           |
| `amt`?    | `bigint`                                 | The amount in quais to get the rate for. Default is `1` |

#### Returns

`Promise`\<`bigint`>

A promise that resolves to the latest Quai -> Qi rate for the given amount.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`getLatestQuaiToQiRate`](/sdk/content/classes/JsonRpcApiProvider#getlatestquaitoqirate)

#### Source

[providers/abstract-provider.ts:1068](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1068)

***

### getProtocolExpansionNumber()

```ts theme={null}
getProtocolExpansionNumber(): Promise<number>
```

Get the protocol expansion number.

#### Returns

`Promise`\<`number`>

A promise that resolves to the protocol expansion number.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`getProtocolExpansionNumber`](/sdk/content/classes/JsonRpcApiProvider#getprotocolexpansionnumber)

#### Source

[providers/abstract-provider.ts:1101](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1101)

***

### getQiToQuaiRateAtBlock()

```ts theme={null}
getQiToQuaiRateAtBlock(
   zone, 
   blockTag, 
amt?): Promise<bigint>
```

Get the Qi rate at a specific block.

#### Parameters

| Parameter  | Type                                             | Description                                    |
| :--------- | :----------------------------------------------- | :--------------------------------------------- |
| `zone`     | [`Zone`](/sdk/content/enumerations/Zone)         | The zone to get the rate for.                  |
| `blockTag` | [`BlockTag`](/sdk/content/type-aliases/BlockTag) | The block tag to get the rate at.              |
| `amt`?     | `bigint`                                         | The amount to get the rate for. Default is `1` |

#### Returns

`Promise`\<`bigint`>

A promise that resolves to the Qi rate at the specified block.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`getQiToQuaiRateAtBlock`](/sdk/content/classes/JsonRpcApiProvider#getqitoquairateatblock)

#### Source

[providers/abstract-provider.ts:1162](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1162)

***

### getQuaiToQiRateAtBlock()

```ts theme={null}
getQuaiToQiRateAtBlock(
   zone, 
   blockTag, 
amt?): Promise<bigint>
```

Get the Quai rate at a specific block.

#### Parameters

| Parameter  | Type                                             | Description                                    |
| :--------- | :----------------------------------------------- | :--------------------------------------------- |
| `zone`     | [`Zone`](/sdk/content/enumerations/Zone)         | The zone to get the rate for.                  |
| `blockTag` | [`BlockTag`](/sdk/content/type-aliases/BlockTag) | The block tag to get the rate at.              |
| `amt`?     | `bigint`                                         | The amount to get the rate for. Default is `1` |

#### Returns

`Promise`\<`bigint`>

A promise that resolves to the Quai rate at the specified block.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`getQuaiToQiRateAtBlock`](/sdk/content/classes/JsonRpcApiProvider#getquaitoqirateatblock)

#### Source

[providers/abstract-provider.ts:1081](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1081)

***

### getRpcError()

```ts theme={null}
getRpcError(payload, error): Error
```

Gets the RPC error.

#### Parameters

| Parameter | Type                                                         | Description           |
| :-------- | :----------------------------------------------------------- | :-------------------- |
| `payload` | [`JsonRpcPayload`](/sdk/content/type-aliases/JsonRpcPayload) | The JSON-RPC payload. |
| `error`   | [`JsonRpcError`](/sdk/content/type-aliases/JsonRpcError)     | The JSON-RPC error.   |

#### Returns

`Error`

The RPC error.

#### Overrides

`JsonRpcApiProvider.getRpcError`

#### Source

[providers/provider-browser.ts:162](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-browser.ts#L162)

***

### getSigner()

```ts theme={null}
getSigner(address?): Promise<JsonRpcSigner>
```

Gets the signer for the given address.

#### Parameters

| Parameter  | Type                 | Description                        |
| :--------- | :------------------- | :--------------------------------- |
| `address`? | `string` \| `number` | The address to get the signer for. |

#### Returns

`Promise`\<[`JsonRpcSigner`](/sdk/content/classes/JsonRpcSigner)>

The signer for the address.

#### Overrides

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`getSigner`](/sdk/content/classes/JsonRpcApiProvider#getsigner)

#### Source

[providers/provider-browser.ts:185](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-browser.ts#L185)

***

### hasSigner()

```ts theme={null}
hasSigner(address): Promise<boolean>
```

Resolves to `true` if the provider manages the `address`.

#### Parameters

| Parameter | Type                 | Description           |
| :-------- | :------------------- | :-------------------- |
| `address` | `string` \| `number` | The address to check. |

#### Returns

`Promise`\<`boolean`>

Resolves to `true` if the provider manages the `address`.

#### Source

[providers/provider-browser.ts:101](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-browser.ts#L101)

***

### initialize()

```ts theme={null}
initialize<U>(urls): Promise<void>
```

Initialize the URL map with the provided URLs.

#### Type parameters

| Type parameter | Value                                                              |
| :------------- | :----------------------------------------------------------------- |
| `U`            | `string`\[] \| [`FetchRequest`](/sdk/content/classes/FetchRequest) |

#### Parameters

| Parameter | Type | Description                          |
| :-------- | :--- | :----------------------------------- |
| `urls`    | `U`  | The URLs to initialize the map with. |

#### Returns

`Promise`\<`void`>

A promise that resolves when the map is initialized.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`initialize`](/sdk/content/classes/JsonRpcApiProvider#initialize)

#### Source

[providers/abstract-provider.ts:874](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L874)

***

### listAccounts()

```ts theme={null}
listAccounts(): Promise<JsonRpcSigner[]>
```

Returns a list of JsonRpcSigners for all accounts.

#### Returns

`Promise`\<[`JsonRpcSigner`](/sdk/content/classes/JsonRpcSigner)\[]>

A promise that resolves to an array of JsonRpcSigners.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`listAccounts`](/sdk/content/classes/JsonRpcApiProvider#listaccounts)

#### Source

[providers/provider-jsonrpc.ts:1579](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L1579)

***

### pause()

```ts theme={null}
pause(dropWhilePaused?): void
```

Pause the provider. If `dropWhilePaused`, any events that occur while paused are dropped, otherwise all events
will be emitted once the provider is unpaused.

#### Parameters

| Parameter          | Type      | Description                          |
| :----------------- | :-------- | :----------------------------------- |
| `dropWhilePaused`? | `boolean` | Whether to drop events while paused. |

#### Returns

`void`

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`pause`](/sdk/content/classes/JsonRpcApiProvider#pause)

#### Source

[providers/abstract-provider.ts:2598](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L2598)

***

### resume()

```ts theme={null}
resume(): void
```

Resume the provider.

#### Returns

`void`

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`resume`](/sdk/content/classes/JsonRpcApiProvider#resume)

#### Source

[providers/abstract-provider.ts:2627](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L2627)

***

### send()

```ts theme={null}
send(
   method, 
   params, 
shard?): Promise<any>
```

Sends a JSON-RPC request.

#### Parameters

| Parameter | Type                                       | Description                    |
| :-------- | :----------------------------------------- | :----------------------------- |
| `method`  | `string`                                   | The method name.               |
| `params`  | `any`\[] \| `Record`\<`string`, `any`>     | The parameters for the method. |
| `shard`?  | [`Shard`](/sdk/content/enumerations/Shard) | -                              |

#### Returns

`Promise`\<`any`>

The result of the request.

#### Overrides

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`send`](/sdk/content/classes/JsonRpcApiProvider#send)

#### Source

[providers/provider-browser.ts:122](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-browser.ts#L122)

***

### shardFromHash()

```ts theme={null}
shardFromHash(hash): Shard
```

Get the shard from a hash.

#### Parameters

| Parameter | Type     | Description                     |
| :-------- | :------- | :------------------------------ |
| `hash`    | `string` | The hash to get the shard from. |

#### Returns

[`Shard`](/sdk/content/enumerations/Shard)

The shard.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`shardFromHash`](/sdk/content/classes/JsonRpcApiProvider#shardfromhash)

#### Source

[providers/abstract-provider.ts:1047](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1047)

***

### zoneFromAddress()

```ts theme={null}
zoneFromAddress(_address): Promise<Zone>
```

Get the zone from an address.

#### Parameters

| Parameter  | Type                                                   | Description                       |
| :--------- | :----------------------------------------------------- | :-------------------------------- |
| `_address` | [`AddressLike`](/sdk/content/type-aliases/AddressLike) | The address to get the zone from. |

#### Returns

`Promise`\<[`Zone`](/sdk/content/enumerations/Zone)>

A promise that resolves to the zone.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`zoneFromAddress`](/sdk/content/classes/JsonRpcApiProvider#zonefromaddress)

#### Source

[providers/abstract-provider.ts:1036](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1036)

***

### zoneFromHash()

```ts theme={null}
zoneFromHash(hash): Zone
```

Get the zone from a hash.

#### Parameters

| Parameter | Type     | Description                    |
| :-------- | :------- | :----------------------------- |
| `hash`    | `string` | The hash to get the zone from. |

#### Returns

[`Zone`](/sdk/content/enumerations/Zone)

The zone.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`zoneFromHash`](/sdk/content/classes/JsonRpcApiProvider#zonefromhash)

#### Source

[providers/abstract-provider.ts:1057](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1057)


# EventPayload
Source: https://docs.qu.ai/sdk/content/classes/EventPayload



When an [**EventEmitterable**](/sdk/content/interfaces/EventEmitterable) triggers a Listener, the callback always ahas one additional
argument passed, which is an **EventPayload**.

## Extended by

* [`ContractUnknownEventPayload`](/sdk/content/classes/ContractUnknownEventPayload)

## Type parameters

| Type parameter |
| :------------- |
| `T`            |

## Constructors

### new EventPayload()

```ts theme={null}
new EventPayload<T>(
   emitter, 
   listener, 
filter): EventPayload<T>
```

Create a new **EventPayload** for `emitter` with the `listener` and for `filter`.

#### Parameters

| Parameter  | Type                                                                 |
| :--------- | :------------------------------------------------------------------- |
| `emitter`  | [`EventEmitterable`](/sdk/content/interfaces/EventEmitterable)\<`T`> |
| `listener` | `null` \| [`Listener`](/sdk/content/type-aliases/Listener)           |
| `filter`   | `T`                                                                  |

#### Returns

[`EventPayload`](/sdk/content/classes/EventPayload)\<`T`>

#### Source

[utils/events.ts:91](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/events.ts#L91)

## Properties

| Property  | Modifier   | Type                                                                 | Description               |
| :-------- | :--------- | :------------------------------------------------------------------- | :------------------------ |
| `emitter` | `readonly` | [`EventEmitterable`](/sdk/content/interfaces/EventEmitterable)\<`T`> | The **EventEmitterable**. |
| `filter`  | `readonly` | `T`                                                                  | The event filter.         |

## Methods

### removeListener()

```ts theme={null}
removeListener(): Promise<void>
```

Unregister the triggered listener for future events.

#### Returns

`Promise`\<`void`>

#### Source

[utils/events.ts:99](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/events.ts#L99)


# FeeData
Source: https://docs.qu.ai/sdk/content/classes/FeeData



A **FeeData** wraps all the fee-related values associated with the network.

## Constructors

### new FeeData()

```ts theme={null}
new FeeData(gasPrice?): FeeData
```

Creates a new FeeData for `gasPrice`.

#### Parameters

| Parameter   | Type               | Description    |
| :---------- | :----------------- | :------------- |
| `gasPrice`? | `null` \| `bigint` | The gas price. |

#### Returns

[`FeeData`](/sdk/content/classes/FeeData)

#### Source

[providers/provider.ts:106](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L106)

## Properties

| Property   | Modifier   | Type               | Description                        |
| :--------- | :--------- | :----------------- | :--------------------------------- |
| `gasPrice` | `readonly` | `null` \| `bigint` | The gas price for legacy networks. |

## Methods

### toJSON()

```ts theme={null}
toJSON(): any
```

Returns a JSON-friendly value.

#### Returns

`any`

The JSON-friendly value.

#### Source

[providers/provider.ts:117](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L117)


# FetchRequest
Source: https://docs.qu.ai/sdk/content/classes/FetchRequest



Represents a request for a resource using a URI.

By default, the supported schemes are `HTTP`, `HTTPS`, `data:`, and `IPFS:`.

Additional schemes can be added globally using [**registerGateway**](/sdk/content/classes/FetchRequest#registergateway).

## Example

```ts theme={null}
req = new FetchRequest('https://www.ricmoo.com');
resp = await req.send();
resp.body.length;
```

## Implements

* `Iterable`\<\[`string`, `string`]>

## Constructors

### new FetchRequest()

```ts theme={null}
new FetchRequest(url): FetchRequest
```

Create a new FetchRequest instance with default values.

Once created, each property may be set before issuing a `.send()` to make the request.

#### Parameters

| Parameter | Type     |
| :-------- | :------- |
| `url`     | `string` |

#### Returns

[`FetchRequest`](/sdk/content/classes/FetchRequest)

#### Source

[utils/fetch.ts:503](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L503)

## Accessors

### allowGzip

```ts theme={null}
get allowGzip(): boolean
```

Enable and request gzip-encoded responses. The response will automatically be decompressed. (default: true)

#### Returns

`boolean`

#### Source

[utils/fetch.ts:413](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L413)

***

### allowInsecureAuthentication

```ts theme={null}
get allowInsecureAuthentication(): boolean
```

Allow `Authentication` credentials to be sent over insecure channels. (default: false)

#### Returns

`boolean`

#### Source

[utils/fetch.ts:423](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L423)

***

### body

```ts theme={null}
get body(): null | Uint8Array
```

The fetch body, if any, to send as the request body. (default: null)

When setting a body, the intrinsic `Content-Type` is automatically set and will be used if **not overridden** by
setting a custom header.

If `body` is null, the body is cleared (along with the intrinsic `Content-Type`).

If `body` is a string, the intrinsic `Content-Type` is set to `text/plain`.

If `body` is a Uint8Array, the intrinsic `Content-Type` is set to `application/octet-stream`.

If `body` is any other object, the intrinsic `Content-Type` is set to `application/json`.

#### Returns

`null` | `Uint8Array`

#### Source

[utils/fetch.ts:265](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L265)

***

### credentials

```ts theme={null}
get credentials(): null | string
```

The value that will be sent for the `Authorization` header.

To set the credentials, use the `setCredentials` method.

#### Returns

`null` | `string`

#### Source

[utils/fetch.ts:394](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L394)

***

### getUrlFunc

```ts theme={null}
get getUrlFunc(): FetchGetUrlFunc
```

This function is called to fetch content from HTTP and HTTPS URLs and is platform specific (e.g. nodejs vs
browsers).

This is by default the currently registered global getUrl function, which can be changed using
[**registerGetUrl**](/sdk/content/classes/FetchRequest#registergeturl). If this has been set, setting is to `null` will cause this
FetchRequest (and any future clones) to revert back to using the currently registered global getUrl function.

Setting this is generally not necessary, but may be useful for developers that wish to intercept requests or to
configurege a proxy or other agent.

#### Returns

[`FetchGetUrlFunc`](/sdk/content/type-aliases/FetchGetUrlFunc)

#### Source

[utils/fetch.ts:491](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L491)

***

### headers

```ts theme={null}
get headers(): Record<string, string>
```

The headers that will be used when requesting the URI. All keys are lower-case.

This object is a copy, so any changes will **NOT** be reflected in the `FetchRequest`.

To set a header entry, use the `setHeader` method.

#### Returns

`Record`\<`string`, `string`>

#### Source

[utils/fetch.ts:323](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L323)

***

### method

```ts theme={null}
get method(): string
```

The HTTP method to use when requesting the URI. If no method has been explicitly set, then `GET` is used if the
body is null and `POST` otherwise.

#### Returns

`string`

#### Source

[utils/fetch.ts:300](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L300)

***

### preflightFunc

```ts theme={null}
get preflightFunc(): null | FetchPreflightFunc
```

This function is called prior to each request, for example during a redirection or retry in case of server
throttling.

This offers an opportunity to populate headers or update content before sending a request.

#### Returns

`null` | [`FetchPreflightFunc`](/sdk/content/type-aliases/FetchPreflightFunc)

#### Source

[utils/fetch.ts:447](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L447)

***

### processFunc

```ts theme={null}
get processFunc(): null | FetchProcessFunc
```

This function is called after each response, offering an opportunity to provide client-level throttling or
updating response data.

Any error thrown in this causes the `send()` to throw.

To schedule a retry attempt (assuming the maximum retry limit has not been reached), use
[**FetchResponse.throwThrottleError**](/sdk/content/classes/FetchResponse#throwthrottleerror).

#### Returns

`null` | [`FetchProcessFunc`](/sdk/content/type-aliases/FetchProcessFunc)

#### Source

[utils/fetch.ts:463](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L463)

***

### retryFunc

```ts theme={null}
get retryFunc(): null | FetchRetryFunc
```

This function is called on each retry attempt.

#### Returns

`null` | [`FetchRetryFunc`](/sdk/content/type-aliases/FetchRetryFunc)

#### Source

[utils/fetch.ts:473](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L473)

***

### timeout

```ts theme={null}
get timeout(): number
```

The timeout (in milliseconds) to wait for a complete response. (default: 5 minutes)

#### Returns

`number`

#### Source

[utils/fetch.ts:433](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L433)

***

### url

```ts theme={null}
get url(): string
```

The fetch URL to request.

#### Returns

`string`

#### Source

[utils/fetch.ts:244](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L244)

## Methods

### cancel()

```ts theme={null}
cancel(): void
```

Cancels the inflight response, causing a `CANCELLED` error to be rejected from the
[**send**](/sdk/content/classes/FetchRequest#send).

#### Returns

`void`

#### Source

[utils/fetch.ts:656](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L656)

***

### clearHeaders()

```ts theme={null}
clearHeaders(): void
```

Clear all headers, resetting all intrinsic headers.

#### Returns

`void`

#### Source

[utils/fetch.ts:367](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L367)

***

### clone()

```ts theme={null}
clone(): FetchRequest
```

Create a new copy of this request.

#### Returns

[`FetchRequest`](/sdk/content/classes/FetchRequest)

The new request.

#### Source

[utils/fetch.ts:709](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L709)

***

### getHeader()

```ts theme={null}
getHeader(key): string
```

Get the header for `key`, ignoring case.

#### Parameters

| Parameter | Type     | Description                 |
| :-------- | :------- | :-------------------------- |
| `key`     | `string` | The header key to retrieve. |

#### Returns

`string`

The header value.

#### Source

[utils/fetch.ts:350](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L350)

***

### hasBody()

```ts theme={null}
hasBody(): this is FetchRequest & Object
```

Returns true if the request has a body.

#### Returns

`this is FetchRequest & Object`

#### Source

[utils/fetch.ts:292](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L292)

***

### redirect()

```ts theme={null}
redirect(location): FetchRequest
```

Returns a new [**FetchRequest**](/sdk/content/classes/FetchRequest) that represents the redirection to `location`.

#### Parameters

| Parameter  | Type     | Description                  |
| :--------- | :------- | :--------------------------- |
| `location` | `string` | The location to redirect to. |

#### Returns

[`FetchRequest`](/sdk/content/classes/FetchRequest)

The new request.

#### Source

[utils/fetch.ts:673](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L673)

***

### send()

```ts theme={null}
send(): Promise<FetchResponse>
```

Resolves to the response by sending the request.

#### Returns

`Promise`\<[`FetchResponse`](/sdk/content/classes/FetchResponse)>

#### Source

[utils/fetch.ts:644](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L644)

***

### setCredentials()

```ts theme={null}
setCredentials(username, password): void
```

Sets an `Authorization` for `username` with `password`.

#### Parameters

| Parameter  | Type     | Description                                   |
| :--------- | :------- | :-------------------------------------------- |
| `username` | `string` | The username to use for basic authentication. |
| `password` | `string` | The password to use for basic authentication. |

#### Returns

`void`

#### Throws

If the `username` contains a colon.

#### Source

[utils/fetch.ts:405](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L405)

***

### setHeader()

```ts theme={null}
setHeader(key, value): void
```

Set the header for `key` to `value`. All values are coerced to a string.

#### Parameters

| Parameter | Type                 | Description              |
| :-------- | :------------------- | :----------------------- |
| `key`     | `string`             | The header key to set.   |
| `value`   | `string` \| `number` | The header value to set. |

#### Returns

`void`

#### Source

[utils/fetch.ts:360](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L360)

***

### setThrottleParams()

```ts theme={null}
setThrottleParams(params): void
```

Update the throttle parameters used to determine maximum attempts and exponential-backoff properties.

#### Parameters

| Parameter | Type                  | Description                     |
| :-------- | :-------------------- | :------------------------------ |
| `params`  | `FetchThrottleParams` | The throttle parameters to set. |

#### Returns

`void`

#### Throws

If the `slotInterval` is not a positive integer.

#### Source

[utils/fetch.ts:530](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L530)

***

### createDataGateway()

```ts theme={null}
static createDataGateway(): FetchGatewayFunc
```

Creates a function that can "fetch" data URIs.

Note that this is automatically done internally to support data URIs, so it is not necessary to register it.

This is not generally something that is needed, but may be useful in a wrapper to perfom custom data URI
functionality.

#### Returns

[`FetchGatewayFunc`](/sdk/content/type-aliases/FetchGatewayFunc)

The gateway function.

#### Source

[utils/fetch.ts:827](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L827)

***

### createGetUrlFunc()

```ts theme={null}
static createGetUrlFunc(options?): FetchGetUrlFunc
```

Creates a getUrl function that fetches content from HTTP and HTTPS URLs.

The available `options` are dependent on the platform implementation of the default getUrl function.

This is not generally something that is needed, but is useful when trying to customize simple behaviour when
fetching HTTP content.

#### Parameters

| Parameter  | Type                       | Description                                           |
| :--------- | :------------------------- | :---------------------------------------------------- |
| `options`? | `Record`\<`string`, `any`> | The options to use when creating the getUrl function. |

#### Returns

[`FetchGetUrlFunc`](/sdk/content/type-aliases/FetchGetUrlFunc)

The getUrl function.

#### Throws

If the gateways are locked.

#### Source

[utils/fetch.ts:813](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L813)

***

### createIpfsGatewayFunc()

```ts theme={null}
static createIpfsGatewayFunc(baseUrl): FetchGatewayFunc
```

Creates a function that will fetch IPFS (unvalidated) from a custom gateway baseUrl.

The default IPFS gateway used internally is `"https://gateway.ipfs.io/ipfs/"`.

#### Parameters

| Parameter | Type     | Description                       |
| :-------- | :------- | :-------------------------------- |
| `baseUrl` | `string` | The base URL of the IPFS gateway. |

#### Returns

[`FetchGatewayFunc`](/sdk/content/type-aliases/FetchGatewayFunc)

The gateway function.

#### Source

[utils/fetch.ts:839](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L839)

***

### getGateway()

```ts theme={null}
static getGateway(scheme): null | FetchGatewayFunc
```

Get the current Gateway function for `scheme`.

#### Parameters

| Parameter | Type     | Description                        |
| :-------- | :------- | :--------------------------------- |
| `scheme`  | `string` | The scheme to get the gateway for. |

#### Returns

`null` | [`FetchGatewayFunc`](/sdk/content/type-aliases/FetchGatewayFunc)

The gateway function, or null if not found.

#### Source

[utils/fetch.ts:758](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L758)

***

### lockConfig()

```ts theme={null}
static lockConfig(): void
```

Locks all static configuration for gateways and FetchGetUrlFunc registration.

#### Returns

`void`

#### Source

[utils/fetch.ts:748](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L748)

***

### registerGateway()

```ts theme={null}
static registerGateway(scheme, func): void
```

Use the `func` when fetching URIs using `scheme`.

This method affects all requests globally.

If [**lockConfig**](/sdk/content/classes/FetchRequest#lockconfig) has been called, no change is made and this throws.

#### Parameters

| Parameter | Type                                                             | Description                             |
| :-------- | :--------------------------------------------------------------- | :-------------------------------------- |
| `scheme`  | `string`                                                         | The scheme to register the gateway for. |
| `func`    | [`FetchGatewayFunc`](/sdk/content/type-aliases/FetchGatewayFunc) | The gateway function to use.            |

#### Returns

`void`

#### Throws

If the scheme is `http` or `https`.

#### Source

[utils/fetch.ts:773](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L773)

***

### registerGetUrl()

```ts theme={null}
static registerGetUrl(getUrl): void
```

Use `getUrl` when fetching URIs over HTTP and HTTPS requests.

This method affects all requests globally.

If [**lockConfig**](/sdk/content/classes/FetchRequest#lockconfig) has been called, no change is made and this throws.

#### Parameters

| Parameter | Type                                                           | Description                                           |
| :-------- | :------------------------------------------------------------- | :---------------------------------------------------- |
| `getUrl`  | [`FetchGetUrlFunc`](/sdk/content/type-aliases/FetchGetUrlFunc) | The function to use for fetching HTTP and HTTPS URIs. |

#### Returns

`void`

#### Throws

If the gateways are locked.

#### Source

[utils/fetch.ts:794](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L794)


# FetchResponse
Source: https://docs.qu.ai/sdk/content/classes/FetchResponse



The response for a FetchRequest.

## Implements

* `Iterable`\<\[`string`, `string`]>

## Accessors

### body

```ts theme={null}
get body(): null | Readonly<Uint8Array>
```

The response body, or `null` if there was no body.

#### Returns

`null` | `Readonly`\<`Uint8Array`>

#### Source

[utils/fetch.ts:891](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L891)

***

### bodyJson

```ts theme={null}
get bodyJson(): any
```

The response body, decoded as JSON.

An error is thrown if the body is invalid JSON-encoded data or if there was no body.

#### Returns

`any`

#### Source

[utils/fetch.ts:916](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L916)

***

### bodyText

```ts theme={null}
get bodyText(): string
```

The response body as a UTF-8 encoded string, or the empty string (i.e. `""`) if there was no body.

An error is thrown if the body is invalid UTF-8 data.

#### Returns

`string`

#### Source

[utils/fetch.ts:900](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L900)

***

### headers

```ts theme={null}
get headers(): Record<string, string>
```

The response headers. All keys are lower-case.

#### Returns

`Record`\<`string`, `string`>

#### Source

[utils/fetch.ts:884](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L884)

***

### request

```ts theme={null}
get request(): null | FetchRequest
```

The request made for this response.

#### Returns

`null` | [`FetchRequest`](/sdk/content/classes/FetchRequest)

#### Source

[utils/fetch.ts:1033](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L1033)

***

### statusCode

```ts theme={null}
get statusCode(): number
```

The response status code.

#### Returns

`number`

#### Source

[utils/fetch.ts:870](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L870)

***

### statusMessage

```ts theme={null}
get statusMessage(): string
```

The response status message.

#### Returns

`string`

#### Source

[utils/fetch.ts:877](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L877)

## Methods

### assertOk()

```ts theme={null}
assertOk(): void
```

Throws a `SERVER_ERROR` if this response is not ok.

#### Returns

`void`

#### Throws

If the response is not ok.

#### Source

[utils/fetch.ts:1049](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L1049)

***

### getHeader()

```ts theme={null}
getHeader(key): string
```

Get the header value for `key`, ignoring case.

#### Parameters

| Parameter | Type     | Description                 |
| :-------- | :------- | :-------------------------- |
| `key`     | `string` | The header key to retrieve. |

#### Returns

`string`

The header value.

#### Source

[utils/fetch.ts:1016](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L1016)

***

### hasBody()

```ts theme={null}
hasBody(): this is FetchResponse & Object
```

Returns true if the response has a body.

#### Returns

`this is FetchResponse & Object`

True if the response has a body.

#### Throws

If the body is invalid UTF-8 data.

#### Source

[utils/fetch.ts:1026](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L1026)

***

### makeServerError()

```ts theme={null}
makeServerError(message?, error?): FetchResponse
```

Return a Response with matching headers and body, but with an error status code (i.e. 599) and `message` with an
optional `error`.

#### Parameters

| Parameter  | Type     | Description               |
| :--------- | :------- | :------------------------ |
| `message`? | `string` | The error message to use. |
| `error`?   | `Error`  | The error to use.         |

#### Returns

[`FetchResponse`](/sdk/content/classes/FetchResponse)

The error response.

#### Source

[utils/fetch.ts:975](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L975)

***

### ok()

```ts theme={null}
ok(): boolean
```

Returns true if this response was a success statusCode.

#### Returns

`boolean`

#### Source

[utils/fetch.ts:1040](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L1040)

***

### throwThrottleError()

```ts theme={null}
throwThrottleError(message?, stall?): never
```

If called within a [request.processFunc](FetchRequest-processFunc) call, causes the request to retry as if
throttled for `stall` milliseconds.

#### Parameters

| Parameter  | Type     | Description                                          |
| :--------- | :------- | :--------------------------------------------------- |
| `message`? | `string` | The error message to use.                            |
| `stall`?   | `number` | The number of milliseconds to stall before retrying. |

#### Returns

`never`

#### Throws

If `stall` is not a non-negative integer.

#### Source

[utils/fetch.ts:996](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L996)


# FewestCoinSelector
Source: https://docs.qu.ai/sdk/content/classes/FewestCoinSelector



The FewestCoinSelector class provides a coin selection algorithm that selects the fewest UTXOs required to meet the
target amount. This algorithm is useful for minimizing the size of the transaction and the fees associated with it.

This class is a sub-class of AbstractCoinSelector | **AbstractCoinSelector** and implements the
AbstractCoinSelector.performSelection | **performSelection** method to provide the actual coin selection
logic.

## Extends

* `AbstractCoinSelector`

## Constructors

### new FewestCoinSelector()

```ts theme={null}
new FewestCoinSelector(availableUTXOs): FewestCoinSelector
```

Constructs a new AbstractCoinSelector instance with an empty UTXO array.

#### Parameters

| Parameter        | Type                                   | Default value |
| :--------------- | :------------------------------------- | :------------ |
| `availableUTXOs` | [`UTXO`](/sdk/content/classes/UTXO)\[] | `[]`          |

#### Returns

[`FewestCoinSelector`](/sdk/content/classes/FewestCoinSelector)

#### Inherited from

`AbstractCoinSelector.constructor`

#### Source

[transaction/abstract-coinselector.ts:61](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/abstract-coinselector.ts#L61)

## Methods

### decreaseFee()

```ts theme={null}
decreaseFee(feeReduction): SelectedCoinsResult
```

Decreases the fee by removing inputs if possible and adjusting change outputs.

#### Parameters

| Parameter      | Type     | Description                                |
| :------------- | :------- | :----------------------------------------- |
| `feeReduction` | `bigint` | The amount by which the fee has decreased. |

#### Returns

`SelectedCoinsResult`

#### Source

[transaction/coinselector-fewest.ts:280](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/coinselector-fewest.ts#L280)

***

### increaseFee()

```ts theme={null}
increaseFee(additionalFeeNeeded): SelectedCoinsResult
```

Increases the total fee by first reducing change outputs, then selecting additional inputs if necessary.

#### Parameters

| Parameter             | Type     | Description                |
| :-------------------- | :------- | :------------------------- |
| `additionalFeeNeeded` | `bigint` | The additional fee needed. |

#### Returns

`SelectedCoinsResult`

Returns true if successful, false if insufficient funds.

#### Source

[transaction/coinselector-fewest.ts:226](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/coinselector-fewest.ts#L226)

***

### performSelection()

```ts theme={null}
performSelection(config): SelectedCoinsResult
```

Performs coin selection to meet the target amount plus fee, using the smallest possible denominations and
minimizing the number of inputs and outputs.

#### Parameters

| Parameter | Type                  |
| :-------- | :-------------------- |
| `config`  | `CoinSelectionConfig` |

#### Returns

`SelectedCoinsResult`

The selected UTXOs and outputs.

#### Overrides

`AbstractCoinSelector.performSelection`

#### Source

[transaction/coinselector-fewest.ts:24](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/coinselector-fewest.ts#L24)


# FixedNumber
Source: https://docs.qu.ai/sdk/content/classes/FixedNumber



A FixedNumber represents a value over its [**FixedFormat**](/sdk/content/type-aliases/FixedFormat) arithmetic field.

A FixedNumber can be used to perform math, losslessly, on values which have decmial places.

A FixedNumber has a fixed bit-width to store values in, and stores all values internally by multiplying the value by
10 raised to the power of `decimals`.

If operations are performed that cause a value to grow too high (close to positive infinity) or too low (close to
negative infinity), the value is said to overflow.

For example, an 8-bit signed value, with 0 decimals may only be within the range `-128` to `127`; so `-128 - 1` will
overflow and become `127`. Likewise, `127 + 1` will overflow and become `-127`.

Many operation have a normal and unsafe variant. The normal variant will throw a
[NumericFaultError](../interfaces/NumericFaultError) on any overflow, while the unsafe variant will silently allow
overflow, corrupting its value value.

If operations are performed that cause a value to become too small (close to zero), the value loses precison and is
said to underflow.

For example, an value with 1 decimal place may store a number as small as `0.1`, but the value of `0.1 / 2` is
`0.05`, which cannot fit into 1 decimal place, so underflow occurs which means precision is lost and the value
becomes `0`.

Some operations have a normal and signalling variant. The normal variant will silently ignore underflow, while the
signalling variant will thow a [NumericFaultError](../interfaces/NumericFaultError) on underflow.

## Properties

| Property | Modifier   | Type     | Description                                               |
| :------- | :--------- | :------- | :-------------------------------------------------------- |
| `format` | `readonly` | `string` | The specific fixed-point arithmetic field for this value. |

## Accessors

### decimals

```ts theme={null}
get decimals(): number
```

The number of decimal places in the fixed-point arithment field.

#### Returns

`number`

#### Source

[utils/fixednumber.ts:266](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fixednumber.ts#L266)

***

### signed

```ts theme={null}
get signed(): boolean
```

If true, negative values are permitted, otherwise only positive values and zero are allowed.

#### Returns

`boolean`

#### Source

[utils/fixednumber.ts:252](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fixednumber.ts#L252)

***

### value

```ts theme={null}
get value(): bigint
```

The value as an integer, based on the smallest unit the [**decimals**](/sdk/content/classes/FixedNumber#decimals) allow.

#### Returns

`bigint`

#### Source

[utils/fixednumber.ts:273](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fixednumber.ts#L273)

***

### width

```ts theme={null}
get width(): number
```

The number of bits available to store the value.

#### Returns

`number`

#### Source

[utils/fixednumber.ts:259](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fixednumber.ts#L259)

## Methods

### add()

```ts theme={null}
add(other): FixedNumber
```

Returns a new [**FixedNumber**](/sdk/content/classes/FixedNumber) with the result of `this` added to `other`. A
[NumericFaultError](../interfaces/NumericFaultError) is thrown if overflow occurs.

#### Parameters

| Parameter | Type                                              | Description                 |
| :-------- | :------------------------------------------------ | :-------------------------- |
| `other`   | [`FixedNumber`](/sdk/content/classes/FixedNumber) | The value to add to `this`. |

#### Returns

[`FixedNumber`](/sdk/content/classes/FixedNumber)

The result of the addition.

#### Source

[utils/fixednumber.ts:308](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fixednumber.ts#L308)

***

### addUnsafe()

```ts theme={null}
addUnsafe(other): FixedNumber
```

Returns a new [**FixedNumber**](/sdk/content/classes/FixedNumber) with the result of `this` added to `other`, ignoring overflow.

#### Parameters

| Parameter | Type                                              | Description                 |
| :-------- | :------------------------------------------------ | :-------------------------- |
| `other`   | [`FixedNumber`](/sdk/content/classes/FixedNumber) | The value to add to `this`. |

#### Returns

[`FixedNumber`](/sdk/content/classes/FixedNumber)

The result of the addition.

#### Source

[utils/fixednumber.ts:297](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fixednumber.ts#L297)

***

### ceiling()

```ts theme={null}
ceiling(): FixedNumber
```

Returns a new [**FixedNumber**](/sdk/content/classes/FixedNumber) which is the smallest **integer** that is greater than or
equal to `this`.

The decimal component of the result will always be `0`.

#### Returns

[`FixedNumber`](/sdk/content/classes/FixedNumber)

The ceiling value.

#### Source

[utils/fixednumber.ts:549](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fixednumber.ts#L549)

***

### cmp()

```ts theme={null}
cmp(other): number
```

Returns a comparison result between `this` and `other`.

This is suitable for use in sorting, where `-1` implies `this` is smaller, `1` implies `this` is larger and `0`
implies both are equal.

#### Parameters

| Parameter | Type                                              | Description                     |
| :-------- | :------------------------------------------------ | :------------------------------ |
| `other`   | [`FixedNumber`](/sdk/content/classes/FixedNumber) | The value to compare to `this`. |

#### Returns

`number`

The comparison result.

#### Source

[utils/fixednumber.ts:452](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fixednumber.ts#L452)

***

### div()

```ts theme={null}
div(other): FixedNumber
```

Returns a new [**FixedNumber**](/sdk/content/classes/FixedNumber) with the result of `this` divided by `other`, ignoring
underflow (precision loss). A [NumericFaultError](../interfaces/NumericFaultError) is thrown if overflow occurs.

#### Parameters

| Parameter | Type                                              | Description                    |
| :-------- | :------------------------------------------------ | :----------------------------- |
| `other`   | [`FixedNumber`](/sdk/content/classes/FixedNumber) | The value to divide `this` by. |

#### Returns

[`FixedNumber`](/sdk/content/classes/FixedNumber)

The result of the division.

#### Source

[utils/fixednumber.ts:415](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fixednumber.ts#L415)

***

### divSignal()

```ts theme={null}
divSignal(other): FixedNumber
```

Returns a new [**FixedNumber**](/sdk/content/classes/FixedNumber) with the result of `this` divided by `other`. A
[NumericFaultError](../interfaces/NumericFaultError) is thrown if underflow (precision loss) occurs.

#### Parameters

| Parameter | Type                                              | Description                    |
| :-------- | :------------------------------------------------ | :----------------------------- |
| `other`   | [`FixedNumber`](/sdk/content/classes/FixedNumber) | The value to divide `this` by. |

#### Returns

[`FixedNumber`](/sdk/content/classes/FixedNumber)

The result of the division.

#### Throws

Thrown if underflow occurs.

#### Source

[utils/fixednumber.ts:427](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fixednumber.ts#L427)

***

### divUnsafe()

```ts theme={null}
divUnsafe(other): FixedNumber
```

Returns a new [**FixedNumber**](/sdk/content/classes/FixedNumber) with the result of `this` divided by `other`, ignoring
underflow (precision loss). A [NumericFaultError](../interfaces/NumericFaultError) is thrown if overflow occurs.

#### Parameters

| Parameter | Type                                              | Description                    |
| :-------- | :------------------------------------------------ | :----------------------------- |
| `other`   | [`FixedNumber`](/sdk/content/classes/FixedNumber) | The value to divide `this` by. |

#### Returns

[`FixedNumber`](/sdk/content/classes/FixedNumber)

The result of the division.

#### Source

[utils/fixednumber.ts:404](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fixednumber.ts#L404)

***

### eq()

```ts theme={null}
eq(other): boolean
```

Returns true if `other` is equal to `this`.

#### Parameters

| Parameter | Type                                              | Description                     |
| :-------- | :------------------------------------------------ | :------------------------------ |
| `other`   | [`FixedNumber`](/sdk/content/classes/FixedNumber) | The value to compare to `this`. |

#### Returns

`boolean`

True if `other` is equal to `this`.

#### Source

[utils/fixednumber.ts:480](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fixednumber.ts#L480)

***

### floor()

```ts theme={null}
floor(): FixedNumber
```

Returns a new [**FixedNumber**](/sdk/content/classes/FixedNumber) which is the largest **integer** that is less than or equal to
`this`.

The decimal component of the result will always be `0`.

#### Returns

[`FixedNumber`](/sdk/content/classes/FixedNumber)

The floored value.

#### Source

[utils/fixednumber.ts:532](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fixednumber.ts#L532)

***

### gt()

```ts theme={null}
gt(other): boolean
```

Returns true if `other` is greater than to `this`.

#### Parameters

| Parameter | Type                                              | Description                     |
| :-------- | :------------------------------------------------ | :------------------------------ |
| `other`   | [`FixedNumber`](/sdk/content/classes/FixedNumber) | The value to compare to `this`. |

#### Returns

`boolean`

True if `other` is greater than to `this`.

#### Source

[utils/fixednumber.ts:510](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fixednumber.ts#L510)

***

### gte()

```ts theme={null}
gte(other): boolean
```

Returns true if `other` is greater than or equal to `this`.

#### Parameters

| Parameter | Type                                              | Description                     |
| :-------- | :------------------------------------------------ | :------------------------------ |
| `other`   | [`FixedNumber`](/sdk/content/classes/FixedNumber) | The value to compare to `this`. |

#### Returns

`boolean`

True if `other` is greater than or equal to `this`.

#### Source

[utils/fixednumber.ts:520](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fixednumber.ts#L520)

***

### isNegative()

```ts theme={null}
isNegative(): boolean
```

Returns true if `this` is less than `0`.

#### Returns

`boolean`

True if `this` is less than `0`.

#### Source

[utils/fixednumber.ts:601](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fixednumber.ts#L601)

***

### isZero()

```ts theme={null}
isZero(): boolean
```

Returns true if `this` is equal to `0`.

#### Returns

`boolean`

True if `this` is equal to `0`.

#### Source

[utils/fixednumber.ts:592](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fixednumber.ts#L592)

***

### lt()

```ts theme={null}
lt(other): boolean
```

Returns true if `other` is less than to `this`.

#### Parameters

| Parameter | Type                                              | Description                     |
| :-------- | :------------------------------------------------ | :------------------------------ |
| `other`   | [`FixedNumber`](/sdk/content/classes/FixedNumber) | The value to compare to `this`. |

#### Returns

`boolean`

True if `other` is less than to `this`.

#### Source

[utils/fixednumber.ts:490](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fixednumber.ts#L490)

***

### lte()

```ts theme={null}
lte(other): boolean
```

Returns true if `other` is less than or equal to `this`.

#### Parameters

| Parameter | Type                                              | Description                     |
| :-------- | :------------------------------------------------ | :------------------------------ |
| `other`   | [`FixedNumber`](/sdk/content/classes/FixedNumber) | The value to compare to `this`. |

#### Returns

`boolean`

True if `other` is less than or equal to `this`.

#### Source

[utils/fixednumber.ts:500](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fixednumber.ts#L500)

***

### mul()

```ts theme={null}
mul(other): FixedNumber
```

Returns a new [**FixedNumber**](/sdk/content/classes/FixedNumber) with the result of `this` multiplied by `other`. A
[NumericFaultError](../interfaces/NumericFaultError) is thrown if overflow occurs.

#### Parameters

| Parameter | Type                                              | Description                      |
| :-------- | :------------------------------------------------ | :------------------------------- |
| `other`   | [`FixedNumber`](/sdk/content/classes/FixedNumber) | The value to multiply `this` by. |

#### Returns

[`FixedNumber`](/sdk/content/classes/FixedNumber)

The result of the multiplication.

#### Source

[utils/fixednumber.ts:362](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fixednumber.ts#L362)

***

### mulSignal()

```ts theme={null}
mulSignal(other): FixedNumber
```

Returns a new [**FixedNumber**](/sdk/content/classes/FixedNumber) with the result of `this` multiplied by `other`. A
[NumericFaultError](../interfaces/NumericFaultError) is thrown if overflow occurs or if underflow (precision
loss) occurs.

#### Parameters

| Parameter | Type                                              | Description                      |
| :-------- | :------------------------------------------------ | :------------------------------- |
| `other`   | [`FixedNumber`](/sdk/content/classes/FixedNumber) | The value to multiply `this` by. |

#### Returns

[`FixedNumber`](/sdk/content/classes/FixedNumber)

The result of the multiplication.

#### Throws

Thrown if overflow or underflow occurs.

#### Throws

Thrown if division by 0 occurs.

#### Source

[utils/fixednumber.ts:376](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fixednumber.ts#L376)

***

### mulUnsafe()

```ts theme={null}
mulUnsafe(other): FixedNumber
```

Returns a new [**FixedNumber**](/sdk/content/classes/FixedNumber) with the result of `this` multiplied by `other`, ignoring
overflow and underflow (precision loss).

#### Parameters

| Parameter | Type                                              | Description                      |
| :-------- | :------------------------------------------------ | :------------------------------- |
| `other`   | [`FixedNumber`](/sdk/content/classes/FixedNumber) | The value to multiply `this` by. |

#### Returns

[`FixedNumber`](/sdk/content/classes/FixedNumber)

The result of the multiplication.

#### Source

[utils/fixednumber.ts:351](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fixednumber.ts#L351)

***

### round()

```ts theme={null}
round(decimals?): FixedNumber
```

Returns a new [**FixedNumber**](/sdk/content/classes/FixedNumber) with the decimal component rounded up on ties at `decimals`
places.

#### Parameters

| Parameter   | Type     | Description                               |
| :---------- | :------- | :---------------------------------------- |
| `decimals`? | `number` | The number of decimal places to round to. |

#### Returns

[`FixedNumber`](/sdk/content/classes/FixedNumber)

The rounded value.

#### Source

[utils/fixednumber.ts:565](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fixednumber.ts#L565)

***

### sub()

```ts theme={null}
sub(other): FixedNumber
```

Returns a new [**FixedNumber**](/sdk/content/classes/FixedNumber) with the result of `other` subtracted from `this`. A
[NumericFaultError](../interfaces/NumericFaultError) is thrown if overflow occurs.

#### Parameters

| Parameter | Type                                              | Description                        |
| :-------- | :------------------------------------------------ | :--------------------------------- |
| `other`   | [`FixedNumber`](/sdk/content/classes/FixedNumber) | The value to subtract from `this`. |

#### Returns

[`FixedNumber`](/sdk/content/classes/FixedNumber)

The result of the subtraction.

#### Source

[utils/fixednumber.ts:335](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fixednumber.ts#L335)

***

### subUnsafe()

```ts theme={null}
subUnsafe(other): FixedNumber
```

Returns a new [**FixedNumber**](/sdk/content/classes/FixedNumber) with the result of `other` subtracted from `this`, ignoring
overflow.

#### Parameters

| Parameter | Type                                              | Description                        |
| :-------- | :------------------------------------------------ | :--------------------------------- |
| `other`   | [`FixedNumber`](/sdk/content/classes/FixedNumber) | The value to subtract from `this`. |

#### Returns

[`FixedNumber`](/sdk/content/classes/FixedNumber)

The result of the subtraction.

#### Source

[utils/fixednumber.ts:324](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fixednumber.ts#L324)

***

### toFormat()

```ts theme={null}
toFormat(format): FixedNumber
```

Return a new [**FixedNumber**](/sdk/content/classes/FixedNumber) with the same value but has had its field set to `format`.

This will throw if the value cannot fit into `format`.

#### Parameters

| Parameter | Type                                                   | Description                   |
| :-------- | :----------------------------------------------------- | :---------------------------- |
| `format`  | [`FixedFormat`](/sdk/content/type-aliases/FixedFormat) | The new format for the value. |

#### Returns

[`FixedNumber`](/sdk/content/classes/FixedNumber)

#### Source

[utils/fixednumber.ts:633](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fixednumber.ts#L633)

***

### toString()

```ts theme={null}
toString(): string
```

Returns the string representation of `this`.

#### Returns

`string`

The string representation.

#### Source

[utils/fixednumber.ts:610](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fixednumber.ts#L610)

***

### toUnsafeFloat()

```ts theme={null}
toUnsafeFloat(): number
```

Returns a float approximation.

Due to IEEE 754 precission (or lack thereof), this function can only return an approximation and most values will
contain rounding errors.

#### Returns

`number`

The float approximation.

#### Source

[utils/fixednumber.ts:622](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fixednumber.ts#L622)

***

### fromBytes()

```ts theme={null}
static fromBytes(_value, _format?): FixedNumber
```

Creates a new [**FixedNumber**](/sdk/content/classes/FixedNumber) with the big-endian representation `value` with `format`.

This will throw a [NumericFaultError](../interfaces/NumericFaultError) if `value` cannot fit in `format` due to
overflow.

#### Parameters

| Parameter  | Type                                                   | Description                                 |
| :--------- | :----------------------------------------------------- | :------------------------------------------ |
| `_value`   | [`BytesLike`](/sdk/content/type-aliases/BytesLike)     | The big-endian representation of the value. |
| `_format`? | [`FixedFormat`](/sdk/content/type-aliases/FixedFormat) | The format for the FixedNumber.             |

#### Returns

[`FixedNumber`](/sdk/content/classes/FixedNumber)

The FixedNumber for `value`.

#### Source

[utils/fixednumber.ts:727](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fixednumber.ts#L727)

***

### fromString()

```ts theme={null}
static fromString(_value, _format?): FixedNumber
```

Creates a new [**FixedNumber**](/sdk/content/classes/FixedNumber) for `value` with `format`.

This will throw a [NumericFaultError](../interfaces/NumericFaultError) if `value` cannot fit in `format`, either
due to overflow or underflow (precision loss).

#### Parameters

| Parameter  | Type                                                   | Description                            |
| :--------- | :----------------------------------------------------- | :------------------------------------- |
| `_value`   | `string`                                               | The value to create a FixedNumber for. |
| `_format`? | [`FixedFormat`](/sdk/content/type-aliases/FixedFormat) | The format for the FixedNumber.        |

#### Returns

[`FixedNumber`](/sdk/content/classes/FixedNumber)

The FixedNumber for `value`.

#### Source

[utils/fixednumber.ts:681](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fixednumber.ts#L681)

***

### fromValue()

```ts theme={null}
static fromValue(
   _value, 
   _decimals?, 
   _format?): FixedNumber
```

Creates a new [**FixedNumber**](/sdk/content/classes/FixedNumber) for `value` divided by `decimal` places with `format`.

This will throw a [NumericFaultError](../interfaces/NumericFaultError) if `value` (once adjusted for `decimals`)
cannot fit in `format`, either due to overflow or underflow (precision loss).

#### Parameters

| Parameter    | Type                                                     | Description                              |
| :----------- | :------------------------------------------------------- | :--------------------------------------- |
| `_value`     | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to create a FixedNumber for.   |
| `_decimals`? | [`Numeric`](/sdk/content/type-aliases/Numeric)           | The number of decimal places in `value`. |
| `_format`?   | [`FixedFormat`](/sdk/content/type-aliases/FixedFormat)   | The format for the FixedNumber.          |

#### Returns

[`FixedNumber`](/sdk/content/classes/FixedNumber)

The FixedNumber for `value`.

#### Source

[utils/fixednumber.ts:648](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fixednumber.ts#L648)


# JsonRpcApiProvider
Source: https://docs.qu.ai/sdk/content/classes/JsonRpcApiProvider



The JsonRpcApiProvider is an abstract class and **MUST** be sub-classed.

It provides the base for all JSON-RPC-based Provider interaction.

Sub-classing Notes:

* A sub-class MUST override \_send
* A sub-class MUST call the `_start()` method once connected

## Extends

* [`AbstractProvider`](/sdk/content/classes/AbstractProvider)\<`C`>

## Extended by

* [`JsonRpcProvider`](/sdk/content/classes/JsonRpcProvider)
* [`BrowserProvider`](/sdk/content/classes/BrowserProvider)
* [`SocketProvider`](/sdk/content/classes/SocketProvider)

## Type parameters

| Type parameter | Value                                               |
| :------------- | :-------------------------------------------------- |
| `C`            | [`FetchRequest`](/sdk/content/classes/FetchRequest) |

## Constructors

### new JsonRpcApiProvider()

```ts theme={null}
new JsonRpcApiProvider<C>(network?, options?): JsonRpcApiProvider<C>
```

Creates a new JsonRpcApiProvider instance.

#### Parameters

| Parameter  | Type                                                                               | Description                   |
| :--------- | :--------------------------------------------------------------------------------- | :---------------------------- |
| `network`? | [`Networkish`](/sdk/content/type-aliases/Networkish)                               | The network to connect to.    |
| `options`? | [`JsonRpcApiProviderOptions`](/sdk/content/type-aliases/JsonRpcApiProviderOptions) | The options for the provider. |

#### Returns

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider)\<`C`>

#### Overrides

[`AbstractProvider`](/sdk/content/classes/AbstractProvider).[`constructor`](/sdk/content/classes/AbstractProvider#constructors)

#### Source

[providers/provider-jsonrpc.ts:784](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L784)

## Accessors

### connect

```ts theme={null}
get connect(): FetchRequest[]
```

Get the list of connected FetchRequests.

#### Returns

[`FetchRequest`](/sdk/content/classes/FetchRequest)\[]

The list of connected FetchRequests.

#### Source

[providers/abstract-provider.ts:1026](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1026)

***

### destroyed

```ts theme={null}
get destroyed(): boolean
```

If this provider has been destroyed using the [**destroy**](/sdk/content/classes/AbstractProvider#destroy) method.

Once destroyed, all resources are reclaimed, internal event loops and timers are cleaned up and no further
requests may be sent to the provider.

#### Returns

`boolean`

#### Source

[providers/abstract-provider.ts:2545](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L2545)

***

### paused

```ts theme={null}
get paused(): boolean
```

Whether the provider is currently paused.

A paused provider will not emit any events, and generally should not make any requests to the network, but that
is up to sub-classes to manage.

Setting `paused = true` is identical to calling `.pause(false)`, which will buffer any events that occur while
paused until the provider is unpaused.

#### Returns

`boolean`

Whether the provider is paused.

#### Source

[providers/abstract-provider.ts:2577](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L2577)

***

### pollingInterval

```ts theme={null}
get pollingInterval(): number
```

Get the polling interval.

#### Returns

`number`

The polling interval.

#### Source

[providers/abstract-provider.ts:1183](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1183)

***

### provider

```ts theme={null}
get provider(): this
```

Returns `this`, to allow an **AbstractProvider** to implement the [Contract Runner](../classes/ContractRunner)
interface.

#### Returns

`this`

The provider instance.

#### Source

[providers/abstract-provider.ts:1193](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1193)

***

### ready

```ts theme={null}
get ready(): boolean
```

Returns true only if the JsonRpcApiProvider.\_start | **\_start** has been called.

#### Returns

`boolean`

True if the provider is ready.

#### Source

[providers/provider-jsonrpc.ts:1117](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L1117)

## Methods

### \_clearTimeout()

```ts theme={null}
_clearTimeout(timerId): void
```

Clear a timer created using the AbstractProvider.\_setTimeout | **\_setTimeout** method.

#### Parameters

| Parameter | Type     | Description                   |
| :-------- | :------- | :---------------------------- |
| `timerId` | `number` | The ID of the timer to clear. |

#### Returns

`void`

#### Inherited from

[`AbstractProvider`](/sdk/content/classes/AbstractProvider).[`_clearTimeout`](/sdk/content/classes/AbstractProvider#_cleartimeout)

#### Source

[providers/abstract-provider.ts:2221](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L2221)

***

### destroy()

```ts theme={null}
destroy(): void
```

Destroys the provider, stopping all processing and canceling all pending requests.

#### Returns

`void`

#### Overrides

[`AbstractProvider`](/sdk/content/classes/AbstractProvider).[`destroy`](/sdk/content/classes/AbstractProvider#destroy)

#### Source

[providers/provider-jsonrpc.ts:1587](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L1587)

***

### getActiveRegions()

```ts theme={null}
getActiveRegions(): Promise<Shard[]>
```

Get the active region shards based on the protocol expansion number.

#### Returns

`Promise`\<[`Shard`](/sdk/content/enumerations/Shard)\[]>

A promise that resolves to the active shards.

#### Inherited from

[`AbstractProvider`](/sdk/content/classes/AbstractProvider).[`getActiveRegions`](/sdk/content/classes/AbstractProvider#getactiveregions)

#### Source

[providers/abstract-provider.ts:1110](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1110)

***

### getActiveZones()

```ts theme={null}
getActiveZones(): Promise<Zone[]>
```

Get the active zones for a shard based on the protocol expansion number.

#### Returns

`Promise`\<[`Zone`](/sdk/content/enumerations/Zone)\[]>

A promise that resolves to the active zones.

#### Inherited from

[`AbstractProvider`](/sdk/content/classes/AbstractProvider).[`getActiveZones`](/sdk/content/classes/AbstractProvider#getactivezones)

#### Source

[providers/abstract-provider.ts:1127](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1127)

***

### getLatestQiToQuaiRate()

```ts theme={null}
getLatestQiToQuaiRate(zone, amt?): Promise<bigint>
```

Get the latest Qi rate for a zone.

#### Parameters

| Parameter | Type                                     | Description                                    |
| :-------- | :--------------------------------------- | :--------------------------------------------- |
| `zone`    | [`Zone`](/sdk/content/enumerations/Zone) | The zone to get the rate for.                  |
| `amt`?    | `bigint`                                 | The amount to get the rate for. Default is `1` |

#### Returns

`Promise`\<`bigint`>

A promise that resolves to the latest Qi rate.

#### Inherited from

[`AbstractProvider`](/sdk/content/classes/AbstractProvider).[`getLatestQiToQuaiRate`](/sdk/content/classes/AbstractProvider#getlatestqitoquairate)

#### Source

[providers/abstract-provider.ts:1149](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1149)

***

### getLatestQuaiToQiRate()

```ts theme={null}
getLatestQuaiToQiRate(zone, amt?): Promise<bigint>
```

Get the latest Quai rate for a zone.

#### Parameters

| Parameter | Type                                     | Description                                             |
| :-------- | :--------------------------------------- | :------------------------------------------------------ |
| `zone`    | [`Zone`](/sdk/content/enumerations/Zone) | The zone to get the rate for.                           |
| `amt`?    | `bigint`                                 | The amount in quais to get the rate for. Default is `1` |

#### Returns

`Promise`\<`bigint`>

A promise that resolves to the latest Quai -> Qi rate for the given amount.

#### Inherited from

[`AbstractProvider`](/sdk/content/classes/AbstractProvider).[`getLatestQuaiToQiRate`](/sdk/content/classes/AbstractProvider#getlatestquaitoqirate)

#### Source

[providers/abstract-provider.ts:1068](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1068)

***

### getProtocolExpansionNumber()

```ts theme={null}
getProtocolExpansionNumber(): Promise<number>
```

Get the protocol expansion number.

#### Returns

`Promise`\<`number`>

A promise that resolves to the protocol expansion number.

#### Inherited from

[`AbstractProvider`](/sdk/content/classes/AbstractProvider).[`getProtocolExpansionNumber`](/sdk/content/classes/AbstractProvider#getprotocolexpansionnumber)

#### Source

[providers/abstract-provider.ts:1101](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1101)

***

### getQiToQuaiRateAtBlock()

```ts theme={null}
getQiToQuaiRateAtBlock(
   zone, 
   blockTag, 
amt?): Promise<bigint>
```

Get the Qi rate at a specific block.

#### Parameters

| Parameter  | Type                                             | Description                                    |
| :--------- | :----------------------------------------------- | :--------------------------------------------- |
| `zone`     | [`Zone`](/sdk/content/enumerations/Zone)         | The zone to get the rate for.                  |
| `blockTag` | [`BlockTag`](/sdk/content/type-aliases/BlockTag) | The block tag to get the rate at.              |
| `amt`?     | `bigint`                                         | The amount to get the rate for. Default is `1` |

#### Returns

`Promise`\<`bigint`>

A promise that resolves to the Qi rate at the specified block.

#### Inherited from

[`AbstractProvider`](/sdk/content/classes/AbstractProvider).[`getQiToQuaiRateAtBlock`](/sdk/content/classes/AbstractProvider#getqitoquairateatblock)

#### Source

[providers/abstract-provider.ts:1162](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1162)

***

### getQuaiToQiRateAtBlock()

```ts theme={null}
getQuaiToQiRateAtBlock(
   zone, 
   blockTag, 
amt?): Promise<bigint>
```

Get the Quai rate at a specific block.

#### Parameters

| Parameter  | Type                                             | Description                                    |
| :--------- | :----------------------------------------------- | :--------------------------------------------- |
| `zone`     | [`Zone`](/sdk/content/enumerations/Zone)         | The zone to get the rate for.                  |
| `blockTag` | [`BlockTag`](/sdk/content/type-aliases/BlockTag) | The block tag to get the rate at.              |
| `amt`?     | `bigint`                                         | The amount to get the rate for. Default is `1` |

#### Returns

`Promise`\<`bigint`>

A promise that resolves to the Quai rate at the specified block.

#### Inherited from

[`AbstractProvider`](/sdk/content/classes/AbstractProvider).[`getQuaiToQiRateAtBlock`](/sdk/content/classes/AbstractProvider#getquaitoqirateatblock)

#### Source

[providers/abstract-provider.ts:1081](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1081)

***

### getSigner()

```ts theme={null}
getSigner(address?): Promise<JsonRpcSigner>
```

Returns a JsonRpcSigner for the given address.

#### Parameters

| Parameter  | Type                 | Description                          |
| :--------- | :------------------- | :----------------------------------- |
| `address`? | `string` \| `number` | The address or index of the account. |

#### Returns

`Promise`\<[`JsonRpcSigner`](/sdk/content/classes/JsonRpcSigner)>

A promise that resolves to the JsonRpcSigner.

#### Throws

If the account is invalid.

#### Source

[providers/provider-jsonrpc.ts:1542](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L1542)

***

### initialize()

```ts theme={null}
initialize<U>(urls): Promise<void>
```

Initialize the URL map with the provided URLs.

#### Type parameters

| Type parameter | Value                                                              |
| :------------- | :----------------------------------------------------------------- |
| `U`            | `string`\[] \| [`FetchRequest`](/sdk/content/classes/FetchRequest) |

#### Parameters

| Parameter | Type | Description                          |
| :-------- | :--- | :----------------------------------- |
| `urls`    | `U`  | The URLs to initialize the map with. |

#### Returns

`Promise`\<`void`>

A promise that resolves when the map is initialized.

#### Inherited from

[`AbstractProvider`](/sdk/content/classes/AbstractProvider).[`initialize`](/sdk/content/classes/AbstractProvider#initialize)

#### Source

[providers/abstract-provider.ts:874](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L874)

***

### listAccounts()

```ts theme={null}
listAccounts(): Promise<JsonRpcSigner[]>
```

Returns a list of JsonRpcSigners for all accounts.

#### Returns

`Promise`\<[`JsonRpcSigner`](/sdk/content/classes/JsonRpcSigner)\[]>

A promise that resolves to an array of JsonRpcSigners.

#### Source

[providers/provider-jsonrpc.ts:1579](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L1579)

***

### pause()

```ts theme={null}
pause(dropWhilePaused?): void
```

Pause the provider. If `dropWhilePaused`, any events that occur while paused are dropped, otherwise all events
will be emitted once the provider is unpaused.

#### Parameters

| Parameter          | Type      | Description                          |
| :----------------- | :-------- | :----------------------------------- |
| `dropWhilePaused`? | `boolean` | Whether to drop events while paused. |

#### Returns

`void`

#### Inherited from

[`AbstractProvider`](/sdk/content/classes/AbstractProvider).[`pause`](/sdk/content/classes/AbstractProvider#pause)

#### Source

[providers/abstract-provider.ts:2598](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L2598)

***

### resume()

```ts theme={null}
resume(): void
```

Resume the provider.

#### Returns

`void`

#### Inherited from

[`AbstractProvider`](/sdk/content/classes/AbstractProvider).[`resume`](/sdk/content/classes/AbstractProvider#resume)

#### Source

[providers/abstract-provider.ts:2627](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L2627)

***

### send()

```ts theme={null}
send(
   method, 
   params, 
   shard?, 
now?): Promise<any>
```

Requests the `method` with `params` via the JSON-RPC protocol over the underlying channel. This can be used to
call methods on the backend that do not have a high-level API within the Provider API.

This method queues requests according to the batch constraints in the options, assigns the request a unique ID.

**Do NOT override** this method in sub-classes; instead override JsonRpcApiProvider.\_send | **\_send** or
force the options values in the call to the constructor to modify this method's behavior.

#### Parameters

| Parameter | Type                                       | Description                                    |
| :-------- | :----------------------------------------- | :--------------------------------------------- |
| `method`  | `string`                                   | The method to call.                            |
| `params`  | `any`\[] \| `Record`\<`string`, `any`>     | The parameters to pass to the method.          |
| `shard`?  | [`Shard`](/sdk/content/enumerations/Shard) | The shard to send the request to.              |
| `now`?    | `boolean`                                  | If true, the request will be sent immediately. |

#### Returns

`Promise`\<`any`>

A promise that resolves to the result of the method call.

#### Source

[providers/provider-jsonrpc.ts:1500](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L1500)

***

### shardFromHash()

```ts theme={null}
shardFromHash(hash): Shard
```

Get the shard from a hash.

#### Parameters

| Parameter | Type     | Description                     |
| :-------- | :------- | :------------------------------ |
| `hash`    | `string` | The hash to get the shard from. |

#### Returns

[`Shard`](/sdk/content/enumerations/Shard)

The shard.

#### Inherited from

[`AbstractProvider`](/sdk/content/classes/AbstractProvider).[`shardFromHash`](/sdk/content/classes/AbstractProvider#shardfromhash)

#### Source

[providers/abstract-provider.ts:1047](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1047)

***

### zoneFromAddress()

```ts theme={null}
zoneFromAddress(_address): Promise<Zone>
```

Get the zone from an address.

#### Parameters

| Parameter  | Type                                                   | Description                       |
| :--------- | :----------------------------------------------------- | :-------------------------------- |
| `_address` | [`AddressLike`](/sdk/content/type-aliases/AddressLike) | The address to get the zone from. |

#### Returns

`Promise`\<[`Zone`](/sdk/content/enumerations/Zone)>

A promise that resolves to the zone.

#### Inherited from

[`AbstractProvider`](/sdk/content/classes/AbstractProvider).[`zoneFromAddress`](/sdk/content/classes/AbstractProvider#zonefromaddress)

#### Source

[providers/abstract-provider.ts:1036](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1036)

***

### zoneFromHash()

```ts theme={null}
zoneFromHash(hash): Zone
```

Get the zone from a hash.

#### Parameters

| Parameter | Type     | Description                    |
| :-------- | :------- | :----------------------------- |
| `hash`    | `string` | The hash to get the zone from. |

#### Returns

[`Zone`](/sdk/content/enumerations/Zone)

The zone.

#### Inherited from

[`AbstractProvider`](/sdk/content/classes/AbstractProvider).[`zoneFromHash`](/sdk/content/classes/AbstractProvider#zonefromhash)

#### Source

[providers/abstract-provider.ts:1057](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1057)


# JsonRpcProvider
Source: https://docs.qu.ai/sdk/content/classes/JsonRpcProvider



The JsonRpcProvider is one of the most common Providers, which performs all operations over HTTP (or HTTPS) requests.

Events are processed by polling the backend for the current block number; when it advances, all block-base events are
then checked for updates.

## Extends

* [`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider)

## Accessors

### connect

```ts theme={null}
get connect(): FetchRequest[]
```

Get the list of connected FetchRequests.

#### Returns

[`FetchRequest`](/sdk/content/classes/FetchRequest)\[]

The list of connected FetchRequests.

#### Source

[providers/abstract-provider.ts:1026](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1026)

***

### destroyed

```ts theme={null}
get destroyed(): boolean
```

If this provider has been destroyed using the [**destroy**](/sdk/content/classes/AbstractProvider#destroy) method.

Once destroyed, all resources are reclaimed, internal event loops and timers are cleaned up and no further
requests may be sent to the provider.

#### Returns

`boolean`

#### Source

[providers/abstract-provider.ts:2545](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L2545)

***

### paused

```ts theme={null}
get paused(): boolean
```

Whether the provider is currently paused.

A paused provider will not emit any events, and generally should not make any requests to the network, but that
is up to sub-classes to manage.

Setting `paused = true` is identical to calling `.pause(false)`, which will buffer any events that occur while
paused until the provider is unpaused.

#### Returns

`boolean`

Whether the provider is paused.

#### Source

[providers/abstract-provider.ts:2577](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L2577)

***

### pollingInterval

```ts theme={null}
get pollingInterval(): number
```

Get the polling interval.

#### Returns

`number`

The polling interval.

#### Source

[providers/abstract-provider.ts:1183](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1183)

***

### provider

```ts theme={null}
get provider(): this
```

Returns `this`, to allow an **AbstractProvider** to implement the [Contract Runner](../classes/ContractRunner)
interface.

#### Returns

`this`

The provider instance.

#### Source

[providers/abstract-provider.ts:1193](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1193)

***

### ready

```ts theme={null}
get ready(): boolean
```

Returns true only if the JsonRpcApiProvider.\_start | **\_start** has been called.

#### Returns

`boolean`

True if the provider is ready.

#### Source

[providers/provider-jsonrpc.ts:1117](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L1117)

## Methods

### \_clearTimeout()

```ts theme={null}
_clearTimeout(timerId): void
```

Clear a timer created using the AbstractProvider.\_setTimeout | **\_setTimeout** method.

#### Parameters

| Parameter | Type     | Description                   |
| :-------- | :------- | :---------------------------- |
| `timerId` | `number` | The ID of the timer to clear. |

#### Returns

`void`

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`_clearTimeout`](/sdk/content/classes/JsonRpcApiProvider#_cleartimeout)

#### Source

[providers/abstract-provider.ts:2221](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L2221)

***

### destroy()

```ts theme={null}
destroy(): void
```

Destroys the provider, stopping all processing and canceling all pending requests.

#### Returns

`void`

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`destroy`](/sdk/content/classes/JsonRpcApiProvider#destroy)

#### Source

[providers/provider-jsonrpc.ts:1587](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L1587)

***

### getActiveRegions()

```ts theme={null}
getActiveRegions(): Promise<Shard[]>
```

Get the active region shards based on the protocol expansion number.

#### Returns

`Promise`\<[`Shard`](/sdk/content/enumerations/Shard)\[]>

A promise that resolves to the active shards.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`getActiveRegions`](/sdk/content/classes/JsonRpcApiProvider#getactiveregions)

#### Source

[providers/abstract-provider.ts:1110](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1110)

***

### getActiveZones()

```ts theme={null}
getActiveZones(): Promise<Zone[]>
```

Get the active zones for a shard based on the protocol expansion number.

#### Returns

`Promise`\<[`Zone`](/sdk/content/enumerations/Zone)\[]>

A promise that resolves to the active zones.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`getActiveZones`](/sdk/content/classes/JsonRpcApiProvider#getactivezones)

#### Source

[providers/abstract-provider.ts:1127](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1127)

***

### getLatestQiToQuaiRate()

```ts theme={null}
getLatestQiToQuaiRate(zone, amt?): Promise<bigint>
```

Get the latest Qi rate for a zone.

#### Parameters

| Parameter | Type                                     | Description                                    |
| :-------- | :--------------------------------------- | :--------------------------------------------- |
| `zone`    | [`Zone`](/sdk/content/enumerations/Zone) | The zone to get the rate for.                  |
| `amt`?    | `bigint`                                 | The amount to get the rate for. Default is `1` |

#### Returns

`Promise`\<`bigint`>

A promise that resolves to the latest Qi rate.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`getLatestQiToQuaiRate`](/sdk/content/classes/JsonRpcApiProvider#getlatestqitoquairate)

#### Source

[providers/abstract-provider.ts:1149](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1149)

***

### getLatestQuaiToQiRate()

```ts theme={null}
getLatestQuaiToQiRate(zone, amt?): Promise<bigint>
```

Get the latest Quai rate for a zone.

#### Parameters

| Parameter | Type                                     | Description                                             |
| :-------- | :--------------------------------------- | :------------------------------------------------------ |
| `zone`    | [`Zone`](/sdk/content/enumerations/Zone) | The zone to get the rate for.                           |
| `amt`?    | `bigint`                                 | The amount in quais to get the rate for. Default is `1` |

#### Returns

`Promise`\<`bigint`>

A promise that resolves to the latest Quai -> Qi rate for the given amount.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`getLatestQuaiToQiRate`](/sdk/content/classes/JsonRpcApiProvider#getlatestquaitoqirate)

#### Source

[providers/abstract-provider.ts:1068](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1068)

***

### getProtocolExpansionNumber()

```ts theme={null}
getProtocolExpansionNumber(): Promise<number>
```

Get the protocol expansion number.

#### Returns

`Promise`\<`number`>

A promise that resolves to the protocol expansion number.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`getProtocolExpansionNumber`](/sdk/content/classes/JsonRpcApiProvider#getprotocolexpansionnumber)

#### Source

[providers/abstract-provider.ts:1101](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1101)

***

### getQiToQuaiRateAtBlock()

```ts theme={null}
getQiToQuaiRateAtBlock(
   zone, 
   blockTag, 
amt?): Promise<bigint>
```

Get the Qi rate at a specific block.

#### Parameters

| Parameter  | Type                                             | Description                                    |
| :--------- | :----------------------------------------------- | :--------------------------------------------- |
| `zone`     | [`Zone`](/sdk/content/enumerations/Zone)         | The zone to get the rate for.                  |
| `blockTag` | [`BlockTag`](/sdk/content/type-aliases/BlockTag) | The block tag to get the rate at.              |
| `amt`?     | `bigint`                                         | The amount to get the rate for. Default is `1` |

#### Returns

`Promise`\<`bigint`>

A promise that resolves to the Qi rate at the specified block.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`getQiToQuaiRateAtBlock`](/sdk/content/classes/JsonRpcApiProvider#getqitoquairateatblock)

#### Source

[providers/abstract-provider.ts:1162](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1162)

***

### getQuaiToQiRateAtBlock()

```ts theme={null}
getQuaiToQiRateAtBlock(
   zone, 
   blockTag, 
amt?): Promise<bigint>
```

Get the Quai rate at a specific block.

#### Parameters

| Parameter  | Type                                             | Description                                    |
| :--------- | :----------------------------------------------- | :--------------------------------------------- |
| `zone`     | [`Zone`](/sdk/content/enumerations/Zone)         | The zone to get the rate for.                  |
| `blockTag` | [`BlockTag`](/sdk/content/type-aliases/BlockTag) | The block tag to get the rate at.              |
| `amt`?     | `bigint`                                         | The amount to get the rate for. Default is `1` |

#### Returns

`Promise`\<`bigint`>

A promise that resolves to the Quai rate at the specified block.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`getQuaiToQiRateAtBlock`](/sdk/content/classes/JsonRpcApiProvider#getquaitoqirateatblock)

#### Source

[providers/abstract-provider.ts:1081](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1081)

***

### getSigner()

```ts theme={null}
getSigner(address?): Promise<JsonRpcSigner>
```

Returns a JsonRpcSigner for the given address.

#### Parameters

| Parameter  | Type                 | Description                          |
| :--------- | :------------------- | :----------------------------------- |
| `address`? | `string` \| `number` | The address or index of the account. |

#### Returns

`Promise`\<[`JsonRpcSigner`](/sdk/content/classes/JsonRpcSigner)>

A promise that resolves to the JsonRpcSigner.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`getSigner`](/sdk/content/classes/JsonRpcApiProvider#getsigner)

#### Throws

If the account is invalid.

#### Source

[providers/provider-jsonrpc.ts:1542](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L1542)

***

### initialize()

```ts theme={null}
initialize<U>(urls): Promise<void>
```

Initialize the URL map with the provided URLs.

#### Type parameters

| Type parameter | Value                                                              |
| :------------- | :----------------------------------------------------------------- |
| `U`            | `string`\[] \| [`FetchRequest`](/sdk/content/classes/FetchRequest) |

#### Parameters

| Parameter | Type | Description                          |
| :-------- | :--- | :----------------------------------- |
| `urls`    | `U`  | The URLs to initialize the map with. |

#### Returns

`Promise`\<`void`>

A promise that resolves when the map is initialized.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`initialize`](/sdk/content/classes/JsonRpcApiProvider#initialize)

#### Source

[providers/abstract-provider.ts:874](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L874)

***

### listAccounts()

```ts theme={null}
listAccounts(): Promise<JsonRpcSigner[]>
```

Returns a list of JsonRpcSigners for all accounts.

#### Returns

`Promise`\<[`JsonRpcSigner`](/sdk/content/classes/JsonRpcSigner)\[]>

A promise that resolves to an array of JsonRpcSigners.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`listAccounts`](/sdk/content/classes/JsonRpcApiProvider#listaccounts)

#### Source

[providers/provider-jsonrpc.ts:1579](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L1579)

***

### pause()

```ts theme={null}
pause(dropWhilePaused?): void
```

Pause the provider. If `dropWhilePaused`, any events that occur while paused are dropped, otherwise all events
will be emitted once the provider is unpaused.

#### Parameters

| Parameter          | Type      | Description                          |
| :----------------- | :-------- | :----------------------------------- |
| `dropWhilePaused`? | `boolean` | Whether to drop events while paused. |

#### Returns

`void`

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`pause`](/sdk/content/classes/JsonRpcApiProvider#pause)

#### Source

[providers/abstract-provider.ts:2598](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L2598)

***

### resume()

```ts theme={null}
resume(): void
```

Resume the provider.

#### Returns

`void`

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`resume`](/sdk/content/classes/JsonRpcApiProvider#resume)

#### Source

[providers/abstract-provider.ts:2627](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L2627)

***

### shardFromHash()

```ts theme={null}
shardFromHash(hash): Shard
```

Get the shard from a hash.

#### Parameters

| Parameter | Type     | Description                     |
| :-------- | :------- | :------------------------------ |
| `hash`    | `string` | The hash to get the shard from. |

#### Returns

[`Shard`](/sdk/content/enumerations/Shard)

The shard.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`shardFromHash`](/sdk/content/classes/JsonRpcApiProvider#shardfromhash)

#### Source

[providers/abstract-provider.ts:1047](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1047)

***

### zoneFromAddress()

```ts theme={null}
zoneFromAddress(_address): Promise<Zone>
```

Get the zone from an address.

#### Parameters

| Parameter  | Type                                                   | Description                       |
| :--------- | :----------------------------------------------------- | :-------------------------------- |
| `_address` | [`AddressLike`](/sdk/content/type-aliases/AddressLike) | The address to get the zone from. |

#### Returns

`Promise`\<[`Zone`](/sdk/content/enumerations/Zone)>

A promise that resolves to the zone.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`zoneFromAddress`](/sdk/content/classes/JsonRpcApiProvider#zonefromaddress)

#### Source

[providers/abstract-provider.ts:1036](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1036)

***

### zoneFromHash()

```ts theme={null}
zoneFromHash(hash): Zone
```

Get the zone from a hash.

#### Parameters

| Parameter | Type     | Description                    |
| :-------- | :------- | :----------------------------- |
| `hash`    | `string` | The hash to get the zone from. |

#### Returns

[`Zone`](/sdk/content/enumerations/Zone)

The zone.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`zoneFromHash`](/sdk/content/classes/JsonRpcApiProvider#zonefromhash)

#### Source

[providers/abstract-provider.ts:1057](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1057)


# JsonRpcSigner
Source: https://docs.qu.ai/sdk/content/classes/JsonRpcSigner



A signer that uses JSON-RPC to sign transactions and messages.

## Extends

* [`AbstractSigner`](/sdk/content/classes/AbstractSigner)\<[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider)>

## Constructors

### new JsonRpcSigner()

```ts theme={null}
new JsonRpcSigner(provider, address): JsonRpcSigner
```

Creates a new JsonRpcSigner instance.

#### Parameters

| Parameter  | Type                                                                    | Description                |
| :--------- | :---------------------------------------------------------------------- | :------------------------- |
| `provider` | [`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider)\<`any`> | The JSON-RPC provider.     |
| `address`  | `string`                                                                | The address of the signer. |

#### Returns

[`JsonRpcSigner`](/sdk/content/classes/JsonRpcSigner)

#### Overrides

[`AbstractSigner`](/sdk/content/classes/AbstractSigner).[`constructor`](/sdk/content/classes/AbstractSigner#constructors)

#### Source

[providers/provider-jsonrpc.ts:328](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L328)

## Properties

| Property   | Modifier   | Type                                                                                                                  | Description                               | Inherited from                                                     |
| :--------- | :--------- | :-------------------------------------------------------------------------------------------------------------------- | :---------------------------------------- | :----------------------------------------------------------------- |
| `provider` | `readonly` | [`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider)\<[`FetchRequest`](/sdk/content/classes/FetchRequest)> | The provider this signer is connected to. | [`AbstractSigner`](/sdk/content/classes/AbstractSigner).`provider` |

## Methods

### connect()

```ts theme={null}
connect(provider): Signer
```

Connects the signer to a provider.

#### Parameters

| Parameter  | Type                                                     | Description                 |
| :--------- | :------------------------------------------------------- | :-------------------------- |
| `provider` | `null` \| [`Provider`](/sdk/content/interfaces/Provider) | The provider to connect to. |

#### Returns

[`Signer`](/sdk/content/interfaces/Signer)

The connected signer.

#### Overrides

[`AbstractSigner`](/sdk/content/classes/AbstractSigner).[`connect`](/sdk/content/classes/AbstractSigner#connect)

#### Throws

If the signer cannot be reconnected.

#### Source

[providers/provider-jsonrpc.ts:342](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L342)

***

### getAddress()

```ts theme={null}
getAddress(): Promise<string>
```

Gets the address of the signer.

#### Returns

`Promise`\<`string`>

The address of the signer.

#### Overrides

[`AbstractSigner`](/sdk/content/classes/AbstractSigner).[`getAddress`](/sdk/content/classes/AbstractSigner#getaddress)

#### Source

[providers/provider-jsonrpc.ts:353](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L353)

***

### sendTransaction()

```ts theme={null}
sendTransaction(tx): Promise<TransactionResponse>
```

Sends a transaction.

#### Parameters

| Parameter | Type                                                                 | Description              |
| :-------- | :------------------------------------------------------------------- | :----------------------- |
| `tx`      | [`TransactionRequest`](/sdk/content/type-aliases/TransactionRequest) | The transaction request. |

#### Returns

`Promise`\<[`TransactionResponse`](/sdk/content/type-aliases/TransactionResponse)>

The transaction response.

#### Overrides

`AbstractSigner.sendTransaction`

#### Throws

If the transaction cannot be sent.

#### Source

[providers/provider-jsonrpc.ts:438](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L438)

***

### signMessage()

```ts theme={null}
signMessage(_message): Promise<string>
```

Signs a message.

#### Parameters

| Parameter  | Type                     | Description          |
| :--------- | :----------------------- | :------------------- |
| `_message` | `string` \| `Uint8Array` | The message to sign. |

#### Returns

`Promise`\<`string`>

The signed message.

#### Overrides

`AbstractSigner.signMessage`

#### Source

[providers/provider-jsonrpc.ts:551](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L551)

***

### signTransaction()

```ts theme={null}
signTransaction(_tx): Promise<string>
```

Signs a transaction.

#### Parameters

| Parameter | Type                                                                 | Description              |
| :-------- | :------------------------------------------------------------------- | :----------------------- |
| `_tx`     | [`TransactionRequest`](/sdk/content/type-aliases/TransactionRequest) | The transaction request. |

#### Returns

`Promise`\<`string`>

The signed transaction.

#### Overrides

`AbstractSigner.signTransaction`

#### Throws

If the transaction cannot be signed.

#### Source

[providers/provider-jsonrpc.ts:521](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L521)

***

### signTypedData()

```ts theme={null}
signTypedData(
   domain, 
   types, 
_value): Promise<string>
```

Signs typed data.

#### Parameters

| Parameter | Type                                                                               | Description                   |
| :-------- | :--------------------------------------------------------------------------------- | :---------------------------- |
| `domain`  | [`TypedDataDomain`](/sdk/content/interfaces/TypedDataDomain)                       | The domain of the typed data. |
| `types`   | `Record`\<`string`, [`TypedDataField`](/sdk/content/interfaces/TypedDataField)\[]> | The types of the typed data.  |
| `_value`  | `Record`\<`string`, `any`>                                                         | The value of the typed data.  |

#### Returns

`Promise`\<`string`>

The signed typed data.

#### Overrides

`AbstractSigner.signTypedData`

#### Source

[providers/provider-jsonrpc.ts:564](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L564)

***

### unlock()

```ts theme={null}
unlock(password): Promise<boolean>
```

Unlocks the account.

#### Parameters

| Parameter  | Type     | Description                         |
| :--------- | :------- | :---------------------------------- |
| `password` | `string` | The password to unlock the account. |

#### Returns

`Promise`\<`boolean`>

True if the account is unlocked, false otherwise.

#### Source

[providers/provider-jsonrpc.ts:583](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L583)


# Log
Source: https://docs.qu.ai/sdk/content/classes/Log



A **Log** in Ethereum represents an event that has been included in a transaction using the `LOG*` opcodes, which are
most commonly used by Solidity's emit for announcing events.

## Extended by

* [`EventLog`](/sdk/content/classes/EventLog)
* [`UndecodedEventLog`](/sdk/content/classes/UndecodedEventLog)

## Implements

* [`LogParams`](/sdk/content/interfaces/LogParams)

## Properties

| Property           | Modifier   | Type                                           | Description                                                                                                                                                                                                                                                                 |
| :----------------- | :--------- | :--------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `address`          | `readonly` | `string`                                       | The address of the contract that emitted this log.                                                                                                                                                                                                                          |
| `blockHash`        | `readonly` | `string`                                       | The block hash of the block this log occurred in. Use the [**Log.getBlock**](/sdk/content/classes/Log#getblock) to get the<br />[**Block**](/sdk/content/classes/Block).                                                                                                    |
| `blockNumber`      | `readonly` | `number`                                       | The block number of the block this log occurred in. It is preferred to use the Block.hash \| **Block.hash**<br />when fetching the related [**Block**](/sdk/content/classes/Block), since in the case of an orphaned block, the block at that<br />height may have changed. |
| `data`             | `readonly` | `string`                                       | The data included in this log when it was emitted.                                                                                                                                                                                                                          |
| `index`            | `readonly` | `number`                                       | The index within the block this log occurred at. This is generally not useful to developers, but can be used with<br />the various roots to proof inclusion within a block.                                                                                                 |
| `provider`         | `readonly` | [`Provider`](/sdk/content/interfaces/Provider) | The provider connected to the log used to fetch additional details if necessary.                                                                                                                                                                                            |
| `removed`          | `readonly` | `boolean`                                      | If the **Log** represents a block that was removed due to an orphaned block, this will be true.<br /><br />This can only happen within an orphan event listener.                                                                                                            |
| `topics`           | `readonly` | readonly `string`\[]                           | The indexed topics included in this log when it was emitted.<br /><br />All topics are included in the bloom filters, so they can be efficiently filtered using the<br />[**Provider.getLogs**](/sdk/content/interfaces/Provider#getlogs) method.                           |
| `transactionHash`  | `readonly` | `string`                                       | The transaction hash of the transaction this log occurred in. Use the<br />[**Log.getTransaction**](/sdk/content/classes/Log#gettransaction) to get the<br />[\*\*TransactionResponse](/sdk/content/type-aliases/TransactionResponse).                                      |
| `transactionIndex` | `readonly` | `number`                                       | The index within the transaction of this log.                                                                                                                                                                                                                               |

## Methods

### getBlock()

```ts theme={null}
getBlock(shard): Promise<Block>
```

Returns the block that this log occurred in.

#### Parameters

| Parameter | Type                                       | Description                        |
| :-------- | :----------------------------------------- | :--------------------------------- |
| `shard`   | [`Shard`](/sdk/content/enumerations/Shard) | The shard to fetch the block from. |

#### Returns

`Promise`\<[`Block`](/sdk/content/classes/Block)>

A promise resolving to the block.

#### Source

[providers/provider.ts:1089](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1089)

***

### getTransaction()

```ts theme={null}
getTransaction(): Promise<TransactionResponse>
```

Returns the transaction that this log occurred in.

#### Returns

`Promise`\<[`TransactionResponse`](/sdk/content/type-aliases/TransactionResponse)>

A promise resolving to the transaction.

#### Source

[providers/provider.ts:1100](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1100)

***

### getTransactionReceipt()

```ts theme={null}
getTransactionReceipt(): Promise<TransactionReceipt>
```

Returns the transaction receipt fot the transaction that this log occurred in.

#### Returns

`Promise`\<[`TransactionReceipt`](/sdk/content/classes/TransactionReceipt)>

A promise resolving to the transaction receipt.

#### Source

[providers/provider.ts:1111](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1111)

***

### toJSON()

```ts theme={null}
toJSON(): any
```

Returns a JSON-compatible object.

#### Returns

`any`

#### Source

[providers/provider.ts:1065](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1065)


# Network
Source: https://docs.qu.ai/sdk/content/classes/Network



A **Network** provides access to a chain's properties and allows for plug-ins to extend functionality.

## Constructors

### new Network()

```ts theme={null}
new Network(name, chainId): Network
```

Creates a new **Network** for `name` and `chainId`.

#### Parameters

| Parameter | Type                                                     | Description           |
| :-------- | :------------------------------------------------------- | :-------------------- |
| `name`    | `string`                                                 | The network name.     |
| `chainId` | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The network chain ID. |

#### Returns

[`Network`](/sdk/content/classes/Network)

#### Source

[providers/network.ts:48](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/network.ts#L48)

## Accessors

### chainId

```ts theme={null}
get chainId(): bigint
```

The network chain ID.

```ts theme={null}
set chainId(value): void
```

Sets the network chain ID.

#### Parameters

| Parameter | Type                                                     | Description               |
| :-------- | :------------------------------------------------------- | :------------------------ |
| `value`   | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The new network chain ID. |

#### Returns

`bigint`

The network chain ID.

#### Source

[providers/network.ts:87](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/network.ts#L87)

***

### name

```ts theme={null}
get name(): string
```

The network common name.

This is the canonical name, as networks might have multiple names.

```ts theme={null}
set name(value): void
```

Sets the network name.

#### Parameters

| Parameter | Type     | Description           |
| :-------- | :------- | :-------------------- |
| `value`   | `string` | The new network name. |

#### Returns

`string`

The network name.

#### Source

[providers/network.ts:69](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/network.ts#L69)

## Methods

### clone()

```ts theme={null}
clone(): Network
```

Create a copy of this Network.

#### Returns

[`Network`](/sdk/content/classes/Network)

A new Network instance.

#### Source

[providers/network.ts:153](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/network.ts#L153)

***

### toJSON()

```ts theme={null}
toJSON(): any
```

Returns a JSON-compatible representation of a Network.

#### Returns

`any`

The JSON representation of the network.

#### Source

[providers/network.ts:58](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/network.ts#L58)

***

### from()

```ts theme={null}
static from(network?): Network
```

Returns a new Network for the `network` name or chainId.

#### Parameters

| Parameter  | Type                                                 | Description         |
| :--------- | :--------------------------------------------------- | :------------------ |
| `network`? | [`Networkish`](/sdk/content/type-aliases/Networkish) | The network to get. |

#### Returns

[`Network`](/sdk/content/classes/Network)

The Network instance.

#### Throws

If the network is invalid.

#### Source

[providers/network.ts:165](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/network.ts#L165)

***

### register()

```ts theme={null}
static register(nameOrChainId, networkFunc): void
```

Register `nameOrChainId` with a function which returns an instance of a Network representing that chain.

#### Parameters

| Parameter       | Type                                            | Description                         |
| :-------------- | :---------------------------------------------- | :---------------------------------- |
| `nameOrChainId` | `string` \| `number` \| `bigint`                | The name or chain ID to register.   |
| `networkFunc`   | () => [`Network`](/sdk/content/classes/Network) | The function to create the Network. |

#### Returns

`void`

#### Throws

If a network is already registered for `nameOrChainId`.

#### Source

[providers/network.ts:217](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/network.ts#L217)


# QiTransaction
Source: https://docs.qu.ai/sdk/content/classes/QiTransaction



Class representing a QiTransaction.

## Implements

## Extends

* `AbstractTransaction`\<`string`>

## Implements

* `QiTransactionLike`

## Constructors

### new QiTransaction()

```ts theme={null}
new QiTransaction(): QiTransaction
```

Creates a new Transaction with default values.

#### Returns

[`QiTransaction`](/sdk/content/classes/QiTransaction)

#### Overrides

`AbstractTransaction<string>.constructor`

#### Source

[transaction/qi-transaction.ts:185](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/qi-transaction.ts#L185)

## Accessors

### chainId

```ts theme={null}
get chainId(): bigint
```

The chain ID this transaction is valid on.

#### Returns

`bigint`

#### Source

[transaction/abstract-transaction.ts:275](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/abstract-transaction.ts#L275)

***

### data

```ts theme={null}
get data(): Uint8Array
```

Get transaction data.

```ts theme={null}
set data(value): void
```

Set transaction data.

#### Parameters

| Parameter | Type                   | Description           |
| :-------- | :--------------------- | :-------------------- |
| `value`   | `null` \| `Uint8Array` | The transaction data. |

#### Returns

`Uint8Array`

The transaction data.

#### Source

[transaction/qi-transaction.ts:99](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/qi-transaction.ts#L99)

***

### destZone

```ts theme={null}
get destZone(): undefined | Zone
```

Get the zone of the recipient address.

#### Returns

`undefined` | [`Zone`](/sdk/content/enumerations/Zone)

The destination zone.

#### Source

[transaction/qi-transaction.ts:177](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/qi-transaction.ts#L177)

***

### digest

```ts theme={null}
get digest(): string
```

The pre-image hash of this transaction.

This is the digest that a [Signer](../interfaces/Signer) must sign to authorize this transaction.

#### Returns

`string`

#### Source

[transaction/abstract-transaction.ts:310](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/abstract-transaction.ts#L310)

***

### hash

```ts theme={null}
get hash(): null | string
```

Get the permuted hash of the transaction as specified by QIP-0010.

#### Throws

If the transaction has no inputs or outputs, or if cross-zone & cross-ledger transactions are not
supported.

#### See

[QIP0010](https://github.com/quai-network/qips/blob/master/qip-0010.md)

#### Returns

`null` | `string`

The transaction hash.

#### Source

[transaction/qi-transaction.ts:121](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/qi-transaction.ts#L121)

***

### isExternal

```ts theme={null}
get isExternal(): boolean
```

Check if the transaction is external.

#### Returns

`boolean`

True if the transaction is external.

#### Source

[transaction/abstract-transaction.ts:412](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/abstract-transaction.ts#L412)

***

### originZone

```ts theme={null}
get originZone(): undefined | Zone
```

Get the zone of the sender address.

#### Returns

`undefined` | [`Zone`](/sdk/content/enumerations/Zone)

The origin zone.

#### Source

[transaction/qi-transaction.ts:165](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/qi-transaction.ts#L165)

***

### serialized

```ts theme={null}
get serialized(): string
```

The serialized transaction.

This throws if the transaction is unsigned. For the pre-image, use
[**unsignedSerialized** ](/sdk/content/classes/QiTransaction#unsignedserialized).

#### Returns

`string`

#### Source

[transaction/abstract-transaction.ts:336](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/abstract-transaction.ts#L336)

***

### signature

```ts theme={null}
get signature(): S
```

If signed, the signature for this transaction.

#### Returns

`S`

#### Source

[transaction/abstract-transaction.ts:285](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/abstract-transaction.ts#L285)

***

### txInputs

```ts theme={null}
get txInputs(): TxInput[]
```

Get transaction inputs.

```ts theme={null}
set txInputs(value): void
```

Set transaction inputs.

#### Throws

If the value is not an array.

#### Parameters

| Parameter | Type                   | Description             |
| :-------- | :--------------------- | :---------------------- |
| `value`   | `null` \| `TxInput`\[] | The transaction inputs. |

#### Returns

`TxInput`\[]

The transaction inputs.

#### Source

[transaction/qi-transaction.ts:55](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/qi-transaction.ts#L55)

***

### txOutputs

```ts theme={null}
get txOutputs(): TxOutput[]
```

Get transaction outputs.

```ts theme={null}
set txOutputs(value): void
```

Set transaction outputs.

#### Throws

If the value is not an array.

#### Parameters

| Parameter | Type                    | Description              |
| :-------- | :---------------------- | :----------------------- |
| `value`   | `null` \| `TxOutput`\[] | The transaction outputs. |

#### Returns

`TxOutput`\[]

The transaction outputs.

#### Source

[transaction/qi-transaction.ts:77](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/qi-transaction.ts#L77)

***

### type

```ts theme={null}
get type(): null | number
```

The transaction type.

If null, the type will be automatically inferred based on explicit properties.

#### Returns

`null` | `number`

#### Source

[transaction/abstract-transaction.ts:235](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/abstract-transaction.ts#L235)

***

### typeName

```ts theme={null}
get typeName(): null | string
```

The name of the transaction type.

#### Returns

`null` | `string`

#### Source

[transaction/abstract-transaction.ts:259](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/abstract-transaction.ts#L259)

***

### unsignedSerialized

```ts theme={null}
get unsignedSerialized(): string
```

The transaction pre-image.

The hash of this is the digest which needs to be signed to authorize this transaction.

#### Returns

`string`

#### Source

[transaction/abstract-transaction.ts:351](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/abstract-transaction.ts#L351)

## Methods

### clone()

```ts theme={null}
clone(): QiTransaction
```

Create a copy of this transaction.

#### Returns

[`QiTransaction`](/sdk/content/classes/QiTransaction)

The cloned transaction.

#### Overrides

`AbstractTransaction.clone`

#### Source

[transaction/qi-transaction.ts:217](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/qi-transaction.ts#L217)

***

### inferType()

```ts theme={null}
inferType(): number
```

Return the most "likely" type; currently the highest supported transaction type.

#### Returns

`number`

The inferred transaction type.

#### Inherited from

`AbstractTransaction.inferType`

#### Source

[transaction/abstract-transaction.ts:360](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/abstract-transaction.ts#L360)

***

### inferTypes()

```ts theme={null}
inferTypes(): number[]
```

Validates the explicit properties and returns a list of compatible transaction types.

#### Returns

`number`\[]

The compatible transaction types.

#### Overrides

`AbstractTransaction.inferTypes`

#### Source

[transaction/qi-transaction.ts:197](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/qi-transaction.ts#L197)

***

### isSigned()

```ts theme={null}
isSigned(): this is AbstractTransaction<string> & Object
```

Returns true if signed.

This provides a Type Guard that properties requiring a signed transaction are non-null.

#### Returns

`this is AbstractTransaction<string> & Object`

Indicates if the transaction is signed.

#### Inherited from

`AbstractTransaction.isSigned`

#### Source

[transaction/abstract-transaction.ts:321](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/abstract-transaction.ts#L321)

***

### toJSON()

```ts theme={null}
toJSON(): TransactionLike
```

Return a JSON-friendly object.

#### Returns

[`TransactionLike`](/sdk/content/interfaces/TransactionLike)

The JSON-friendly object.

#### Overrides

`AbstractTransaction.toJSON`

#### Source

[transaction/qi-transaction.ts:226](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/qi-transaction.ts#L226)

***

### toProtobuf()

```ts theme={null}
toProtobuf(includeSignature?): ProtoTransaction
```

Return a protobuf-friendly JSON object.

#### Parameters

| Parameter           | Type      | Default value | Description                                         |
| :------------------ | :-------- | :------------ | :-------------------------------------------------- |
| `includeSignature`? | `boolean` | `true`        | Whether to include the signature. Default is `true` |

#### Returns

`ProtoTransaction`

The protobuf-friendly JSON object.

#### Overrides

`AbstractTransaction.toProtobuf`

#### Source

[transaction/qi-transaction.ts:251](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/qi-transaction.ts#L251)

***

### from()

```ts theme={null}
static from(tx): QiTransaction
```

Create a Transaction from a serialized transaction or a Transaction-like object.

#### Parameters

| Parameter | Type                            | Description                |
| :-------- | :------------------------------ | :------------------------- |
| `tx`      | `string` \| `QiTransactionLike` | The transaction to decode. |

#### Returns

[`QiTransaction`](/sdk/content/classes/QiTransaction)

The decoded transaction.

#### Throws

If the transaction is unsigned and defines a hash.

#### Source

[transaction/qi-transaction.ts:287](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/qi-transaction.ts#L287)

***

### fromProto()

```ts theme={null}
static fromProto(protoTx): QiTransaction
```

Create a Transaction from a ProtoTransaction object.

#### Parameters

| Parameter | Type               | Description                |
| :-------- | :----------------- | :------------------------- |
| `protoTx` | `ProtoTransaction` | The transaction to decode. |

#### Returns

[`QiTransaction`](/sdk/content/classes/QiTransaction)

The decoded transaction.

#### Source

[transaction/qi-transaction.ts:326](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/qi-transaction.ts#L326)


# QiTransactionResponse
Source: https://docs.qu.ai/sdk/content/classes/QiTransactionResponse



A **QiTransactionResponse** includes all properties about a Qi transaction that was sent to the network, which may or
may not be included in a block.

The TransactionResponse.isMined | **TransactionResponse.isMined** can be used to check if the transaction has
been mined as well as type guard that the otherwise possibly `null` properties are defined.

## Implements

* `QiTransactionLike`
* `QiTransactionResponseParams`

## Properties

| Property      | Modifier   | Type                                           | Description                                                                                                                        |
| :------------ | :--------- | :--------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------- |
| `blockHash`   | `readonly` | `null` \| `string`                             | The blockHash of the block that this transaction was included in.<br /><br />This is `null` for pending transactions.              |
| `blockNumber` | `readonly` | `null` \| `number`                             | The block number of the block that this transaction was included in.<br /><br />This is `null` for pending transactions.           |
| `chainId`     | `readonly` | `bigint`                                       | The chain ID.                                                                                                                      |
| `hash`        | `readonly` | `string`                                       | The transaction hash.                                                                                                              |
| `index`       | `readonly` | `bigint`                                       | The index within the block that this transaction resides at.                                                                       |
| `provider`    | `readonly` | [`Provider`](/sdk/content/interfaces/Provider) | The provider this is connected to, which will influence how its methods will resolve its async inspection<br />methods.            |
| `signature`   | `readonly` | `string`                                       | The signature.                                                                                                                     |
| `type`        | `readonly` | `number`                                       | The [EIP-2718](https://eips.ethereum.org/EIPS/eip-2718) transaction envelope type. This is `0` for legacy<br />transactions types. |

## Methods

### confirmations()

```ts theme={null}
confirmations(): Promise<number>
```

Resolve to the number of confirmations this transaction has.

#### Returns

`Promise`\<`number`>

A promise resolving to the number of confirmations.

#### Source

[providers/provider.ts:2383](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2383)

***

### getBlock()

```ts theme={null}
getBlock(shard): Promise<null | Block>
```

Resolves to the Block that this transaction was included in.

This will return null if the transaction has not been included yet.

#### Parameters

| Parameter | Type                                       | Description                        |
| :-------- | :----------------------------------------- | :--------------------------------- |
| `shard`   | [`Shard`](/sdk/content/enumerations/Shard) | The shard to fetch the block from. |

#### Returns

`Promise`\<`null` | [`Block`](/sdk/content/classes/Block)>

A promise resolving to the block or null if not found.

#### Source

[providers/provider.ts:2344](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2344)

***

### getTransaction()

```ts theme={null}
getTransaction(): Promise<null | QiTransactionResponse>
```

Resolves to this transaction being re-requested from the provider. This can be used if you have an unmined
transaction and wish to get an up-to-date populated instance.

#### Returns

`Promise`\<`null` | [`QiTransactionResponse`](/sdk/content/classes/QiTransactionResponse)>

A promise resolving to the transaction, or null if not found.

#### Throws

If the transaction is not found.

#### Source

[providers/provider.ts:2369](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2369)

***

### isMined()

```ts theme={null}
isMined(): this is QiMinedTransactionResponse
```

Returns `true` if this transaction has been included.

This is effective only as of the time the TransactionResponse was instantiated. To get up-to-date information,
use [**getTransaction**](/sdk/content/classes/QiTransactionResponse#gettransaction).

This provides a Type Guard that this transaction will have non-null property values for properties that are null
for unmined transactions.

#### Returns

`this is QiMinedTransactionResponse`

True if the transaction has been mined or false otherwise.

#### Source

[providers/provider.ts:2462](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2462)

***

### removedEvent()

```ts theme={null}
removedEvent(): OrphanFilter
```

Returns a filter which can be used to listen for orphan events that evict this transaction.

#### Returns

[`OrphanFilter`](/sdk/content/type-aliases/OrphanFilter)

The orphan filter.

#### Source

[providers/provider.ts:2471](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2471)

***

### reorderedEvent()

```ts theme={null}
reorderedEvent(other?): OrphanFilter
```

Returns a filter which can be used to listen for orphan events that re-order this event against `other`.

#### Parameters

| Parameter | Type                                                                   | Description                               |
| :-------- | :--------------------------------------------------------------------- | :---------------------------------------- |
| `other`?  | [`TransactionResponse`](/sdk/content/type-aliases/TransactionResponse) | The other transaction to compare against. |

#### Returns

[`OrphanFilter`](/sdk/content/type-aliases/OrphanFilter)

The orphan filter.

#### Source

[providers/provider.ts:2484](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2484)

***

### replaceableTransaction()

```ts theme={null}
replaceableTransaction(startBlock): QiTransactionResponse
```

Returns a new TransactionResponse instance which has the ability to detect (and throw an error) if the
transaction is replaced, which will begin scanning at `startBlock`.

This should generally not be used by developers and is intended primarily for internal use. Setting an incorrect
`startBlock` can have devastating performance consequences if used incorrectly.

#### Parameters

| Parameter    | Type     | Description                                          |
| :----------- | :------- | :--------------------------------------------------- |
| `startBlock` | `number` | The block number to start scanning for replacements. |

#### Returns

[`QiTransactionResponse`](/sdk/content/classes/QiTransactionResponse)

The replaceable transaction.

#### Source

[providers/provider.ts:2506](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2506)

***

### toJSON()

```ts theme={null}
toJSON(): any
```

Returns a JSON-compatible representation of this transaction.

#### Returns

`any`

#### Source

[providers/provider.ts:2318](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2318)


# QuaiTransaction
Source: https://docs.qu.ai/sdk/content/classes/QuaiTransaction



Represents a Quai transaction.

## Extends

* `AbstractTransaction`\<[`Signature`](/sdk/content/classes/Signature)>

## Implements

* `QuaiTransactionLike`

## Constructors

### new QuaiTransaction()

```ts theme={null}
new QuaiTransaction(from?): QuaiTransaction
```

Creates a new Transaction with default values.

#### Parameters

| Parameter | Type     | Description         |
| :-------- | :------- | :------------------ |
| `from`?   | `string` | The sender address. |

#### Returns

[`QuaiTransaction`](/sdk/content/classes/QuaiTransaction)

#### Overrides

`AbstractTransaction<Signature>.constructor`

#### Source

[transaction/quai-transaction.ts:273](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/quai-transaction.ts#L273)

## Accessors

### accessList

```ts theme={null}
get accessList(): null | AccessList
```

The access list.

An access list permits discounted (but pre-paid) access to bytecode and state variable access within contract
execution.

#### Returns

`null` | [`AccessList`](/sdk/content/type-aliases/AccessList)

#### Source

[transaction/quai-transaction.ts:257](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/quai-transaction.ts#L257)

***

### chainId

```ts theme={null}
get chainId(): bigint
```

The chain ID this transaction is valid on.

#### Returns

`bigint`

#### Source

[transaction/abstract-transaction.ts:275](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/abstract-transaction.ts#L275)

***

### data

```ts theme={null}
get data(): string
```

The transaction data. For `init` transactions this is the deployment code.

#### Returns

`string`

#### Source

[transaction/quai-transaction.ts:230](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/quai-transaction.ts#L230)

***

### destZone

```ts theme={null}
get destZone(): undefined | Zone
```

The zone of the recipient address

#### Returns

`undefined` | [`Zone`](/sdk/content/enumerations/Zone)

#### Source

[transaction/quai-transaction.ts:180](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/quai-transaction.ts#L180)

***

### digest

```ts theme={null}
get digest(): string
```

The pre-image hash of this transaction.

This is the digest that a [Signer](../interfaces/Signer) must sign to authorize this transaction.

#### Returns

`string`

#### Source

[transaction/abstract-transaction.ts:310](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/abstract-transaction.ts#L310)

***

### gasLimit

```ts theme={null}
get gasLimit(): bigint
```

The gas limit.

#### Returns

`bigint`

#### Source

[transaction/quai-transaction.ts:202](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/quai-transaction.ts#L202)

***

### gasPrice

```ts theme={null}
get gasPrice(): null | bigint
```

The maximum total fee per unit of gas to pay. On legacy networks this should be `null`.

#### Returns

`null` | `bigint`

#### Source

[transaction/quai-transaction.ts:214](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/quai-transaction.ts#L214)

***

### hash

```ts theme={null}
get hash(): null | string
```

The permuted hash of the transaction as specified by
[QIP-0010](https://github.com/quai-network/qips/blob/master/qip-0010.md).

#### Throws

If the transaction is not signed.

#### Returns

`null` | `string`

#### Source

[transaction/quai-transaction.ts:135](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/quai-transaction.ts#L135)

***

### isExternal

```ts theme={null}
get isExternal(): boolean
```

Check if the transaction is external.

#### Returns

`boolean`

True if the transaction is external.

#### Source

[transaction/abstract-transaction.ts:412](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/abstract-transaction.ts#L412)

***

### nonce

```ts theme={null}
get nonce(): number
```

The transaction nonce.

#### Returns

`number`

#### Source

[transaction/quai-transaction.ts:190](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/quai-transaction.ts#L190)

***

### originZone

```ts theme={null}
get originZone(): undefined | Zone
```

The zone of the sender address

#### Returns

`undefined` | [`Zone`](/sdk/content/enumerations/Zone)

#### Source

[transaction/quai-transaction.ts:170](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/quai-transaction.ts#L170)

***

### serialized

```ts theme={null}
get serialized(): string
```

The serialized transaction.

This throws if the transaction is unsigned. For the pre-image, use
[**unsignedSerialized** ](/sdk/content/classes/QiTransaction#unsignedserialized).

#### Returns

`string`

#### Source

[transaction/abstract-transaction.ts:336](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/abstract-transaction.ts#L336)

***

### signature

```ts theme={null}
get signature(): S
```

If signed, the signature for this transaction.

#### Returns

`S`

#### Source

[transaction/abstract-transaction.ts:285](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/abstract-transaction.ts#L285)

***

### to

```ts theme={null}
get to(): null | string
```

The `to` address for the transaction or `null` if the transaction is an `init` transaction.

#### Returns

`null` | `string`

#### Source

[transaction/quai-transaction.ts:120](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/quai-transaction.ts#L120)

***

### type

```ts theme={null}
get type(): null | number
```

The transaction type.

If null, the type will be automatically inferred based on explicit properties.

#### Returns

`null` | `number`

#### Source

[transaction/abstract-transaction.ts:235](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/abstract-transaction.ts#L235)

***

### typeName

```ts theme={null}
get typeName(): null | string
```

The name of the transaction type.

#### Returns

`null` | `string`

#### Source

[transaction/abstract-transaction.ts:259](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/abstract-transaction.ts#L259)

***

### unsignedSerialized

```ts theme={null}
get unsignedSerialized(): string
```

The transaction pre-image.

The hash of this is the digest which needs to be signed to authorize this transaction.

#### Returns

`string`

#### Source

[transaction/abstract-transaction.ts:351](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/abstract-transaction.ts#L351)

***

### value

```ts theme={null}
get value(): bigint
```

The amount of ether to send in this transactions.

#### Returns

`bigint`

#### Source

[transaction/quai-transaction.ts:242](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/quai-transaction.ts#L242)

## Methods

### clone()

```ts theme={null}
clone(): QuaiTransaction
```

Create a copy of this transaction.

#### Returns

[`QuaiTransaction`](/sdk/content/classes/QuaiTransaction)

The cloned transaction.

#### Overrides

`AbstractTransaction.clone`

#### Source

[transaction/quai-transaction.ts:317](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/quai-transaction.ts#L317)

***

### inferType()

```ts theme={null}
inferType(): number
```

Return the most "likely" type; currently the highest supported transaction type.

#### Returns

`number`

The inferred transaction type.

#### Inherited from

`AbstractTransaction.inferType`

#### Source

[transaction/abstract-transaction.ts:360](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/abstract-transaction.ts#L360)

***

### inferTypes()

```ts theme={null}
inferTypes(): number[]
```

Validates the explicit properties and returns a list of compatible transaction types.

#### Returns

`number`\[]

The compatible transaction types.

#### Overrides

`AbstractTransaction.inferTypes`

#### Source

[transaction/quai-transaction.ts:290](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/quai-transaction.ts#L290)

***

### isSigned()

```ts theme={null}
isSigned(): this is AbstractTransaction<Signature> & Object
```

Returns true if signed.

This provides a Type Guard that properties requiring a signed transaction are non-null.

#### Returns

`this is AbstractTransaction<Signature> & Object`

Indicates if the transaction is signed.

#### Inherited from

`AbstractTransaction.isSigned`

#### Source

[transaction/abstract-transaction.ts:321](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/abstract-transaction.ts#L321)

***

### toJSON()

```ts theme={null}
toJSON(): QuaiTransactionLike
```

Return a JSON-friendly object.

#### Returns

`QuaiTransactionLike`

The JSON-friendly object.

#### Overrides

`AbstractTransaction.toJSON`

#### Source

[transaction/quai-transaction.ts:326](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/quai-transaction.ts#L326)

***

### toProtobuf()

```ts theme={null}
toProtobuf(includeSignature?): ProtoTransaction
```

Return a protobuf-friendly JSON object.

#### Parameters

| Parameter           | Type      | Default value | Description                                         |
| :------------------ | :-------- | :------------ | :-------------------------------------------------- |
| `includeSignature`? | `boolean` | `true`        | Whether to include the signature. Default is `true` |

#### Returns

`ProtoTransaction`

The protobuf-friendly JSON object.

#### Overrides

`AbstractTransaction.toProtobuf`

#### Source

[transaction/quai-transaction.ts:356](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/quai-transaction.ts#L356)

***

### from()

```ts theme={null}
static from(tx): QuaiTransaction
```

Create a **Transaction** from a serialized transaction or a Transaction-like object.

#### Parameters

| Parameter | Type                              | Description                |
| :-------- | :-------------------------------- | :------------------------- |
| `tx`      | `string` \| `QuaiTransactionLike` | The transaction to decode. |

#### Returns

[`QuaiTransaction`](/sdk/content/classes/QuaiTransaction)

The decoded transaction.

#### Source

[transaction/quai-transaction.ts:394](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/quai-transaction.ts#L394)

***

### fromProto()

```ts theme={null}
static fromProto(protoTx): QuaiTransaction
```

Create a **Transaction** from a ProtoTransaction object.

#### Parameters

| Parameter | Type               | Description                |
| :-------- | :----------------- | :------------------------- |
| `protoTx` | `ProtoTransaction` | The transaction to decode. |

#### Returns

[`QuaiTransaction`](/sdk/content/classes/QuaiTransaction)

The decoded transaction.

#### Source

[transaction/quai-transaction.ts:456](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/quai-transaction.ts#L456)


# QuaiTransactionResponse
Source: https://docs.qu.ai/sdk/content/classes/QuaiTransactionResponse



A **QuaiTransactionResponse** includes all properties about a Quai transaction that was sent to the network, which
may or may not be included in a block.

The TransactionResponse.isMined | **TransactionResponse.isMined** can be used to check if the transaction has
been mined as well as type guard that the otherwise possibly `null` properties are defined.

## Extended by

* [`ContractTransactionResponse`](/sdk/content/classes/ContractTransactionResponse)

## Implements

* `QuaiTransactionLike`
* `QuaiTransactionResponseParams`

## Properties

| Property      | Modifier   | Type                                                           | Description                                                                                                                                                                                                                                                                                                                                                                            |
| :------------ | :--------- | :------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `accessList`  | `readonly` | `null` \| [`AccessList`](/sdk/content/type-aliases/AccessList) | The [EIP-2930](https://eips.ethereum.org/EIPS/eip-2930) access list for transaction types that support it,<br />otherwise `null`.                                                                                                                                                                                                                                                      |
| `blockHash`   | `readonly` | `null` \| `string`                                             | The blockHash of the block that this transaction was included in.<br /><br />This is `null` for pending transactions.                                                                                                                                                                                                                                                                  |
| `blockNumber` | `readonly` | `null` \| `number`                                             | The block number of the block that this transaction was included in.<br /><br />This is `null` for pending transactions.                                                                                                                                                                                                                                                               |
| `chainId`     | `readonly` | `bigint`                                                       | The chain ID.                                                                                                                                                                                                                                                                                                                                                                          |
| `data`        | `readonly` | `string`                                                       | The data.                                                                                                                                                                                                                                                                                                                                                                              |
| `from`        | `readonly` | `string`                                                       | The sender of this transaction. It is implicitly computed from the transaction pre-image hash (as the digest) and<br />the [**signature** ](/sdk/content/classes/QuaiTransactionResponse) using ecrecover.                                                                                                                                                                             |
| `gasLimit`    | `readonly` | `bigint`                                                       | The maximum units of gas this transaction can consume. If execution exceeds this, the entries transaction is<br />reverted and the sender is charged for the full amount, despite not state changes being made.                                                                                                                                                                        |
| `gasPrice`    | `readonly` | `null` \| `bigint`                                             | The maximum fee (per unit of gas) to allow this transaction to charge the sender.                                                                                                                                                                                                                                                                                                      |
| `hash`        | `readonly` | `string`                                                       | The transaction hash.                                                                                                                                                                                                                                                                                                                                                                  |
| `index`       | `readonly` | `bigint`                                                       | The index within the block that this transaction resides at.                                                                                                                                                                                                                                                                                                                           |
| `nonce`       | `readonly` | `number`                                                       | The nonce, which is used to prevent replay attacks and offer a method to ensure transactions from a given sender<br />are explicitly ordered.<br /><br />When sending a transaction, this must be equal to the number of transactions ever sent by<br />[**from** ](/sdk/content/classes/QuaiTransactionResponse).                                                                     |
| `provider`    | `readonly` | [`Provider`](/sdk/content/interfaces/Provider)                 | The provider this is connected to, which will influence how its methods will resolve its async inspection<br />methods.                                                                                                                                                                                                                                                                |
| `signature`   | `readonly` | [`Signature`](/sdk/content/classes/Signature)                  | The signature.                                                                                                                                                                                                                                                                                                                                                                         |
| `to`          | `readonly` | `null` \| `string`                                             | The receiver of this transaction.<br /><br />If `null`, then the transaction is an initcode transaction. This means the result of executing the<br />[**data** ](/sdk/content/classes/QuaiTransactionResponse) will be deployed as a new contract on chain (assuming it does not<br />revert) and the address may be computed using [getCreateAddress](../functions/getCreateAddress). |
| `type`        | `readonly` | `number`                                                       | The [EIP-2718](https://eips.ethereum.org/EIPS/eip-2718) transaction envelope type. This is `0` for legacy<br />transactions types.                                                                                                                                                                                                                                                     |
| `value`       | `readonly` | `bigint`                                                       | The value, in wei. Use [formatEther](../functions/formatEther) to format this value as ether.                                                                                                                                                                                                                                                                                          |

## Methods

### confirmations()

```ts theme={null}
confirmations(): Promise<number>
```

Resolve to the number of confirmations this transaction has.

#### Returns

`Promise`\<`number`>

A promise resolving to the number of confirmations.

#### Throws

If the block is not found.

#### Source

[providers/provider.ts:1921](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1921)

***

### getBlock()

```ts theme={null}
getBlock(shard): Promise<null | Block>
```

Resolves to the Block that this transaction was included in.

This will return null if the transaction has not been included yet.

#### Parameters

| Parameter | Type                                       | Description                        |
| :-------- | :----------------------------------------- | :--------------------------------- |
| `shard`   | [`Shard`](/sdk/content/enumerations/Shard) | The shard to fetch the block from. |

#### Returns

`Promise`\<`null` | [`Block`](/sdk/content/classes/Block)>

A promise resolving to the block.

#### Source

[providers/provider.ts:1882](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1882)

***

### getTransaction()

```ts theme={null}
getTransaction(): Promise<null | QuaiTransactionResponse>
```

Resolves to this transaction being re-requested from the provider. This can be used if you have an unmined
transaction and wish to get an up-to-date populated instance.

#### Returns

`Promise`\<`null` | [`QuaiTransactionResponse`](/sdk/content/classes/QuaiTransactionResponse)>

A promise resolving to the transaction, or null if not found.

#### Source

[providers/provider.ts:1906](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1906)

***

### isMined()

```ts theme={null}
isMined(): this is QuaiMinedTransactionResponse
```

Returns `true` if this transaction has been included.

This is effective only as of the time the TransactionResponse was instantiated. To get up-to-date information,
use [**getTransaction**](/sdk/content/classes/QuaiTransactionResponse#gettransaction).

This provides a Type Guard that this transaction will have non-null property values for properties that are null
for unmined transactions.

#### Returns

`this is QuaiMinedTransactionResponse`

True if the transaction has been mined.

#### Throws

If the transaction was replaced, repriced, or cancelled.

#### Source

[providers/provider.ts:2179](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2179)

***

### removedEvent()

```ts theme={null}
removedEvent(): OrphanFilter
```

Returns a filter which can be used to listen for orphan events that evict this transaction.

#### Returns

[`OrphanFilter`](/sdk/content/type-aliases/OrphanFilter)

The orphan filter.

#### Source

[providers/provider.ts:2188](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2188)

***

### reorderedEvent()

```ts theme={null}
reorderedEvent(other?): OrphanFilter
```

Returns a filter which can be used to listen for orphan events that re-order this event against `other`.

#### Parameters

| Parameter | Type                                                                   | Description                               |
| :-------- | :--------------------------------------------------------------------- | :---------------------------------------- |
| `other`?  | [`TransactionResponse`](/sdk/content/type-aliases/TransactionResponse) | The other transaction to compare against. |

#### Returns

[`OrphanFilter`](/sdk/content/type-aliases/OrphanFilter)

The orphan filter.

#### Source

[providers/provider.ts:2201](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2201)

***

### replaceableTransaction()

```ts theme={null}
replaceableTransaction(startBlock): QuaiTransactionResponse
```

Returns a new TransactionResponse instance which has the ability to detect (and throw an error) if the
transaction is replaced, which will begin scanning at `startBlock`.

This should generally not be used by developers and is intended primarily for internal use. Setting an incorrect
`startBlock` can have devastating performance consequences if used incorrectly.

#### Parameters

| Parameter    | Type     | Description                                          |
| :----------- | :------- | :--------------------------------------------------- |
| `startBlock` | `number` | The block number to start scanning for replacements. |

#### Returns

[`QuaiTransactionResponse`](/sdk/content/classes/QuaiTransactionResponse)

The replaceable transaction.

#### Source

[providers/provider.ts:2223](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2223)

***

### toJSON()

```ts theme={null}
toJSON(): any
```

Returns a JSON-compatible representation of this transaction.

#### Returns

`any`

#### Source

[providers/provider.ts:1850](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1850)

***

### wait()

```ts theme={null}
wait(_confirms?, _timeout?): Promise<null | TransactionReceipt>
```

Resolves once this transaction has been mined and has `confirms` blocks including it (default: `1`) with an
optional `timeout`.

This can resolve to `null` only if `confirms` is `0` and the transaction has not been mined, otherwise this will
wait until enough confirmations have completed.

#### Parameters

| Parameter    | Type     | Description                                          |
| :----------- | :------- | :--------------------------------------------------- |
| `_confirms`? | `number` | The number of confirmations to wait for.             |
| `_timeout`?  | `number` | The number of milliseconds to wait before rejecting. |

#### Returns

`Promise`\<`null` | [`TransactionReceipt`](/sdk/content/classes/TransactionReceipt)>

A promise resolving to the transaction receipt.

#### Throws

If the transaction was replaced, repriced, or cancelled.

#### Source

[providers/provider.ts:1953](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1953)


# SocketBlockSubscriber
Source: https://docs.qu.ai/sdk/content/classes/SocketBlockSubscriber



A **SocketBlockSubscriber** listens for `newHeads` events and emits `"block"` events.

## Extends

* [`SocketSubscriber`](/sdk/content/classes/SocketSubscriber)

## Accessors

### filter

```ts theme={null}
get filter(): any[]
```

The filter.

#### Returns

`any`\[]

#### Source

[providers/provider-socket.ts:46](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-socket.ts#L46)

## Methods

### pause()

```ts theme={null}
pause(dropWhilePaused?): void
```

Pause the subscriber.

#### Parameters

| Parameter          | Type      | Description                        |
| :----------------- | :-------- | :--------------------------------- |
| `dropWhilePaused`? | `boolean` | Whether to drop logs while paused. |

#### Returns

`void`

#### Inherited from

[`SocketSubscriber`](/sdk/content/classes/SocketSubscriber).[`pause`](/sdk/content/classes/SocketSubscriber#pause)

#### Source

[providers/provider-socket.ts:98](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-socket.ts#L98)

***

### resume()

```ts theme={null}
resume(): void
```

Resume the subscriber.

#### Returns

`void`

#### Inherited from

[`SocketSubscriber`](/sdk/content/classes/SocketSubscriber).[`resume`](/sdk/content/classes/SocketSubscriber#resume)

#### Source

[providers/provider-socket.ts:111](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-socket.ts#L111)

***

### start()

```ts theme={null}
start(): void
```

Start the subscriber.

#### Returns

`void`

#### Inherited from

[`SocketSubscriber`](/sdk/content/classes/SocketSubscriber).[`start`](/sdk/content/classes/SocketSubscriber#start)

#### Source

[providers/provider-socket.ts:76](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-socket.ts#L76)

***

### stop()

```ts theme={null}
stop(): void
```

Stop the subscriber.

#### Returns

`void`

#### Inherited from

[`SocketSubscriber`](/sdk/content/classes/SocketSubscriber).[`stop`](/sdk/content/classes/SocketSubscriber#stop)

#### Source

[providers/provider-socket.ts:86](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-socket.ts#L86)


# SocketEventSubscriber
Source: https://docs.qu.ai/sdk/content/classes/SocketEventSubscriber



A **SocketEventSubscriber** listens for event logs.

## Extends

* [`SocketSubscriber`](/sdk/content/classes/SocketSubscriber)

## Accessors

### filter

```ts theme={null}
get filter(): any[]
```

The filter.

#### Returns

`any`\[]

#### Source

[providers/provider-socket.ts:46](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-socket.ts#L46)

***

### logFilter

```ts theme={null}
get logFilter(): EventFilter
```

The filter.

#### Returns

[`EventFilter`](/sdk/content/interfaces/EventFilter)

#### Source

[providers/provider-socket.ts:267](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-socket.ts#L267)

## Methods

### pause()

```ts theme={null}
pause(dropWhilePaused?): void
```

Pause the subscriber.

#### Parameters

| Parameter          | Type      | Description                        |
| :----------------- | :-------- | :--------------------------------- |
| `dropWhilePaused`? | `boolean` | Whether to drop logs while paused. |

#### Returns

`void`

#### Inherited from

[`SocketSubscriber`](/sdk/content/classes/SocketSubscriber).[`pause`](/sdk/content/classes/SocketSubscriber#pause)

#### Source

[providers/provider-socket.ts:98](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-socket.ts#L98)

***

### resume()

```ts theme={null}
resume(): void
```

Resume the subscriber.

#### Returns

`void`

#### Inherited from

[`SocketSubscriber`](/sdk/content/classes/SocketSubscriber).[`resume`](/sdk/content/classes/SocketSubscriber#resume)

#### Source

[providers/provider-socket.ts:111](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-socket.ts#L111)

***

### start()

```ts theme={null}
start(): void
```

Start the subscriber.

#### Returns

`void`

#### Inherited from

[`SocketSubscriber`](/sdk/content/classes/SocketSubscriber).[`start`](/sdk/content/classes/SocketSubscriber#start)

#### Source

[providers/provider-socket.ts:76](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-socket.ts#L76)

***

### stop()

```ts theme={null}
stop(): void
```

Stop the subscriber.

#### Returns

`void`

#### Inherited from

[`SocketSubscriber`](/sdk/content/classes/SocketSubscriber).[`stop`](/sdk/content/classes/SocketSubscriber#stop)

#### Source

[providers/provider-socket.ts:86](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-socket.ts#L86)


# SocketPendingSubscriber
Source: https://docs.qu.ai/sdk/content/classes/SocketPendingSubscriber



A **SocketPendingSubscriber** listens for pending transactions and emits `"pending"` events.

## Extends

* [`SocketSubscriber`](/sdk/content/classes/SocketSubscriber)

## Accessors

### filter

```ts theme={null}
get filter(): any[]
```

The filter.

#### Returns

`any`\[]

#### Source

[providers/provider-socket.ts:46](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-socket.ts#L46)

## Methods

### pause()

```ts theme={null}
pause(dropWhilePaused?): void
```

Pause the subscriber.

#### Parameters

| Parameter          | Type      | Description                        |
| :----------------- | :-------- | :--------------------------------- |
| `dropWhilePaused`? | `boolean` | Whether to drop logs while paused. |

#### Returns

`void`

#### Inherited from

[`SocketSubscriber`](/sdk/content/classes/SocketSubscriber).[`pause`](/sdk/content/classes/SocketSubscriber#pause)

#### Source

[providers/provider-socket.ts:98](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-socket.ts#L98)

***

### resume()

```ts theme={null}
resume(): void
```

Resume the subscriber.

#### Returns

`void`

#### Inherited from

[`SocketSubscriber`](/sdk/content/classes/SocketSubscriber).[`resume`](/sdk/content/classes/SocketSubscriber#resume)

#### Source

[providers/provider-socket.ts:111](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-socket.ts#L111)

***

### start()

```ts theme={null}
start(): void
```

Start the subscriber.

#### Returns

`void`

#### Inherited from

[`SocketSubscriber`](/sdk/content/classes/SocketSubscriber).[`start`](/sdk/content/classes/SocketSubscriber#start)

#### Source

[providers/provider-socket.ts:76](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-socket.ts#L76)

***

### stop()

```ts theme={null}
stop(): void
```

Stop the subscriber.

#### Returns

`void`

#### Inherited from

[`SocketSubscriber`](/sdk/content/classes/SocketSubscriber).[`stop`](/sdk/content/classes/SocketSubscriber#stop)

#### Source

[providers/provider-socket.ts:86](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-socket.ts#L86)


# SocketProvider
Source: https://docs.qu.ai/sdk/content/classes/SocketProvider



A **SocketProvider** is backed by a long-lived connection over a socket, which can subscribe and receive real-time
messages over its communication channel.

## Extends

* [`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider)\<[`WebSocketLike`](/sdk/content/interfaces/WebSocketLike)>

## Extended by

* [`WebSocketProvider`](/sdk/content/classes/WebSocketProvider)

## Constructors

### new SocketProvider()

```ts theme={null}
new SocketProvider(network?, _options?): SocketProvider
```

Creates a new **SocketProvider** connected to `network`.

If unspecified, the network will be discovered.

#### Parameters

| Parameter   | Type                                                                               | Description                   |
| :---------- | :--------------------------------------------------------------------------------- | :---------------------------- |
| `network`?  | [`Networkish`](/sdk/content/type-aliases/Networkish)                               | The network to connect to.    |
| `_options`? | [`JsonRpcApiProviderOptions`](/sdk/content/type-aliases/JsonRpcApiProviderOptions) | The options for the provider. |

#### Returns

[`SocketProvider`](/sdk/content/classes/SocketProvider)

#### Overrides

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`constructor`](/sdk/content/classes/JsonRpcApiProvider#constructors)

#### Source

[providers/provider-socket.ts:320](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-socket.ts#L320)

## Accessors

### connect

```ts theme={null}
get connect(): FetchRequest[]
```

Get the list of connected FetchRequests.

#### Returns

[`FetchRequest`](/sdk/content/classes/FetchRequest)\[]

The list of connected FetchRequests.

#### Source

[providers/abstract-provider.ts:1026](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1026)

***

### destroyed

```ts theme={null}
get destroyed(): boolean
```

If this provider has been destroyed using the [**destroy**](/sdk/content/classes/AbstractProvider#destroy) method.

Once destroyed, all resources are reclaimed, internal event loops and timers are cleaned up and no further
requests may be sent to the provider.

#### Returns

`boolean`

#### Source

[providers/abstract-provider.ts:2545](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L2545)

***

### paused

```ts theme={null}
get paused(): boolean
```

Whether the provider is currently paused.

A paused provider will not emit any events, and generally should not make any requests to the network, but that
is up to sub-classes to manage.

Setting `paused = true` is identical to calling `.pause(false)`, which will buffer any events that occur while
paused until the provider is unpaused.

#### Returns

`boolean`

Whether the provider is paused.

#### Source

[providers/abstract-provider.ts:2577](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L2577)

***

### pollingInterval

```ts theme={null}
get pollingInterval(): number
```

Get the polling interval.

#### Returns

`number`

The polling interval.

#### Source

[providers/abstract-provider.ts:1183](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1183)

***

### provider

```ts theme={null}
get provider(): this
```

Returns `this`, to allow an **AbstractProvider** to implement the [Contract Runner](../classes/ContractRunner)
interface.

#### Returns

`this`

The provider instance.

#### Source

[providers/abstract-provider.ts:1193](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1193)

***

### ready

```ts theme={null}
get ready(): boolean
```

Returns true only if the JsonRpcApiProvider.\_start | **\_start** has been called.

#### Returns

`boolean`

True if the provider is ready.

#### Source

[providers/provider-jsonrpc.ts:1117](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L1117)

## Methods

### \_clearTimeout()

```ts theme={null}
_clearTimeout(timerId): void
```

Clear a timer created using the AbstractProvider.\_setTimeout | **\_setTimeout** method.

#### Parameters

| Parameter | Type     | Description                   |
| :-------- | :------- | :---------------------------- |
| `timerId` | `number` | The ID of the timer to clear. |

#### Returns

`void`

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`_clearTimeout`](/sdk/content/classes/JsonRpcApiProvider#_cleartimeout)

#### Source

[providers/abstract-provider.ts:2221](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L2221)

***

### destroy()

```ts theme={null}
destroy(): void
```

Destroys the provider, stopping all processing and canceling all pending requests.

#### Returns

`void`

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`destroy`](/sdk/content/classes/JsonRpcApiProvider#destroy)

#### Source

[providers/provider-jsonrpc.ts:1587](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L1587)

***

### getActiveRegions()

```ts theme={null}
getActiveRegions(): Promise<Shard[]>
```

Get the active region shards based on the protocol expansion number.

#### Returns

`Promise`\<[`Shard`](/sdk/content/enumerations/Shard)\[]>

A promise that resolves to the active shards.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`getActiveRegions`](/sdk/content/classes/JsonRpcApiProvider#getactiveregions)

#### Source

[providers/abstract-provider.ts:1110](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1110)

***

### getActiveZones()

```ts theme={null}
getActiveZones(): Promise<Zone[]>
```

Get the active zones for a shard based on the protocol expansion number.

#### Returns

`Promise`\<[`Zone`](/sdk/content/enumerations/Zone)\[]>

A promise that resolves to the active zones.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`getActiveZones`](/sdk/content/classes/JsonRpcApiProvider#getactivezones)

#### Source

[providers/abstract-provider.ts:1127](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1127)

***

### getLatestQiToQuaiRate()

```ts theme={null}
getLatestQiToQuaiRate(zone, amt?): Promise<bigint>
```

Get the latest Qi rate for a zone.

#### Parameters

| Parameter | Type                                     | Description                                    |
| :-------- | :--------------------------------------- | :--------------------------------------------- |
| `zone`    | [`Zone`](/sdk/content/enumerations/Zone) | The zone to get the rate for.                  |
| `amt`?    | `bigint`                                 | The amount to get the rate for. Default is `1` |

#### Returns

`Promise`\<`bigint`>

A promise that resolves to the latest Qi rate.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`getLatestQiToQuaiRate`](/sdk/content/classes/JsonRpcApiProvider#getlatestqitoquairate)

#### Source

[providers/abstract-provider.ts:1149](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1149)

***

### getLatestQuaiToQiRate()

```ts theme={null}
getLatestQuaiToQiRate(zone, amt?): Promise<bigint>
```

Get the latest Quai rate for a zone.

#### Parameters

| Parameter | Type                                     | Description                                             |
| :-------- | :--------------------------------------- | :------------------------------------------------------ |
| `zone`    | [`Zone`](/sdk/content/enumerations/Zone) | The zone to get the rate for.                           |
| `amt`?    | `bigint`                                 | The amount in quais to get the rate for. Default is `1` |

#### Returns

`Promise`\<`bigint`>

A promise that resolves to the latest Quai -> Qi rate for the given amount.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`getLatestQuaiToQiRate`](/sdk/content/classes/JsonRpcApiProvider#getlatestquaitoqirate)

#### Source

[providers/abstract-provider.ts:1068](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1068)

***

### getProtocolExpansionNumber()

```ts theme={null}
getProtocolExpansionNumber(): Promise<number>
```

Get the protocol expansion number.

#### Returns

`Promise`\<`number`>

A promise that resolves to the protocol expansion number.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`getProtocolExpansionNumber`](/sdk/content/classes/JsonRpcApiProvider#getprotocolexpansionnumber)

#### Source

[providers/abstract-provider.ts:1101](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1101)

***

### getQiToQuaiRateAtBlock()

```ts theme={null}
getQiToQuaiRateAtBlock(
   zone, 
   blockTag, 
amt?): Promise<bigint>
```

Get the Qi rate at a specific block.

#### Parameters

| Parameter  | Type                                             | Description                                    |
| :--------- | :----------------------------------------------- | :--------------------------------------------- |
| `zone`     | [`Zone`](/sdk/content/enumerations/Zone)         | The zone to get the rate for.                  |
| `blockTag` | [`BlockTag`](/sdk/content/type-aliases/BlockTag) | The block tag to get the rate at.              |
| `amt`?     | `bigint`                                         | The amount to get the rate for. Default is `1` |

#### Returns

`Promise`\<`bigint`>

A promise that resolves to the Qi rate at the specified block.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`getQiToQuaiRateAtBlock`](/sdk/content/classes/JsonRpcApiProvider#getqitoquairateatblock)

#### Source

[providers/abstract-provider.ts:1162](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1162)

***

### getQuaiToQiRateAtBlock()

```ts theme={null}
getQuaiToQiRateAtBlock(
   zone, 
   blockTag, 
amt?): Promise<bigint>
```

Get the Quai rate at a specific block.

#### Parameters

| Parameter  | Type                                             | Description                                    |
| :--------- | :----------------------------------------------- | :--------------------------------------------- |
| `zone`     | [`Zone`](/sdk/content/enumerations/Zone)         | The zone to get the rate for.                  |
| `blockTag` | [`BlockTag`](/sdk/content/type-aliases/BlockTag) | The block tag to get the rate at.              |
| `amt`?     | `bigint`                                         | The amount to get the rate for. Default is `1` |

#### Returns

`Promise`\<`bigint`>

A promise that resolves to the Quai rate at the specified block.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`getQuaiToQiRateAtBlock`](/sdk/content/classes/JsonRpcApiProvider#getquaitoqirateatblock)

#### Source

[providers/abstract-provider.ts:1081](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1081)

***

### getSigner()

```ts theme={null}
getSigner(address?): Promise<JsonRpcSigner>
```

Returns a JsonRpcSigner for the given address.

#### Parameters

| Parameter  | Type                 | Description                          |
| :--------- | :------------------- | :----------------------------------- |
| `address`? | `string` \| `number` | The address or index of the account. |

#### Returns

`Promise`\<[`JsonRpcSigner`](/sdk/content/classes/JsonRpcSigner)>

A promise that resolves to the JsonRpcSigner.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`getSigner`](/sdk/content/classes/JsonRpcApiProvider#getsigner)

#### Throws

If the account is invalid.

#### Source

[providers/provider-jsonrpc.ts:1542](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L1542)

***

### initialize()

```ts theme={null}
initialize<U>(urls): Promise<void>
```

Initialize the URL map with the provided URLs.

#### Type parameters

| Type parameter | Value                                                              |
| :------------- | :----------------------------------------------------------------- |
| `U`            | `string`\[] \| [`FetchRequest`](/sdk/content/classes/FetchRequest) |

#### Parameters

| Parameter | Type | Description                          |
| :-------- | :--- | :----------------------------------- |
| `urls`    | `U`  | The URLs to initialize the map with. |

#### Returns

`Promise`\<`void`>

A promise that resolves when the map is initialized.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`initialize`](/sdk/content/classes/JsonRpcApiProvider#initialize)

#### Source

[providers/abstract-provider.ts:874](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L874)

***

### listAccounts()

```ts theme={null}
listAccounts(): Promise<JsonRpcSigner[]>
```

Returns a list of JsonRpcSigners for all accounts.

#### Returns

`Promise`\<[`JsonRpcSigner`](/sdk/content/classes/JsonRpcSigner)\[]>

A promise that resolves to an array of JsonRpcSigners.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`listAccounts`](/sdk/content/classes/JsonRpcApiProvider#listaccounts)

#### Source

[providers/provider-jsonrpc.ts:1579](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L1579)

***

### pause()

```ts theme={null}
pause(dropWhilePaused?): void
```

Pause the provider. If `dropWhilePaused`, any events that occur while paused are dropped, otherwise all events
will be emitted once the provider is unpaused.

#### Parameters

| Parameter          | Type      | Description                          |
| :----------------- | :-------- | :----------------------------------- |
| `dropWhilePaused`? | `boolean` | Whether to drop events while paused. |

#### Returns

`void`

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`pause`](/sdk/content/classes/JsonRpcApiProvider#pause)

#### Source

[providers/abstract-provider.ts:2598](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L2598)

***

### resume()

```ts theme={null}
resume(): void
```

Resume the provider.

#### Returns

`void`

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`resume`](/sdk/content/classes/JsonRpcApiProvider#resume)

#### Source

[providers/abstract-provider.ts:2627](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L2627)

***

### send()

```ts theme={null}
send(
   method, 
   params, 
   shard?, 
now?): Promise<any>
```

Requests the `method` with `params` via the JSON-RPC protocol over the underlying channel. This can be used to
call methods on the backend that do not have a high-level API within the Provider API.

This method queues requests according to the batch constraints in the options, assigns the request a unique ID.

**Do NOT override** this method in sub-classes; instead override JsonRpcApiProvider.\_send | **\_send** or
force the options values in the call to the constructor to modify this method's behavior.

#### Parameters

| Parameter | Type                                       | Description                                    |
| :-------- | :----------------------------------------- | :--------------------------------------------- |
| `method`  | `string`                                   | The method to call.                            |
| `params`  | `any`\[] \| `Record`\<`string`, `any`>     | The parameters to pass to the method.          |
| `shard`?  | [`Shard`](/sdk/content/enumerations/Shard) | The shard to send the request to.              |
| `now`?    | `boolean`                                  | If true, the request will be sent immediately. |

#### Returns

`Promise`\<`any`>

A promise that resolves to the result of the method call.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`send`](/sdk/content/classes/JsonRpcApiProvider#send)

#### Source

[providers/provider-jsonrpc.ts:1500](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L1500)

***

### shardFromHash()

```ts theme={null}
shardFromHash(hash): Shard
```

Get the shard from a hash.

#### Parameters

| Parameter | Type     | Description                     |
| :-------- | :------- | :------------------------------ |
| `hash`    | `string` | The hash to get the shard from. |

#### Returns

[`Shard`](/sdk/content/enumerations/Shard)

The shard.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`shardFromHash`](/sdk/content/classes/JsonRpcApiProvider#shardfromhash)

#### Source

[providers/abstract-provider.ts:1047](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1047)

***

### zoneFromAddress()

```ts theme={null}
zoneFromAddress(_address): Promise<Zone>
```

Get the zone from an address.

#### Parameters

| Parameter  | Type                                                   | Description                       |
| :--------- | :----------------------------------------------------- | :-------------------------------- |
| `_address` | [`AddressLike`](/sdk/content/type-aliases/AddressLike) | The address to get the zone from. |

#### Returns

`Promise`\<[`Zone`](/sdk/content/enumerations/Zone)>

A promise that resolves to the zone.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`zoneFromAddress`](/sdk/content/classes/JsonRpcApiProvider#zonefromaddress)

#### Source

[providers/abstract-provider.ts:1036](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1036)

***

### zoneFromHash()

```ts theme={null}
zoneFromHash(hash): Zone
```

Get the zone from a hash.

#### Parameters

| Parameter | Type     | Description                    |
| :-------- | :------- | :----------------------------- |
| `hash`    | `string` | The hash to get the zone from. |

#### Returns

[`Zone`](/sdk/content/enumerations/Zone)

The zone.

#### Inherited from

[`JsonRpcApiProvider`](/sdk/content/classes/JsonRpcApiProvider).[`zoneFromHash`](/sdk/content/classes/JsonRpcApiProvider#zonefromhash)

#### Source

[providers/abstract-provider.ts:1057](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1057)


# SocketSubscriber
Source: https://docs.qu.ai/sdk/content/classes/SocketSubscriber



A **SocketSubscriber** uses a socket transport to handle events and should use
[**\_emit**](/sdk/content/classes/SocketSubscriber#_emit) to manage the events.

* A sub-class MUST call the `_start()` method once connected
* A sub-class MUST override the `_write(string)` method
* A sub-class MUST call `_processMessage(string)` for each message

## Extended by

* [`SocketBlockSubscriber`](/sdk/content/classes/SocketBlockSubscriber)
* [`SocketEventSubscriber`](/sdk/content/classes/SocketEventSubscriber)
* [`SocketPendingSubscriber`](/sdk/content/classes/SocketPendingSubscriber)

## Implements

* [`Subscriber`](/sdk/content/interfaces/Subscriber)

## Constructors

### new SocketSubscriber()

```ts theme={null}
new SocketSubscriber(
   provider, 
   filter, 
   zone): SocketSubscriber
```

Creates a new **SocketSubscriber** attached to `provider` listening to `filter`.

#### Parameters

| Parameter  | Type                                                    | Description          |
| :--------- | :------------------------------------------------------ | :------------------- |
| `provider` | [`SocketProvider`](/sdk/content/classes/SocketProvider) | The socket provider. |
| `filter`   | `any`\[]                                                | The filter.          |
| `zone`     | [`Zone`](/sdk/content/enumerations/Zone)                | -                    |

#### Returns

[`SocketSubscriber`](/sdk/content/classes/SocketSubscriber)

#### Source

[providers/provider-socket.ts:63](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-socket.ts#L63)

## Accessors

### filter

```ts theme={null}
get filter(): any[]
```

The filter.

#### Returns

`any`\[]

#### Source

[providers/provider-socket.ts:46](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-socket.ts#L46)

## Methods

### \_emit()

```ts theme={null}
_emit(provider, message): Promise<void>
```

Sub-classes **must** override this to emit the events on the provider.

#### Parameters

| Parameter  | Type                                                    | Description          |
| :--------- | :------------------------------------------------------ | :------------------- |
| `provider` | [`SocketProvider`](/sdk/content/classes/SocketProvider) | The socket provider. |
| `message`  | `any`                                                   | The message to emit. |

#### Returns

`Promise`\<`void`>

#### Abstract

#### Source

[providers/provider-socket.ts:151](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-socket.ts#L151)

***

### pause()

```ts theme={null}
pause(dropWhilePaused?): void
```

Pause the subscriber.

#### Parameters

| Parameter          | Type      | Description                        |
| :----------------- | :-------- | :--------------------------------- |
| `dropWhilePaused`? | `boolean` | Whether to drop logs while paused. |

#### Returns

`void`

#### Implementation of

[`Subscriber`](/sdk/content/interfaces/Subscriber).[`pause`](/sdk/content/interfaces/Subscriber#pause)

#### Source

[providers/provider-socket.ts:98](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-socket.ts#L98)

***

### resume()

```ts theme={null}
resume(): void
```

Resume the subscriber.

#### Returns

`void`

#### Implementation of

[`Subscriber`](/sdk/content/interfaces/Subscriber).[`resume`](/sdk/content/interfaces/Subscriber#resume)

#### Source

[providers/provider-socket.ts:111](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-socket.ts#L111)

***

### start()

```ts theme={null}
start(): void
```

Start the subscriber.

#### Returns

`void`

#### Implementation of

[`Subscriber`](/sdk/content/interfaces/Subscriber).[`start`](/sdk/content/interfaces/Subscriber#start)

#### Source

[providers/provider-socket.ts:76](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-socket.ts#L76)

***

### stop()

```ts theme={null}
stop(): void
```

Stop the subscriber.

#### Returns

`void`

#### Implementation of

[`Subscriber`](/sdk/content/interfaces/Subscriber).[`stop`](/sdk/content/interfaces/Subscriber#stop)

#### Source

[providers/provider-socket.ts:86](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-socket.ts#L86)


# TransactionReceipt
Source: https://docs.qu.ai/sdk/content/classes/TransactionReceipt



A **TransactionReceipt** includes additional information about a transaction that is only available after it has been
mined.

## Extended by

* [`ContractTransactionReceipt`](/sdk/content/classes/ContractTransactionReceipt)

## Implements

* [`TransactionReceiptParams`](/sdk/content/interfaces/TransactionReceiptParams)
* `Iterable`\<[`Log`](/sdk/content/classes/Log)>

## Properties

| Property            | Modifier   | Type                                           | Description                                                                                                                                                                                                                                                                    |
| :------------------ | :--------- | :--------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `#logs`             | `private`  | readonly [`Log`](/sdk/content/classes/Log)\[]  | The root hash of this transaction.<br /><br />This is no present and was only included in pre-byzantium blocks, but could be used to validate certain parts of<br />the receipt.                                                                                               |
| `blockHash`         | `readonly` | `string`                                       | The block hash of the [**Block**](/sdk/content/classes/Block) this transaction was included in.                                                                                                                                                                                |
| `blockNumber`       | `readonly` | `number`                                       | The block number of the [**Block**](/sdk/content/classes/Block) this transaction was included in.                                                                                                                                                                              |
| `contractAddress`   | `readonly` | `null` \| `string`                             | The address of the contract if the transaction was directly responsible for deploying one.<br /><br />This is non-null **only** if the `to` is empty and the `data` was successfully executed as initcode.                                                                     |
| `cumulativeGasUsed` | `readonly` | `bigint`                                       | The amount of gas used by all transactions within the block for this and all transactions with a lower `index`.<br /><br />This is generally not useful for developers but can be used to validate certain aspects of execution.                                               |
| `from`              | `readonly` | `string`                                       | The sender of the transaction.                                                                                                                                                                                                                                                 |
| `gasPrice`          | `readonly` | `bigint`                                       | The actual gas price used during execution.<br /><br />Due to the complexity of [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559) this value can only be caluclated<br />after the transaction has been mined, snce the base fee is protocol-enforced.                       |
| `gasUsed`           | `readonly` | `bigint`                                       | The actual amount of gas used by this transaction.<br /><br />When creating a transaction, the amount of gas that will be used can only be approximated, but the sender must<br />pay the gas fee for the entire gas limit. After the transaction, the difference is refunded. |
| `hash`              | `readonly` | `string`                                       | The transaction hash.                                                                                                                                                                                                                                                          |
| `index`             | `readonly` | `number`                                       | The index of this transaction within the block transactions.                                                                                                                                                                                                                   |
| `logsBloom`         | `readonly` | `string`                                       | The bloom filter bytes that represent all logs that occurred within this transaction. This is generally not<br />useful for most developers, but can be used to validate the included logs.                                                                                    |
| `provider`          | `readonly` | [`Provider`](/sdk/content/interfaces/Provider) | The provider connected to the log used to fetch additional details if necessary.                                                                                                                                                                                               |
| `status`            | `readonly` | `null` \| `number`                             | The status of this transaction, indicating success (i.e. `1`) or a revert (i.e. `0`).<br /><br />This is available in post-byzantium blocks, but some backends may backfill this value.                                                                                        |
| `to`                | `readonly` | `null` \| `string`                             | The address the transaction was sent to.                                                                                                                                                                                                                                       |
| `type`              | `readonly` | `number`                                       | The [EIP-2718](https://eips.ethereum.org/EIPS/eip-2718) transaction type.                                                                                                                                                                                                      |

## Accessors

### fee

```ts theme={null}
get fee(): bigint
```

The total fee for this transaction, in wei.

#### Returns

`bigint`

#### Source

[providers/provider.ts:1375](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1375)

***

### logs

```ts theme={null}
get logs(): readonly Log[]
```

The logs for this transaction.

#### Returns

readonly [`Log`](/sdk/content/classes/Log)\[]

#### Source

[providers/provider.ts:1312](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1312)

## Methods

### confirmations()

```ts theme={null}
confirmations(): Promise<number>
```

Resolves to the number of confirmations this transaction has.

#### Returns

`Promise`\<`number`>

A promise resolving to the number of confirmations.

#### Throws

If the block is not found.

#### Source

[providers/provider.ts:1426](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1426)

***

### getBlock()

```ts theme={null}
getBlock(shard): Promise<Block>
```

Resolves to the block this transaction occurred in.

#### Parameters

| Parameter | Type                                       | Description                        |
| :-------- | :----------------------------------------- | :--------------------------------- |
| `shard`   | [`Shard`](/sdk/content/enumerations/Shard) | The shard to fetch the block from. |

#### Returns

`Promise`\<[`Block`](/sdk/content/classes/Block)>

A promise resolving to the block.

#### Throws

If the block is not found.

#### Source

[providers/provider.ts:1386](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1386)

***

### getResult()

```ts theme={null}
getResult(): Promise<string>
```

Resolves to the return value of the execution of this transaction.

Support for this feature is limited, as it requires an archive node with the `debug_` or `trace_` API enabled.

#### Returns

`Promise`\<`string`>

A promise resolving to the return value of the transaction.

#### Throws

If the transaction is not found.

#### Source

[providers/provider.ts:1416](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1416)

***

### getTransaction()

```ts theme={null}
getTransaction(): Promise<TransactionResponse | ExternalTransactionResponse>
```

Resolves to the transaction this transaction occurred in.

#### Returns

`Promise`\<[`TransactionResponse`](/sdk/content/type-aliases/TransactionResponse) | `ExternalTransactionResponse`>

A promise resolving to the transaction.

#### Throws

If the transaction is not found.

#### Source

[providers/provider.ts:1400](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1400)

***

### toJSON()

```ts theme={null}
toJSON(): any
```

Returns a JSON-compatible representation.

#### Returns

`any`

#### Source

[providers/provider.ts:1319](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1319)


# TypedDataEncoder
Source: https://docs.qu.ai/sdk/content/classes/TypedDataEncoder



A **TypedDataEncode** prepares and encodes [EIP-712](https://eips.ethereum.org/EIPS/eip-712) payloads for signed
typed data.

This is useful for those that wish to compute various components of a typed data hash, primary types, or
sub-components, but generally the higher level [`Signer.signTypedData`](../classes/Signer#signTypedData) is more
useful.

## Constructors

### new TypedDataEncoder()

```ts theme={null}
new TypedDataEncoder(types): TypedDataEncoder
```

Create a new **TypedDataEncoder** for `types`.

This performs all necessary checking that types are valid and do not violate the
[EIP-712](https://eips.ethereum.org/EIPS/eip-712) structural constraints as well as computes the
[**primaryType**](/sdk/content/classes/TypedDataEncoder).

#### Parameters

| Parameter | Type                                                                               |
| :-------- | :--------------------------------------------------------------------------------- |
| `types`   | `Record`\<`string`, [`TypedDataField`](/sdk/content/interfaces/TypedDataField)\[]> |

#### Returns

[`TypedDataEncoder`](/sdk/content/classes/TypedDataEncoder)

#### Source

[hash/typed-data.ts:259](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/hash/typed-data.ts#L259)

## Properties

| Property      | Modifier   | Type     | Description                                                                                                                                                                                                                                                                                                                                                                 |
| :------------ | :--------- | :------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `primaryType` | `readonly` | `string` | The primary type for the structured [**types**](/sdk/content/classes/TypedDataEncoder#types).<br /><br />This is derived automatically from the [**types**](/sdk/content/classes/TypedDataEncoder#types), since no recursion is possible, once the DAG for<br />the types is consturcted internally, the primary type must be the only remaining type with no parent nodes. |

## Accessors

### types

```ts theme={null}
get types(): Record<string, TypedDataField[]>
```

The types.

#### Returns

`Record`\<`string`, [`TypedDataField`](/sdk/content/interfaces/TypedDataField)\[]>

#### Source

[hash/typed-data.ts:244](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/hash/typed-data.ts#L244)

## Methods

### encode()

```ts theme={null}
encode(value): string
```

Return the fulled encoded `value` for the [**types**](/sdk/content/classes/TypedDataEncoder#types).

#### Parameters

| Parameter | Type                       | Description          |
| :-------- | :------------------------- | :------------------- |
| `value`   | `Record`\<`string`, `any`> | The value to encode. |

#### Returns

`string`

The encoded value.

#### Source

[hash/typed-data.ts:465](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/hash/typed-data.ts#L465)

***

### encodeData()

```ts theme={null}
encodeData(type, value): string
```

Return the encoded `value` for the `type`.

#### Parameters

| Parameter | Type     | Description                       |
| :-------- | :------- | :-------------------------------- |
| `type`    | `string` | The type to encode the value for. |
| `value`   | `any`    | The value to encode.              |

#### Returns

`string`

The encoded value.

#### Source

[hash/typed-data.ts:444](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/hash/typed-data.ts#L444)

***

### encodeType()

```ts theme={null}
encodeType(name): string
```

Return the full type for `name`.

#### Parameters

| Parameter | Type     | Description                        |
| :-------- | :------- | :--------------------------------- |
| `name`    | `string` | The name to get the full type for. |

#### Returns

`string`

The full type.

#### Source

[hash/typed-data.ts:431](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/hash/typed-data.ts#L431)

***

### getEncoder()

```ts theme={null}
getEncoder(type): (value) => string
```

Returnthe encoder for the specific `type`.

#### Parameters

| Parameter | Type     | Description                      |
| :-------- | :------- | :------------------------------- |
| `type`    | `string` | The type to get the encoder for. |

#### Returns

`Function`

The encoder for the type.

##### Parameters

| Parameter | Type  |
| :-------- | :---- |
| `value`   | `any` |

##### Returns

`string`

#### Source

[hash/typed-data.ts:365](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/hash/typed-data.ts#L365)

***

### hash()

```ts theme={null}
hash(value): string
```

Return the hash of the fully encoded `value` for the [**types**](/sdk/content/classes/TypedDataEncoder#types).

#### Parameters

| Parameter | Type                       | Description        |
| :-------- | :------------------------- | :----------------- |
| `value`   | `Record`\<`string`, `any`> | The value to hash. |

#### Returns

`string`

The hash of the value.

#### Source

[hash/typed-data.ts:475](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/hash/typed-data.ts#L475)

***

### hashStruct()

```ts theme={null}
hashStruct(name, value): string
```

Returns the hash of `value` for the type of `name`.

#### Parameters

| Parameter | Type                       | Description           |
| :-------- | :------------------------- | :-------------------- |
| `name`    | `string`                   | The name of the type. |
| `value`   | `Record`\<`string`, `any`> | The value to hash.    |

#### Returns

`string`

The hash of the value.

#### Source

[hash/typed-data.ts:455](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/hash/typed-data.ts#L455)

***

### visit()

```ts theme={null}
visit(value, callback): any
```

Call `calback` for each value in `value`, passing the type and component within `value`.

This is useful for replacing addresses or other transformation that may be desired on each component, based on
its type.

#### Parameters

| Parameter  | Type                       | Description                          |
| :--------- | :------------------------- | :----------------------------------- |
| `value`    | `Record`\<`string`, `any`> | The value to visit.                  |
| `callback` | (`type`, `data`) => `any`  | The callback to call for each value. |

#### Returns

`any`

The result of the callback.

#### Source

[hash/typed-data.ts:528](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/hash/typed-data.ts#L528)

***

### encode()

```ts theme={null}
static encode(
   domain, 
   types, 
   value): string
```

Return the fully encoded [EIP-712](https://eips.ethereum.org/EIPS/eip-712) `value` for `types` with `domain`.

#### Parameters

| Parameter | Type                                                                               | Description          |
| :-------- | :--------------------------------------------------------------------------------- | :------------------- |
| `domain`  | [`TypedDataDomain`](/sdk/content/interfaces/TypedDataDomain)                       | The domain to use.   |
| `types`   | `Record`\<`string`, [`TypedDataField`](/sdk/content/interfaces/TypedDataField)\[]> | The types to encode. |
| `value`   | `Record`\<`string`, `any`>                                                         | The value to encode. |

#### Returns

`string`

The encoded value.

#### Source

[hash/typed-data.ts:599](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/hash/typed-data.ts#L599)

***

### from()

```ts theme={null}
static from(types): TypedDataEncoder
```

Create a new **TypedDataEncoder** for `types`.

#### Parameters

| Parameter | Type                                                                               | Description          |
| :-------- | :--------------------------------------------------------------------------------- | :------------------- |
| `types`   | `Record`\<`string`, [`TypedDataField`](/sdk/content/interfaces/TypedDataField)\[]> | The types to encode. |

#### Returns

[`TypedDataEncoder`](/sdk/content/classes/TypedDataEncoder)

The encoder for the types.

#### Throws

If the types are invalid.

#### Source

[hash/typed-data.ts:539](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/hash/typed-data.ts#L539)

***

### getPayload()

```ts theme={null}
static getPayload(
   domain, 
   types, 
   value): any
```

Returns the JSON-encoded payload expected by nodes which implement the JSON-RPC
[EIP-712](https://eips.ethereum.org/EIPS/eip-712) method.

#### Parameters

| Parameter | Type                                                                               | Description          |
| :-------- | :--------------------------------------------------------------------------------- | :------------------- |
| `domain`  | [`TypedDataDomain`](/sdk/content/interfaces/TypedDataDomain)                       | The domain to use.   |
| `types`   | `Record`\<`string`, [`TypedDataField`](/sdk/content/interfaces/TypedDataField)\[]> | The types to encode. |
| `value`   | `Record`\<`string`, `any`>                                                         | The value to encode. |

#### Returns

`any`

The JSON-encoded payload.

#### Source

[hash/typed-data.ts:633](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/hash/typed-data.ts#L633)

***

### getPrimaryType()

```ts theme={null}
static getPrimaryType(types): string
```

Return the primary type for `types`.

#### Parameters

| Parameter | Type                                                                               | Description                            |
| :-------- | :--------------------------------------------------------------------------------- | :------------------------------------- |
| `types`   | `Record`\<`string`, [`TypedDataField`](/sdk/content/interfaces/TypedDataField)\[]> | The types to get the primary type for. |

#### Returns

`string`

The primary type.

#### Throws

If the types are invalid.

#### Source

[hash/typed-data.ts:550](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/hash/typed-data.ts#L550)

***

### hash()

```ts theme={null}
static hash(
   domain, 
   types, 
   value): string
```

Return the hash of the fully encoded [EIP-712](https://eips.ethereum.org/EIPS/eip-712) `value` for `types` with
`domain`.

#### Parameters

| Parameter | Type                                                                               | Description        |
| :-------- | :--------------------------------------------------------------------------------- | :----------------- |
| `domain`  | [`TypedDataDomain`](/sdk/content/interfaces/TypedDataDomain)                       | The domain to use. |
| `types`   | `Record`\<`string`, [`TypedDataField`](/sdk/content/interfaces/TypedDataField)\[]> | The types to hash. |
| `value`   | `Record`\<`string`, `any`>                                                         | The value to hash. |

#### Returns

`string`

The hash of the value.

#### Source

[hash/typed-data.ts:616](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/hash/typed-data.ts#L616)

***

### hashDomain()

```ts theme={null}
static hashDomain(domain): string
```

Return the domain hash for `domain`.

#### Parameters

| Parameter | Type                                                         | Description         |
| :-------- | :----------------------------------------------------------- | :------------------ |
| `domain`  | [`TypedDataDomain`](/sdk/content/interfaces/TypedDataDomain) | The domain to hash. |

#### Returns

`string`

The hash of the domain.

#### Throws

If the domain is invalid.

#### Source

[hash/typed-data.ts:573](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/hash/typed-data.ts#L573)

***

### hashStruct()

```ts theme={null}
static hashStruct(
   name, 
   types, 
   value): string
```

Return the hashed struct for `value` using `types` and `name`.

#### Parameters

| Parameter | Type                                                                               | Description           |
| :-------- | :--------------------------------------------------------------------------------- | :-------------------- |
| `name`    | `string`                                                                           | The name of the type. |
| `types`   | `Record`\<`string`, [`TypedDataField`](/sdk/content/interfaces/TypedDataField)\[]> | The types to hash.    |
| `value`   | `Record`\<`string`, `any`>                                                         | The value to hash.    |

#### Returns

`string`

The hash of the value.

#### Source

[hash/typed-data.ts:562](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/hash/typed-data.ts#L562)


# UTXO
Source: https://docs.qu.ai/sdk/content/classes/UTXO



Represents a UTXO (Unspent Transaction Output).

## Implements

## Implements

* `UTXOLike`

## Constructors

### new UTXO()

```ts theme={null}
new UTXO(): UTXO
```

Constructs a new UTXO instance with null properties.

#### Returns

[`UTXO`](/sdk/content/classes/UTXO)

#### Source

[transaction/utxo.ts:271](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/utxo.ts#L271)

## Accessors

### address

```ts theme={null}
get address(): string
```

Gets the address.

```ts theme={null}
set address(value): void
```

Sets the address.

#### Throws

If the address is invalid.

#### Parameters

| Parameter | Type     | Description  |
| :-------- | :------- | :----------- |
| `value`   | `string` | The address. |

#### Returns

`string`

The address.

#### Source

[transaction/utxo.ts:217](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/utxo.ts#L217)

***

### denomination

```ts theme={null}
get denomination(): null | number
```

Gets the denomination.

```ts theme={null}
set denomination(value): void
```

Sets the denomination.

#### Throws

If the denomination value is invalid.

#### Parameters

| Parameter | Type               | Description       |
| :-------- | :----------------- | :---------------- |
| `value`   | `null` \| `number` | The denomination. |

#### Returns

`null` | `number`

The denomination.

#### Source

[transaction/utxo.ts:237](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/utxo.ts#L237)

***

### index

```ts theme={null}
get index(): null | number
```

Gets the index.

```ts theme={null}
set index(value): void
```

Sets the index.

#### Parameters

| Parameter | Type               | Description |
| :-------- | :----------------- | :---------- |
| `value`   | `null` \| `number` | The index.  |

#### Returns

`null` | `number`

The index.

#### Source

[transaction/utxo.ts:199](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/utxo.ts#L199)

***

### txhash

```ts theme={null}
get txhash(): null | string
```

Gets the transaction hash.

```ts theme={null}
set txhash(value): void
```

Sets the transaction hash.

#### Parameters

| Parameter | Type               | Description           |
| :-------- | :----------------- | :-------------------- |
| `value`   | `null` \| `string` | The transaction hash. |

#### Returns

`null` | `string`

The transaction hash.

#### Source

[transaction/utxo.ts:181](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/utxo.ts#L181)

## Methods

### toJSON()

```ts theme={null}
toJSON(): any
```

Converts the UTXO instance to a JSON object.

#### Returns

`any`

A JSON representation of the UTXO instance.

#### Source

[transaction/utxo.ts:284](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/utxo.ts#L284)

***

### from()

```ts theme={null}
static from(utxo): UTXO
```

Creates a UTXO instance from a UTXOLike object.

#### Parameters

| Parameter | Type       | Description                     |
| :-------- | :--------- | :------------------------------ |
| `utxo`    | `UTXOLike` | The UTXOLike object to convert. |

#### Returns

[`UTXO`](/sdk/content/classes/UTXO)

The UTXO instance.

#### Source

[transaction/utxo.ts:299](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/utxo.ts#L299)


# UnmanagedSubscriber
Source: https://docs.qu.ai/sdk/content/classes/UnmanagedSubscriber



An **UnmanagedSubscriber** is useful for events which do not require any additional management, such as `"debug"`
which only requires emit in synchronous event loop triggered calls.

## Implements

* [`Subscriber`](/sdk/content/interfaces/Subscriber)

## Constructors

### new UnmanagedSubscriber()

```ts theme={null}
new UnmanagedSubscriber(name): UnmanagedSubscriber
```

Create a new UnmanagedSubscriber with `name`.

#### Parameters

| Parameter | Type     | Description            |
| :-------- | :------- | :--------------------- |
| `name`    | `string` | The name of the event. |

#### Returns

[`UnmanagedSubscriber`](/sdk/content/classes/UnmanagedSubscriber)

#### Source

[providers/abstract-provider.ts:265](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L265)

## Properties

| Property | Type     | Description            |
| :------- | :------- | :--------------------- |
| `name`   | `string` | The name of the event. |


# VoidSigner
Source: https://docs.qu.ai/sdk/content/classes/VoidSigner



A **VoidSigner** is a class deisgned to allow an address to be used in any API which accepts a Signer, but for which
there are no credentials available to perform any actual signing.

This for example allow impersonating an account for the purpose of static calls or estimating gas, but does not allow
sending transactions.

## Extends

* [`AbstractSigner`](/sdk/content/classes/AbstractSigner)

## Constructors

### new VoidSigner()

```ts theme={null}
new VoidSigner(address, provider?): VoidSigner
```

Creates a new **VoidSigner** with `address` attached to `provider`.

#### Parameters

| Parameter   | Type                                                     |
| :---------- | :------------------------------------------------------- |
| `address`   | `string`                                                 |
| `provider`? | `null` \| [`Provider`](/sdk/content/interfaces/Provider) |

#### Returns

[`VoidSigner`](/sdk/content/classes/VoidSigner)

#### Overrides

[`AbstractSigner`](/sdk/content/classes/AbstractSigner).[`constructor`](/sdk/content/classes/AbstractSigner#constructors)

#### Source

[signers/abstract-signer.ts:220](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/signers/abstract-signer.ts#L220)

## Properties

| Property   | Modifier   | Type                                                     | Description                               | Inherited from                                                     |
| :--------- | :--------- | :------------------------------------------------------- | :---------------------------------------- | :----------------------------------------------------------------- |
| `address`  | `readonly` | `string`                                                 | The signer address.                       | -                                                                  |
| `provider` | `readonly` | `null` \| [`Provider`](/sdk/content/interfaces/Provider) | The provider this signer is connected to. | [`AbstractSigner`](/sdk/content/classes/AbstractSigner).`provider` |


# WebSocketProvider
Source: https://docs.qu.ai/sdk/content/classes/WebSocketProvider



A JSON-RPC provider which is backed by a WebSocket.

WebSockets are often preferred because they retain a live connection to a server, which permits more instant access
to events.

However, this incurs higher server infrastructure costs, so additional resources may be required to host your own
WebSocket nodes and many third-party services charge additional fees for WebSocket endpoints.

## Extends

* [`SocketProvider`](/sdk/content/classes/SocketProvider)

## Constructors

### new WebSocketProvider()

```ts theme={null}
new WebSocketProvider(
   url, 
   network?, 
   options?): WebSocketProvider
```

Create a new WebSocketProvider.

#### Parameters

| Parameter  | Type                                                                                                                                                    | Description                                |
| :--------- | :------------------------------------------------------------------------------------------------------------------------------------------------------ | :----------------------------------------- |
| `url`      | `string` \| `string`\[] \| [`WebSocketLike`](/sdk/content/interfaces/WebSocketLike) \| [`WebSocketCreator`](/sdk/content/type-aliases/WebSocketCreator) | The URL(s) or WebSocket object or creator. |
| `network`? | [`Networkish`](/sdk/content/type-aliases/Networkish)                                                                                                    | The network to connect to.                 |
| `options`? | [`JsonRpcApiProviderOptions`](/sdk/content/type-aliases/JsonRpcApiProviderOptions)                                                                      | The options for the JSON-RPC API provider. |

#### Returns

[`WebSocketProvider`](/sdk/content/classes/WebSocketProvider)

#### Overrides

[`SocketProvider`](/sdk/content/classes/SocketProvider).[`constructor`](/sdk/content/classes/SocketProvider#constructors)

#### Source

[providers/provider-websocket.ts:94](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-websocket.ts#L94)

## Properties

| Property   | Type                                                          | Default value | Description                                 |
| :--------- | :------------------------------------------------------------ | :------------ | :------------------------------------------ |
| `readyMap` | `Map`\<[`Shard`](/sdk/content/enumerations/Shard), `boolean`> | `...`         | A map to track the readiness of each shard. |

## Accessors

### connect

```ts theme={null}
get connect(): FetchRequest[]
```

Get the list of connected FetchRequests.

#### Returns

[`FetchRequest`](/sdk/content/classes/FetchRequest)\[]

The list of connected FetchRequests.

#### Source

[providers/abstract-provider.ts:1026](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1026)

***

### destroyed

```ts theme={null}
get destroyed(): boolean
```

If this provider has been destroyed using the [**destroy**](/sdk/content/classes/AbstractProvider#destroy) method.

Once destroyed, all resources are reclaimed, internal event loops and timers are cleaned up and no further
requests may be sent to the provider.

#### Returns

`boolean`

#### Source

[providers/abstract-provider.ts:2545](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L2545)

***

### paused

```ts theme={null}
get paused(): boolean
```

Whether the provider is currently paused.

A paused provider will not emit any events, and generally should not make any requests to the network, but that
is up to sub-classes to manage.

Setting `paused = true` is identical to calling `.pause(false)`, which will buffer any events that occur while
paused until the provider is unpaused.

#### Returns

`boolean`

Whether the provider is paused.

#### Source

[providers/abstract-provider.ts:2577](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L2577)

***

### pollingInterval

```ts theme={null}
get pollingInterval(): number
```

Get the polling interval.

#### Returns

`number`

The polling interval.

#### Source

[providers/abstract-provider.ts:1183](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1183)

***

### provider

```ts theme={null}
get provider(): this
```

Returns `this`, to allow an **AbstractProvider** to implement the [Contract Runner](../classes/ContractRunner)
interface.

#### Returns

`this`

The provider instance.

#### Source

[providers/abstract-provider.ts:1193](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1193)

***

### ready

```ts theme={null}
get ready(): boolean
```

Returns true only if the JsonRpcApiProvider.\_start | **\_start** has been called.

#### Returns

`boolean`

True if the provider is ready.

#### Source

[providers/provider-jsonrpc.ts:1117](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L1117)

***

### websocket

```ts theme={null}
get websocket(): WebSocketLike[]
```

Get the array of WebSocketLike objects.

#### Throws

If the websocket is closed.

#### Returns

[`WebSocketLike`](/sdk/content/interfaces/WebSocketLike)\[]

The array of WebSocketLike objects.

#### Source

[providers/provider-websocket.ts:80](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-websocket.ts#L80)

## Methods

### \_clearTimeout()

```ts theme={null}
_clearTimeout(timerId): void
```

Clear a timer created using the AbstractProvider.\_setTimeout | **\_setTimeout** method.

#### Parameters

| Parameter | Type     | Description                   |
| :-------- | :------- | :---------------------------- |
| `timerId` | `number` | The ID of the timer to clear. |

#### Returns

`void`

#### Inherited from

[`SocketProvider`](/sdk/content/classes/SocketProvider).[`_clearTimeout`](/sdk/content/classes/SocketProvider#_cleartimeout)

#### Source

[providers/abstract-provider.ts:2221](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L2221)

***

### destroy()

```ts theme={null}
destroy(): Promise<void>
```

Destroy the WebSocket connections and clean up resources.

#### Returns

`Promise`\<`void`>

A promise that resolves when the WebSocket connections are closed.

#### Overrides

[`SocketProvider`](/sdk/content/classes/SocketProvider).[`destroy`](/sdk/content/classes/SocketProvider#destroy)

#### Source

[providers/provider-websocket.ts:399](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-websocket.ts#L399)

***

### getActiveRegions()

```ts theme={null}
getActiveRegions(): Promise<Shard[]>
```

Get the active region shards based on the protocol expansion number.

#### Returns

`Promise`\<[`Shard`](/sdk/content/enumerations/Shard)\[]>

A promise that resolves to the active shards.

#### Inherited from

[`SocketProvider`](/sdk/content/classes/SocketProvider).[`getActiveRegions`](/sdk/content/classes/SocketProvider#getactiveregions)

#### Source

[providers/abstract-provider.ts:1110](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1110)

***

### getActiveZones()

```ts theme={null}
getActiveZones(): Promise<Zone[]>
```

Get the active zones for a shard based on the protocol expansion number.

#### Returns

`Promise`\<[`Zone`](/sdk/content/enumerations/Zone)\[]>

A promise that resolves to the active zones.

#### Inherited from

[`SocketProvider`](/sdk/content/classes/SocketProvider).[`getActiveZones`](/sdk/content/classes/SocketProvider#getactivezones)

#### Source

[providers/abstract-provider.ts:1127](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1127)

***

### getLatestQiToQuaiRate()

```ts theme={null}
getLatestQiToQuaiRate(zone, amt?): Promise<bigint>
```

Get the latest Qi rate for a zone.

#### Parameters

| Parameter | Type                                     | Description                                    |
| :-------- | :--------------------------------------- | :--------------------------------------------- |
| `zone`    | [`Zone`](/sdk/content/enumerations/Zone) | The zone to get the rate for.                  |
| `amt`?    | `bigint`                                 | The amount to get the rate for. Default is `1` |

#### Returns

`Promise`\<`bigint`>

A promise that resolves to the latest Qi rate.

#### Inherited from

[`SocketProvider`](/sdk/content/classes/SocketProvider).[`getLatestQiToQuaiRate`](/sdk/content/classes/SocketProvider#getlatestqitoquairate)

#### Source

[providers/abstract-provider.ts:1149](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1149)

***

### getLatestQuaiToQiRate()

```ts theme={null}
getLatestQuaiToQiRate(zone, amt?): Promise<bigint>
```

Get the latest Quai rate for a zone.

#### Parameters

| Parameter | Type                                     | Description                                             |
| :-------- | :--------------------------------------- | :------------------------------------------------------ |
| `zone`    | [`Zone`](/sdk/content/enumerations/Zone) | The zone to get the rate for.                           |
| `amt`?    | `bigint`                                 | The amount in quais to get the rate for. Default is `1` |

#### Returns

`Promise`\<`bigint`>

A promise that resolves to the latest Quai -> Qi rate for the given amount.

#### Inherited from

[`SocketProvider`](/sdk/content/classes/SocketProvider).[`getLatestQuaiToQiRate`](/sdk/content/classes/SocketProvider#getlatestquaitoqirate)

#### Source

[providers/abstract-provider.ts:1068](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1068)

***

### getProtocolExpansionNumber()

```ts theme={null}
getProtocolExpansionNumber(): Promise<number>
```

Get the protocol expansion number.

#### Returns

`Promise`\<`number`>

A promise that resolves to the protocol expansion number.

#### Inherited from

[`SocketProvider`](/sdk/content/classes/SocketProvider).[`getProtocolExpansionNumber`](/sdk/content/classes/SocketProvider#getprotocolexpansionnumber)

#### Source

[providers/abstract-provider.ts:1101](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1101)

***

### getQiToQuaiRateAtBlock()

```ts theme={null}
getQiToQuaiRateAtBlock(
   zone, 
   blockTag, 
amt?): Promise<bigint>
```

Get the Qi rate at a specific block.

#### Parameters

| Parameter  | Type                                             | Description                                    |
| :--------- | :----------------------------------------------- | :--------------------------------------------- |
| `zone`     | [`Zone`](/sdk/content/enumerations/Zone)         | The zone to get the rate for.                  |
| `blockTag` | [`BlockTag`](/sdk/content/type-aliases/BlockTag) | The block tag to get the rate at.              |
| `amt`?     | `bigint`                                         | The amount to get the rate for. Default is `1` |

#### Returns

`Promise`\<`bigint`>

A promise that resolves to the Qi rate at the specified block.

#### Inherited from

[`SocketProvider`](/sdk/content/classes/SocketProvider).[`getQiToQuaiRateAtBlock`](/sdk/content/classes/SocketProvider#getqitoquairateatblock)

#### Source

[providers/abstract-provider.ts:1162](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1162)

***

### getQuaiToQiRateAtBlock()

```ts theme={null}
getQuaiToQiRateAtBlock(
   zone, 
   blockTag, 
amt?): Promise<bigint>
```

Get the Quai rate at a specific block.

#### Parameters

| Parameter  | Type                                             | Description                                    |
| :--------- | :----------------------------------------------- | :--------------------------------------------- |
| `zone`     | [`Zone`](/sdk/content/enumerations/Zone)         | The zone to get the rate for.                  |
| `blockTag` | [`BlockTag`](/sdk/content/type-aliases/BlockTag) | The block tag to get the rate at.              |
| `amt`?     | `bigint`                                         | The amount to get the rate for. Default is `1` |

#### Returns

`Promise`\<`bigint`>

A promise that resolves to the Quai rate at the specified block.

#### Inherited from

[`SocketProvider`](/sdk/content/classes/SocketProvider).[`getQuaiToQiRateAtBlock`](/sdk/content/classes/SocketProvider#getquaitoqirateatblock)

#### Source

[providers/abstract-provider.ts:1081](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1081)

***

### getSigner()

```ts theme={null}
getSigner(address?): Promise<JsonRpcSigner>
```

Returns a JsonRpcSigner for the given address.

#### Parameters

| Parameter  | Type                 | Description                          |
| :--------- | :------------------- | :----------------------------------- |
| `address`? | `string` \| `number` | The address or index of the account. |

#### Returns

`Promise`\<[`JsonRpcSigner`](/sdk/content/classes/JsonRpcSigner)>

A promise that resolves to the JsonRpcSigner.

#### Inherited from

[`SocketProvider`](/sdk/content/classes/SocketProvider).[`getSigner`](/sdk/content/classes/SocketProvider#getsigner)

#### Throws

If the account is invalid.

#### Source

[providers/provider-jsonrpc.ts:1542](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L1542)

***

### listAccounts()

```ts theme={null}
listAccounts(): Promise<JsonRpcSigner[]>
```

Returns a list of JsonRpcSigners for all accounts.

#### Returns

`Promise`\<[`JsonRpcSigner`](/sdk/content/classes/JsonRpcSigner)\[]>

A promise that resolves to an array of JsonRpcSigners.

#### Inherited from

[`SocketProvider`](/sdk/content/classes/SocketProvider).[`listAccounts`](/sdk/content/classes/SocketProvider#listaccounts)

#### Source

[providers/provider-jsonrpc.ts:1579](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L1579)

***

### pause()

```ts theme={null}
pause(dropWhilePaused?): void
```

Pause the provider. If `dropWhilePaused`, any events that occur while paused are dropped, otherwise all events
will be emitted once the provider is unpaused.

#### Parameters

| Parameter          | Type      | Description                          |
| :----------------- | :-------- | :----------------------------------- |
| `dropWhilePaused`? | `boolean` | Whether to drop events while paused. |

#### Returns

`void`

#### Inherited from

[`SocketProvider`](/sdk/content/classes/SocketProvider).[`pause`](/sdk/content/classes/SocketProvider#pause)

#### Source

[providers/abstract-provider.ts:2598](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L2598)

***

### resume()

```ts theme={null}
resume(): void
```

Resume the provider.

#### Returns

`void`

#### Inherited from

[`SocketProvider`](/sdk/content/classes/SocketProvider).[`resume`](/sdk/content/classes/SocketProvider#resume)

#### Source

[providers/abstract-provider.ts:2627](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L2627)

***

### send()

```ts theme={null}
send(
   method, 
   params, 
   shard?, 
now?): Promise<any>
```

Requests the `method` with `params` via the JSON-RPC protocol over the underlying channel. This can be used to
call methods on the backend that do not have a high-level API within the Provider API.

This method queues requests according to the batch constraints in the options, assigns the request a unique ID.

**Do NOT override** this method in sub-classes; instead override JsonRpcApiProvider.\_send | **\_send** or
force the options values in the call to the constructor to modify this method's behavior.

#### Parameters

| Parameter | Type                                       | Description                                    |
| :-------- | :----------------------------------------- | :--------------------------------------------- |
| `method`  | `string`                                   | The method to call.                            |
| `params`  | `any`\[] \| `Record`\<`string`, `any`>     | The parameters to pass to the method.          |
| `shard`?  | [`Shard`](/sdk/content/enumerations/Shard) | The shard to send the request to.              |
| `now`?    | `boolean`                                  | If true, the request will be sent immediately. |

#### Returns

`Promise`\<`any`>

A promise that resolves to the result of the method call.

#### Inherited from

[`SocketProvider`](/sdk/content/classes/SocketProvider).[`send`](/sdk/content/classes/SocketProvider#send)

#### Source

[providers/provider-jsonrpc.ts:1500](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L1500)

***

### shardFromHash()

```ts theme={null}
shardFromHash(hash): Shard
```

Get the shard from a hash.

#### Parameters

| Parameter | Type     | Description                     |
| :-------- | :------- | :------------------------------ |
| `hash`    | `string` | The hash to get the shard from. |

#### Returns

[`Shard`](/sdk/content/enumerations/Shard)

The shard.

#### Inherited from

[`SocketProvider`](/sdk/content/classes/SocketProvider).[`shardFromHash`](/sdk/content/classes/SocketProvider#shardfromhash)

#### Source

[providers/abstract-provider.ts:1047](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1047)

***

### waitShardReady()

```ts theme={null}
waitShardReady(shard): Promise<void>
```

Wait until the shard is ready. Max wait time is \~8 seconds.

#### Parameters

| Parameter | Type                                       | Description           |
| :-------- | :----------------------------------------- | :-------------------- |
| `shard`   | [`Shard`](/sdk/content/enumerations/Shard) | The shard identifier. |

#### Returns

`Promise`\<`void`>

A promise that resolves when the shard is ready.

#### Throws

If the shard is not ready within the timeout period.

#### Source

[providers/provider-websocket.ts:166](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-websocket.ts#L166)

***

### zoneFromAddress()

```ts theme={null}
zoneFromAddress(_address): Promise<Zone>
```

Get the zone from an address.

#### Parameters

| Parameter  | Type                                                   | Description                       |
| :--------- | :----------------------------------------------------- | :-------------------------------- |
| `_address` | [`AddressLike`](/sdk/content/type-aliases/AddressLike) | The address to get the zone from. |

#### Returns

`Promise`\<[`Zone`](/sdk/content/enumerations/Zone)>

A promise that resolves to the zone.

#### Inherited from

[`SocketProvider`](/sdk/content/classes/SocketProvider).[`zoneFromAddress`](/sdk/content/classes/SocketProvider#zonefromaddress)

#### Source

[providers/abstract-provider.ts:1036](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1036)

***

### zoneFromHash()

```ts theme={null}
zoneFromHash(hash): Zone
```

Get the zone from a hash.

#### Parameters

| Parameter | Type     | Description                    |
| :-------- | :------- | :----------------------------- |
| `hash`    | `string` | The hash to get the zone from. |

#### Returns

[`Zone`](/sdk/content/enumerations/Zone)

The zone.

#### Inherited from

[`SocketProvider`](/sdk/content/classes/SocketProvider).[`zoneFromHash`](/sdk/content/classes/SocketProvider#zonefromhash)

#### Source

[providers/abstract-provider.ts:1057](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L1057)


# AddressStatus
Source: https://docs.qu.ai/sdk/content/enumerations/AddressStatus



Enum representing the status of an address in the wallet.

## Enumeration Members

### ATTEMPTED\_USE

```ts theme={null}
ATTEMPTED_USE: "ATTEMPTED_USE";
```

#### Source

[wallet/qi-hdwallet.ts:53](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L53)

***

### UNKNOWN

```ts theme={null}
UNKNOWN: "UNKNOWN";
```

#### Source

[wallet/qi-hdwallet.ts:54](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L54)

***

### UNUSED

```ts theme={null}
UNUSED: "UNUSED";
```

#### Source

[wallet/qi-hdwallet.ts:52](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L52)

***

### USED

```ts theme={null}
USED: "USED";
```

#### Source

[wallet/qi-hdwallet.ts:51](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L51)


# accessListify
Source: https://docs.qu.ai/sdk/content/functions/accessListify



```ts theme={null}
function accessListify(value): AccessList
```

Returns an [**AccessList**](/sdk/content/type-aliases/AccessList) from any quasi-supported access-list structure.

## Parameters

| Parameter | Type                                                       | Description                             |
| :-------- | :--------------------------------------------------------- | :-------------------------------------- |
| `value`   | [`AccessListish`](/sdk/content/type-aliases/AccessListish) | The value to convert to an access list. |

## Returns

[`AccessList`](/sdk/content/type-aliases/AccessList)

The access list.

## Throws

If the value is not a valid access list.

## Source

[transaction/accesslist.ts:33](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/accesslist.ts#L33)


# copyRequest
Source: https://docs.qu.ai/sdk/content/functions/copyRequest



```ts theme={null}
function copyRequest(req): PreparedTransactionRequest
```

Returns a copy of `req` with all properties coerced to their strict types.

## Parameters

| Parameter | Type                                                                 | Description                      |
| :-------- | :------------------------------------------------------------------- | :------------------------------- |
| `req`     | [`TransactionRequest`](/sdk/content/type-aliases/TransactionRequest) | The transaction request to copy. |

## Returns

[`PreparedTransactionRequest`](/sdk/content/type-aliases/PreparedTransactionRequest)

The prepared transaction request.

## Throws

If the request is invalid.

## Source

[providers/provider.ts:388](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L388)


# encodeBytes32
Source: https://docs.qu.ai/sdk/content/functions/encodeBytes32



```ts theme={null}
function encodeBytes32(text): string
```

Encodes a string as a Bytes32 string. This is used to encode ABI data.

## Parameters

| Parameter | Type     | Description           |
| :-------- | :------- | :-------------------- |
| `text`    | `string` | The string to encode. |

## Returns

`string`

The Bytes32-encoded string.

## Throws

If the string is too long to fit in a Bytes32 format.

## Source

[encoding/bytes32.ts:20](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/encoding/bytes32.ts#L20)


# hashMessage
Source: https://docs.qu.ai/sdk/content/functions/hashMessage



```ts theme={null}
function hashMessage(message): string
```

Computes the Quai Network equivalent of the [EIP-191](https://eips.ethereum.org/EIPS/eip-191) personal-sign message
digest to sign.

This prefixes the message with [**MessagePrefix**](/sdk/content/variables/MessagePrefix) and the decimal length of `message` and
computes the [**keccak256**](/sdk/content/functions/keccak256) digest.

If `message` is a string, it is converted to its UTF-8 bytes first. To compute the digest of a
[**DataHexString**](../types-aliases/DataHex), it must be converted to [**bytes**](../functions/getBytes).

## Parameters

| Parameter | Type                     | Description          |
| :-------- | :----------------------- | :------------------- |
| `message` | `string` \| `Uint8Array` | The message to hash. |

## Returns

`string`

The message digest.

## Example

```ts theme={null}
hashMessage('Hello World');

// Hashes the SIX (6) string characters, i.e.
// [ "0", "x", "4", "2", "4", "3" ]
hashMessage('0x4243');

// Hashes the TWO (2) bytes [ 0x42, 0x43 ]...
hashMessage(getBytes('0x4243'));

// ...which is equal to using data
hashMessage(new Uint8Array([0x42, 0x43]));
```

## Source

[hash/message.ts:39](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/hash/message.ts#L39)


# id
Source: https://docs.qu.ai/sdk/content/functions/id



```ts theme={null}
function id(value): string
```

A simple hashing function which operates on UTF-8 strings to compute an 32-byte identifier.

This simply computes the [**UTF-8 bytes**](/sdk/content/functions/toUtf8Bytes) and computes the [**keccak256**](/sdk/content/functions/keccak256).

## Parameters

| Parameter | Type     | Description         |
| :-------- | :------- | :------------------ |
| `value`   | `string` | The string to hash. |

## Returns

`string`

The 32-byte identifier.

## Example

```ts theme={null}
id('hello world');
```

## Source

[hash/id.ts:19](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/hash/id.ts#L19)


# solidityPacked
Source: https://docs.qu.ai/sdk/content/functions/solidityPacked



```ts theme={null}
function solidityPacked(types, values): string
```

Computes the [Non-Standard Packed
Mode](https://docs.soliditylang.org/en/v0.8.14/abi-spec.html#non-standard-packed-mode) representation of `values`
respectively to their `types`.

## Parameters

| Parameter | Type                 | Description              |
| :-------- | :------------------- | :----------------------- |
| `types`   | readonly `string`\[] | The types of the values. |
| `values`  | readonly `any`\[]    | The values to pack.      |

## Returns

`string`

The packed values.

## Example

```ts theme={null}
addr = '0x8ba1f109551bd432803012645ac136ddd64dba72';
solidityPacked(['address', 'uint'], [addr, 45]);
```

## Source

[hash/solidity.ts:110](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/hash/solidity.ts#L110)


# solidityPackedKeccak256
Source: https://docs.qu.ai/sdk/content/functions/solidityPackedKeccak256



```ts theme={null}
function solidityPackedKeccak256(types, values): string
```

Computes the [Non-Standard Packed
Mode](https://docs.soliditylang.org/en/v0.8.14/abi-spec.html#non-standard-packed-mode)
[**keccak256**](../functions/keccak256) hash of `values` respectively to their `types`.

## Parameters

| Parameter | Type                 | Description              |
| :-------- | :------------------- | :----------------------- |
| `types`   | readonly `string`\[] | The types of the values. |
| `values`  | readonly `any`\[]    | The values to hash.      |

## Returns

`string`

The hash of the packed values.

## Example

```ts theme={null}
addr = '0x8ba1f109551bd432803012645ac136ddd64dba72';
solidityPackedKeccak256(['address', 'uint'], [addr, 45]);
```

## Source

[hash/solidity.ts:142](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/hash/solidity.ts#L142)


# solidityPackedSha256
Source: https://docs.qu.ai/sdk/content/functions/solidityPackedSha256



```ts theme={null}
function solidityPackedSha256(types, values): string
```

Computes the [Non-Standard Packed
Mode](https://docs.soliditylang.org/en/v0.8.14/abi-spec.html#non-standard-packed-mode) [sha256](../functions/sha256)
hash of `values` respectively to their `types`.

## Parameters

| Parameter | Type                 | Description              |
| :-------- | :------------------- | :----------------------- |
| `types`   | readonly `string`\[] | The types of the values. |
| `values`  | readonly `any`\[]    | The values to hash.      |

## Returns

`string`

The hash of the packed values.

## Example

```ts theme={null}
addr = '0x8ba1f109551bd432803012645ac136ddd64dba72';
solidityPackedSha256(['address', 'uint'], [addr, 45]);
```

## Source

[hash/solidity.ts:163](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/hash/solidity.ts#L163)


# toUtf8Bytes
Source: https://docs.qu.ai/sdk/content/functions/toUtf8Bytes



```ts theme={null}
function toUtf8Bytes(str, form?): Uint8Array
```

Returns the UTF-8 byte representation of `str`.

If `form` is specified, the string is normalized.

## Parameters

| Parameter | Type                                                                             | Description                    |
| :-------- | :------------------------------------------------------------------------------- | :----------------------------- |
| `str`     | `string`                                                                         | The string to convert.         |
| `form`?   | [`UnicodeNormalizationForm`](/sdk/content/type-aliases/UnicodeNormalizationForm) | The normalization form to use. |

## Returns

`Uint8Array`

The UTF-8 byte representation.

## Throws

If the UTF-8 conversion fails.

## Source

[encoding/utf8.ts:285](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/encoding/utf8.ts#L285)


# toUtf8CodePoints
Source: https://docs.qu.ai/sdk/content/functions/toUtf8CodePoints



```ts theme={null}
function toUtf8CodePoints(str, form?): number[]
```

Returns the UTF-8 code-points for `str`.

If `form` is specified, the string is normalized.

## Parameters

| Parameter | Type                                                                             | Description                    |
| :-------- | :------------------------------------------------------------------------------- | :----------------------------- |
| `str`     | `string`                                                                         | The string to convert.         |
| `form`?   | [`UnicodeNormalizationForm`](/sdk/content/type-aliases/UnicodeNormalizationForm) | The normalization form to use. |

## Returns

`number`\[]

The UTF-8 code-points.

## Source

[encoding/utf8.ts:362](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/encoding/utf8.ts#L362)


# toUtf8String
Source: https://docs.qu.ai/sdk/content/functions/toUtf8String



```ts theme={null}
function toUtf8String(bytes, onError?): string
```

Returns the string represented by the UTF-8 data `bytes`.

When `onError` function is specified, it is called on UTF-8 errors allowing recovery using the
[**Utf8ErrorFunc**](/sdk/content/type-aliases/Utf8ErrorFunc) API. (default: [error](Utf8ErrorFuncs))

## Parameters

| Parameter  | Type                                                       | Description                  |
| :--------- | :--------------------------------------------------------- | :--------------------------- |
| `bytes`    | [`BytesLike`](/sdk/content/type-aliases/BytesLike)         | The UTF-8 data to convert.   |
| `onError`? | [`Utf8ErrorFunc`](/sdk/content/type-aliases/Utf8ErrorFunc) | The error handling function. |

## Returns

`string`

The string.

## Source

[encoding/utf8.ts:348](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/encoding/utf8.ts#L348)


# verifyMessage
Source: https://docs.qu.ai/sdk/content/functions/verifyMessage



```ts theme={null}
function verifyMessage(message, sig): string
```

Return the address of the private key that produced the signature `sig` during signing for `message`.

## Parameters

| Parameter | Type                                                       | Description                  |
| :-------- | :--------------------------------------------------------- | :--------------------------- |
| `message` | `string` \| `Uint8Array`                                   | The message that was signed. |
| `sig`     | [`SignatureLike`](/sdk/content/type-aliases/SignatureLike) | The signature to verify.     |

## Returns

`string`

The address of the signer.

## Source

[hash/message.ts:54](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/hash/message.ts#L54)


# verifyTypedData
Source: https://docs.qu.ai/sdk/content/functions/verifyTypedData



```ts theme={null}
function verifyTypedData(
   domain, 
   types, 
   value, 
   signature): string
```

Compute the address used to sign the typed data for the `signature`.

## Parameters

| Parameter   | Type                                                                               | Description                   |
| :---------- | :--------------------------------------------------------------------------------- | :---------------------------- |
| `domain`    | [`TypedDataDomain`](/sdk/content/interfaces/TypedDataDomain)                       | The domain of the typed data. |
| `types`     | `Record`\<`string`, [`TypedDataField`](/sdk/content/interfaces/TypedDataField)\[]> | The types of the typed data.  |
| `value`     | `Record`\<`string`, `any`>                                                         | The value of the typed data.  |
| `signature` | [`SignatureLike`](/sdk/content/type-aliases/SignatureLike)                         | The signature to verify.      |

## Returns

`string`

The address that signed the typed data.

## Source

[hash/typed-data.ts:710](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/hash/typed-data.ts#L710)


# ActionRejectedError
Source: https://docs.qu.ai/sdk/content/interfaces/ActionRejectedError



This Error indicates a request was rejected by the user.

In most clients (such as MetaMask), when an operation requires user authorization (such as `signer.sendTransaction`),
the client presents a dialog box to the user. If the user denies the request this error is thrown.

## Extends

* [`quaisError`](/sdk/content/interfaces/quaisError)\<`"ACTION_REJECTED"`>

## Properties

| Property       | Type                                                                                                                      | Description                                                                                                                                                                                              | Inherited from                                                    |
| :------------- | :------------------------------------------------------------------------------------------------------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------- |
| `action`       | \| `"unknown"` \| `"sendTransaction"` \| `"signTransaction"` \| `"signMessage"` \| `"signTypedData"` \| `"requestAccess"` | The requested action.                                                                                                                                                                                    | -                                                                 |
| `code`         | [`ErrorCode`](/sdk/content/type-aliases/ErrorCode)                                                                        | The string error code.                                                                                                                                                                                   | [`quaisError`](/sdk/content/interfaces/quaisError).`code`         |
| `error?`       | `Error`                                                                                                                   | Any related error.                                                                                                                                                                                       | [`quaisError`](/sdk/content/interfaces/quaisError).`error`        |
| `info?`        | `Record`\<`string`, `any`>                                                                                                | Additional info regarding the error that may be useful.<br /><br />This is generally helpful mostly for human-based debugging.                                                                           | [`quaisError`](/sdk/content/interfaces/quaisError).`info`         |
| `reason`       | `"rejected"` \| `"pending"` \| `"expired"`                                                                                | The reason the action was rejected.<br /><br />If there is already a pending request, some clients may indicate there is already a `"pending"` action. This<br />prevents an app from spamming the user. | -                                                                 |
| `shortMessage` | `string`                                                                                                                  | A short message describing the error, with minimal additional details.                                                                                                                                   | [`quaisError`](/sdk/content/interfaces/quaisError).`shortMessage` |


# BadDataError
Source: https://docs.qu.ai/sdk/content/interfaces/BadDataError



This Error indicates that a provided set of data cannot be correctly interpreted.

## Extends

* [`quaisError`](/sdk/content/interfaces/quaisError)\<`"BAD_DATA"`>

## Properties

| Property       | Type                                               | Description                                                                                                                    | Inherited from                                                    |
| :------------- | :------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------- |
| `code`         | [`ErrorCode`](/sdk/content/type-aliases/ErrorCode) | The string error code.                                                                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`code`         |
| `error?`       | `Error`                                            | Any related error.                                                                                                             | [`quaisError`](/sdk/content/interfaces/quaisError).`error`        |
| `info?`        | `Record`\<`string`, `any`>                         | Additional info regarding the error that may be useful.<br /><br />This is generally helpful mostly for human-based debugging. | [`quaisError`](/sdk/content/interfaces/quaisError).`info`         |
| `shortMessage` | `string`                                           | A short message describing the error, with minimal additional details.                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`shortMessage` |
| `value`        | `any`                                              | The data.                                                                                                                      | -                                                                 |


# BlockParams
Source: https://docs.qu.ai/sdk/content/interfaces/BlockParams



A **BlockParams** encodes the minimal required properties for a formatted block.


# BufferOverrunError
Source: https://docs.qu.ai/sdk/content/interfaces/BufferOverrunError



This Error indicates an attempt was made to read outside the bounds of protected data.

Most operations in quais are protected by bounds checks, to mitigate exploits when parsing data.

## Extends

* [`quaisError`](/sdk/content/interfaces/quaisError)\<`"BUFFER_OVERRUN"`>

## Properties

| Property       | Type                                               | Description                                                                                                                    | Inherited from                                                    |
| :------------- | :------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------- |
| `buffer`       | `Uint8Array`                                       | The buffer that was overrun.                                                                                                   | -                                                                 |
| `code`         | [`ErrorCode`](/sdk/content/type-aliases/ErrorCode) | The string error code.                                                                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`code`         |
| `error?`       | `Error`                                            | Any related error.                                                                                                             | [`quaisError`](/sdk/content/interfaces/quaisError).`error`        |
| `info?`        | `Record`\<`string`, `any`>                         | Additional info regarding the error that may be useful.<br /><br />This is generally helpful mostly for human-based debugging. | [`quaisError`](/sdk/content/interfaces/quaisError).`info`         |
| `length`       | `number`                                           | The length of the buffer.                                                                                                      | -                                                                 |
| `offset`       | `number`                                           | The offset that was requested.                                                                                                 | -                                                                 |
| `shortMessage` | `string`                                           | A short message describing the error, with minimal additional details.                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`shortMessage` |


# CallExceptionError
Source: https://docs.qu.ai/sdk/content/interfaces/CallExceptionError



This **Error** indicates a transaction reverted.

## Extends

* [`quaisError`](/sdk/content/interfaces/quaisError)\<`"CALL_EXCEPTION"`>

## Properties

| Property       | Type                                                                              | Description                                                                                                                    | Inherited from                                                    |
| :------------- | :-------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------- |
| `action`       | [`CallExceptionAction`](/sdk/content/type-aliases/CallExceptionAction)            | The action being performed when the revert was encountered.                                                                    | -                                                                 |
| `code`         | [`ErrorCode`](/sdk/content/type-aliases/ErrorCode)                                | The string error code.                                                                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`code`         |
| `data`         | `null` \| `string`                                                                | The revert data returned.                                                                                                      | -                                                                 |
| `error?`       | `Error`                                                                           | Any related error.                                                                                                             | [`quaisError`](/sdk/content/interfaces/quaisError).`error`        |
| `info?`        | `Record`\<`string`, `any`>                                                        | Additional info regarding the error that may be useful.<br /><br />This is generally helpful mostly for human-based debugging. | [`quaisError`](/sdk/content/interfaces/quaisError).`info`         |
| `invocation`   | `null` \| \{ `"args"`: `any`\[]; `"method"`: `string`; `"signature"`: `string`; } | The contract invocation details, if available.                                                                                 | -                                                                 |
| `reason`       | `null` \| `string`                                                                | A human-readable representation of data, if possible.                                                                          | -                                                                 |
| `receipt?`     | [`TransactionReceipt`](/sdk/content/classes/TransactionReceipt)                   | If the error occurred in a transaction that was mined (with a status of `0`), this is the receipt.                             | -                                                                 |
| `revert`       | `null` \| \{ `"args"`: `any`\[]; `"name"`: `string`; `"signature"`: `string`; }   | The built-in or custom revert error, if available                                                                              | -                                                                 |
| `shortMessage` | `string`                                                                          | A short message describing the error, with minimal additional details.                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`shortMessage` |
| `transaction`  | [`CallExceptionTransaction`](/sdk/content/type-aliases/CallExceptionTransaction)  | The transaction that triggered the exception.                                                                                  | -                                                                 |


# CancelledError
Source: https://docs.qu.ai/sdk/content/interfaces/CancelledError



This Error indicates that the operation was cancelled by a programmatic call, for example to `cancel()`.

## Extends

* [`quaisError`](/sdk/content/interfaces/quaisError)\<`"CANCELLED"`>

## Properties

| Property       | Type                                               | Description                                                                                                                    | Inherited from                                                    |
| :------------- | :------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------- |
| `code`         | [`ErrorCode`](/sdk/content/type-aliases/ErrorCode) | The string error code.                                                                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`code`         |
| `error?`       | `Error`                                            | Any related error.                                                                                                             | [`quaisError`](/sdk/content/interfaces/quaisError).`error`        |
| `info?`        | `Record`\<`string`, `any`>                         | Additional info regarding the error that may be useful.<br /><br />This is generally helpful mostly for human-based debugging. | [`quaisError`](/sdk/content/interfaces/quaisError).`info`         |
| `shortMessage` | `string`                                           | A short message describing the error, with minimal additional details.                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`shortMessage` |


# Eip1193Provider
Source: https://docs.qu.ai/sdk/content/interfaces/Eip1193Provider



The interface to an [EIP-1193](https://eips.ethereum.org/EIPS/eip-1193) provider, which is a standard used by most
injected providers, which the [**BrowserProvider**](/sdk/content/classes/BrowserProvider) accepts and exposes the API of.

## Methods

### request()

```ts theme={null}
request(request): Promise<any>
```

See [EIP-1193](https://eips.ethereum.org/EIPS/eip-1193) for details on this method.

#### Parameters

| Parameter         | Type                                       | Description                       |
| :---------------- | :----------------------------------------- | :-------------------------------- |
| `request`         | `object`                                   | The request object.               |
| `request.method`  | `string`                                   | The method name.                  |
| `request.params`? | `any`\[] \| `Record`\<`string`, `any`>     | The parameters for the method.    |
| `request.shard`?  | [`Shard`](/sdk/content/enumerations/Shard) | The shard to send the request to. |

#### Returns

`Promise`\<`any`>

The result of the request.

#### Source

[providers/provider-browser.ts:25](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-browser.ts#L25)


# EventEmitterable
Source: https://docs.qu.ai/sdk/content/interfaces/EventEmitterable



An **EventEmitterable** behaves similar to an EventEmitter except provides async access to its methods.

An EventEmitter implements the observer pattern.

## Extended by

* [`Provider`](/sdk/content/interfaces/Provider)

## Type parameters

| Type parameter |
| :------------- |
| `T`            |

## Methods

### addListener()

```ts theme={null}
addListener(
   event, 
   listener, 
zone?): Promise<EventEmitterable<T>>
```

Alias for [**on**](/sdk/content/interfaces/EventEmitterable#on).

#### Parameters

| Parameter  | Type                                             |
| :--------- | :----------------------------------------------- |
| `event`    | `T`                                              |
| `listener` | [`Listener`](/sdk/content/type-aliases/Listener) |
| `zone`?    | [`Zone`](/sdk/content/enumerations/Zone)         |

#### Returns

`Promise`\<[`EventEmitterable`](/sdk/content/interfaces/EventEmitterable)\<`T`>>

#### Source

[utils/events.ts:61](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/events.ts#L61)

***

### emit()

```ts theme={null}
emit(
   event, 
   zone?, ...
args?): Promise<boolean>
```

Triggers each listener for `event` with the `args`.

#### Parameters

| Parameter  | Type                                     |
| :--------- | :--------------------------------------- |
| `event`    | `T`                                      |
| `zone`?    | [`Zone`](/sdk/content/enumerations/Zone) |
| ...`args`? | `any`\[]                                 |

#### Returns

`Promise`\<`boolean`>

#### Source

[utils/events.ts:36](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/events.ts#L36)

***

### listenerCount()

```ts theme={null}
listenerCount(event?): Promise<number>
```

Resolves to the number of listeners for `event`.

#### Parameters

| Parameter | Type |
| :-------- | :--- |
| `event`?  | `T`  |

#### Returns

`Promise`\<`number`>

#### Source

[utils/events.ts:41](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/events.ts#L41)

***

### listeners()

```ts theme={null}
listeners(event?): Promise<Listener[]>
```

Resolves to the listeners for `event`.

#### Parameters

| Parameter | Type |
| :-------- | :--- |
| `event`?  | `T`  |

#### Returns

`Promise`\<[`Listener`](/sdk/content/type-aliases/Listener)\[]>

#### Source

[utils/events.ts:46](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/events.ts#L46)

***

### off()

```ts theme={null}
off(
   event, 
   listener?, 
zone?): Promise<EventEmitterable<T>>
```

Unregister the `listener` for `event`. If `listener` is unspecified, all listeners are unregistered.

#### Parameters

| Parameter   | Type                                             |
| :---------- | :----------------------------------------------- |
| `event`     | `T`                                              |
| `listener`? | [`Listener`](/sdk/content/type-aliases/Listener) |
| `zone`?     | [`Zone`](/sdk/content/enumerations/Zone)         |

#### Returns

`Promise`\<[`EventEmitterable`](/sdk/content/interfaces/EventEmitterable)\<`T`>>

#### Source

[utils/events.ts:51](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/events.ts#L51)

***

### on()

```ts theme={null}
on(
   event, 
   listener, 
zone?): Promise<EventEmitterable<T>>
```

Registers a `listener` that is called whenever the `event` occurs until unregistered.

#### Parameters

| Parameter  | Type                                             |
| :--------- | :----------------------------------------------- |
| `event`    | `T`                                              |
| `listener` | [`Listener`](/sdk/content/type-aliases/Listener) |
| `zone`?    | [`Zone`](/sdk/content/enumerations/Zone)         |

#### Returns

`Promise`\<[`EventEmitterable`](/sdk/content/interfaces/EventEmitterable)\<`T`>>

#### Source

[utils/events.ts:26](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/events.ts#L26)

***

### once()

```ts theme={null}
once(
   event, 
   listener, 
zone?): Promise<EventEmitterable<T>>
```

Registers a `listener` that is called the next time `event` occurs.

#### Parameters

| Parameter  | Type                                             |
| :--------- | :----------------------------------------------- |
| `event`    | `T`                                              |
| `listener` | [`Listener`](/sdk/content/type-aliases/Listener) |
| `zone`?    | [`Zone`](/sdk/content/enumerations/Zone)         |

#### Returns

`Promise`\<[`EventEmitterable`](/sdk/content/interfaces/EventEmitterable)\<`T`>>

#### Source

[utils/events.ts:31](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/events.ts#L31)

***

### removeAllListeners()

```ts theme={null}
removeAllListeners(event?): Promise<EventEmitterable<T>>
```

Unregister all listeners for `event`.

#### Parameters

| Parameter | Type |
| :-------- | :--- |
| `event`?  | `T`  |

#### Returns

`Promise`\<[`EventEmitterable`](/sdk/content/interfaces/EventEmitterable)\<`T`>>

#### Source

[utils/events.ts:56](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/events.ts#L56)

***

### removeListener()

```ts theme={null}
removeListener(
   event, 
   listener, 
zone?): Promise<EventEmitterable<T>>
```

Alias for [**off**](/sdk/content/interfaces/EventEmitterable#off).

#### Parameters

| Parameter  | Type                                             |
| :--------- | :----------------------------------------------- |
| `event`    | `T`                                              |
| `listener` | [`Listener`](/sdk/content/type-aliases/Listener) |
| `zone`?    | [`Zone`](/sdk/content/enumerations/Zone)         |

#### Returns

`Promise`\<[`EventEmitterable`](/sdk/content/interfaces/EventEmitterable)\<`T`>>

#### Source

[utils/events.ts:66](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/events.ts#L66)


# EventFilter
Source: https://docs.qu.ai/sdk/content/interfaces/EventFilter



An **EventFilter** allows efficiently filtering logs (also known as events) using bloom filters included within
blocks.

## Extended by

* [`Filter`](/sdk/content/interfaces/Filter)
* [`FilterByBlockHash`](/sdk/content/interfaces/FilterByBlockHash)


# Filter
Source: https://docs.qu.ai/sdk/content/interfaces/Filter



A **Filter** allows searching a specific range of blocks for mathcing logs.

## Extends

* [`EventFilter`](/sdk/content/interfaces/EventFilter)

## Properties

| Property     | Type                                             | Description                                 |
| :----------- | :----------------------------------------------- | :------------------------------------------ |
| `fromBlock?` | [`BlockTag`](/sdk/content/type-aliases/BlockTag) | The start block for the filter (inclusive). |
| `toBlock?`   | [`BlockTag`](/sdk/content/type-aliases/BlockTag) | The end block for the filter (inclusive).   |


# FilterByBlockHash
Source: https://docs.qu.ai/sdk/content/interfaces/FilterByBlockHash



A **FilterByBlockHash** allows searching a specific block for mathcing logs.

## Extends

* [`EventFilter`](/sdk/content/interfaces/EventFilter)

## Properties

| Property     | Type     | Description                                         |
| :----------- | :------- | :-------------------------------------------------- |
| `blockHash?` | `string` | The blockhash of the specific block for the filter. |


# InsufficientFundsError
Source: https://docs.qu.ai/sdk/content/interfaces/InsufficientFundsError



The sending account has insufficient funds to cover the entire transaction cost.

## Extends

* [`quaisError`](/sdk/content/interfaces/quaisError)\<`"INSUFFICIENT_FUNDS"`>

## Properties

| Property       | Type                                                                 | Description                                                                                                                    | Inherited from                                                    |
| :------------- | :------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------- |
| `code`         | [`ErrorCode`](/sdk/content/type-aliases/ErrorCode)                   | The string error code.                                                                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`code`         |
| `error?`       | `Error`                                                              | Any related error.                                                                                                             | [`quaisError`](/sdk/content/interfaces/quaisError).`error`        |
| `info?`        | `Record`\<`string`, `any`>                                           | Additional info regarding the error that may be useful.<br /><br />This is generally helpful mostly for human-based debugging. | [`quaisError`](/sdk/content/interfaces/quaisError).`info`         |
| `shortMessage` | `string`                                                             | A short message describing the error, with minimal additional details.                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`shortMessage` |
| `transaction`  | [`TransactionRequest`](/sdk/content/type-aliases/TransactionRequest) | The transaction.                                                                                                               | -                                                                 |


# InvalidArgumentError
Source: https://docs.qu.ai/sdk/content/interfaces/InvalidArgumentError



This Error indicates an incorrect type or value was passed to a function or method.

## Extends

* [`quaisError`](/sdk/content/interfaces/quaisError)\<`"INVALID_ARGUMENT"`>

## Properties

| Property       | Type                                               | Description                                                            | Inherited from                                                    |
| :------------- | :------------------------------------------------- | :--------------------------------------------------------------------- | :---------------------------------------------------------------- |
| `argument`     | `string`                                           | The name of the argument.                                              | -                                                                 |
| `code`         | [`ErrorCode`](/sdk/content/type-aliases/ErrorCode) | The string error code.                                                 | [`quaisError`](/sdk/content/interfaces/quaisError).`code`         |
| `error?`       | `Error`                                            | Any related error.                                                     | [`quaisError`](/sdk/content/interfaces/quaisError).`error`        |
| `shortMessage` | `string`                                           | A short message describing the error, with minimal additional details. | [`quaisError`](/sdk/content/interfaces/quaisError).`shortMessage` |
| `value`        | `any`                                              | The value that was provided.                                           | -                                                                 |


# LogParams
Source: https://docs.qu.ai/sdk/content/interfaces/LogParams



A **LogParams** encodes the minimal required properties for a formatted log.

## Properties

| Property           | Type                 | Description                                                                                                    |
| :----------------- | :------------------- | :------------------------------------------------------------------------------------------------------------- |
| `address`          | `string`             | The address of the contract that emitted this log.                                                             |
| `blockHash`        | `string`             | The block hash of the block that included the transaction for this log.                                        |
| `blockNumber`      | `number`             | The block number of the block that included the transaction for this log.                                      |
| `data`             | `string`             | The data emitted with this log.                                                                                |
| `index`            | `number`             | The index of this log.                                                                                         |
| `removed`          | `boolean`            | Whether this log was removed due to the transaction it was included in being removed dur to an orphaned block. |
| `topics`           | readonly `string`\[] | The topics emitted with this log.                                                                              |
| `transactionHash`  | `string`             | The transaction hash for the transaxction the log occurred in.                                                 |
| `transactionIndex` | `number`             | The transaction index of this log.                                                                             |


# MinedBlock
Source: https://docs.qu.ai/sdk/content/interfaces/MinedBlock



An Interface to indicate a [**Block**](/sdk/content/classes/Block) has been included in the blockchain. This asserts a Type Guard
that necessary properties are non-null.

Before a block is included, it is a pending block.

## Extends

* [`Block`](/sdk/content/classes/Block)

## Properties

| Property   | Modifier   | Type                                           | Description                                                                        | Inherited from                                   |
| :--------- | :--------- | :--------------------------------------------- | :--------------------------------------------------------------------------------- | :----------------------------------------------- |
| `provider` | `readonly` | [`Provider`](/sdk/content/interfaces/Provider) | The provider connected to the block used to fetch additional details if necessary. | [`Block`](/sdk/content/classes/Block).`provider` |

## Accessors

### date

```ts theme={null}
get date(): null | Date
```

The [Date](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date) this block was
included at.

#### Returns

`null` | `Date`

The date this block was included at, or null if the timestamp is not available.

#### Source

[providers/provider.ts:826](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L826)

***

### length

```ts theme={null}
get length(): number
```

The number of transactions in this block.

#### Returns

`number`

The number of transactions.

#### Source

[providers/provider.ts:816](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L816)

***

### outboundEtxs

```ts theme={null}
get outboundEtxs(): readonly string[]
```

Returns the list of extended transaction hashes, in the order they were executed within the block.

#### Returns

readonly `string`\[]

The list of extended transaction hashes.

#### Source

[providers/provider.ts:689](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L689)

***

### prefetchedExtTransactions

```ts theme={null}
get prefetchedExtTransactions(): ExternalTransactionResponse[]
```

Returns the complete extended transactions, in the order they were executed within the block.

This is only available for blocks which prefetched transactions, by passing `true` to `prefetchTxs` into
[**getBlock**](/sdk/content/interfaces/Provider#getblock).

#### Throws

If the transactions were not prefetched.

#### Returns

`ExternalTransactionResponse`\[]

The list of prefetched extended transactions.

#### Source

[providers/provider.ts:737](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L737)

***

### prefetchedTransactions

```ts theme={null}
get prefetchedTransactions(): TransactionResponse[]
```

Returns the complete transactions, in the order they were executed within the block.

This is only available for blocks which prefetched transactions, by passing `true` to `prefetchTxs` into
[**getBlock**](/sdk/content/interfaces/Provider#getblock).

#### Throws

If the transactions were not prefetched.

#### Returns

[`TransactionResponse`](/sdk/content/type-aliases/TransactionResponse)\[]

The list of prefetched transactions.

#### Source

[providers/provider.ts:707](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L707)

***

### transactions

```ts theme={null}
get transactions(): readonly string[]
```

Returns the list of transaction hashes, in the order they were executed within the block.

#### Returns

readonly `string`\[]

The list of transaction hashes.

#### Source

[providers/provider.ts:675](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L675)

## Methods

### getExtTransaction()

```ts theme={null}
getExtTransaction(indexOrHash): Promise<ExternalTransactionResponse>
```

Get the extended transaction at `index` within this block.

#### Parameters

| Parameter     | Type                 | Description                                    |
| :------------ | :------------------- | :--------------------------------------------- |
| `indexOrHash` | `string` \| `number` | The index or hash of the extended transaction. |

#### Returns

`Promise`\<`ExternalTransactionResponse`>

A promise resolving to the extended transaction.

#### Inherited from

[`Block`](/sdk/content/classes/Block).[`getExtTransaction`](/sdk/content/classes/Block#getexttransaction)

#### Throws

If the extended transaction is not found.

#### Source

[providers/provider.ts:883](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L883)

***

### getPrefetchedTransaction()

```ts theme={null}
getPrefetchedTransaction(indexOrHash): TransactionResponse
```

If a **Block** was fetched with a request to include the transactions this will allow synchronous access to those
transactions.

If the transactions were not prefetched, this will throw.

#### Parameters

| Parameter     | Type                 | Description                           |
| :------------ | :------------------- | :------------------------------------ |
| `indexOrHash` | `string` \| `number` | The index or hash of the transaction. |

#### Returns

[`TransactionResponse`](/sdk/content/type-aliases/TransactionResponse)

The transaction.

#### Inherited from

[`Block`](/sdk/content/classes/Block).[`getPrefetchedTransaction`](/sdk/content/classes/Block#getprefetchedtransaction)

#### Throws

If the transaction is not found.

#### Source

[providers/provider.ts:927](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L927)

***

### getTransaction()

```ts theme={null}
getTransaction(indexOrHash): Promise<TransactionResponse | ExternalTransactionResponse>
```

Get the transaction at `index` within this block.

#### Parameters

| Parameter     | Type                 | Description                           |
| :------------ | :------------------- | :------------------------------------ |
| `indexOrHash` | `string` \| `number` | The index or hash of the transaction. |

#### Returns

`Promise`\<[`TransactionResponse`](/sdk/content/type-aliases/TransactionResponse) | `ExternalTransactionResponse`>

A promise resolving to the transaction.

#### Inherited from

[`Block`](/sdk/content/classes/Block).[`getTransaction`](/sdk/content/classes/Block#gettransaction)

#### Throws

If the transaction is not found.

#### Source

[providers/provider.ts:842](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L842)

***

### isMined()

```ts theme={null}
isMined(): this is MinedBlock
```

Returns true if this block been mined. This provides a type guard for all properties on a
[**MinedBlock**](/sdk/content/interfaces/MinedBlock).

#### Returns

`this is MinedBlock`

True if the block has been mined.

#### Inherited from

[`Block`](/sdk/content/classes/Block).[`isMined`](/sdk/content/classes/Block#ismined)

#### Source

[providers/provider.ts:949](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L949)

***

### toJSON()

```ts theme={null}
toJSON(): BlockParams
```

Returns a JSON-friendly value.

#### Returns

[`BlockParams`](/sdk/content/interfaces/BlockParams)

The JSON-friendly value.

#### Inherited from

[`Block`](/sdk/content/classes/Block).[`toJSON`](/sdk/content/classes/Block#tojson)

#### Source

[providers/provider.ts:763](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L763)


# MissingArgumentError
Source: https://docs.qu.ai/sdk/content/interfaces/MissingArgumentError



This Error indicates there were too few arguments were provided.

## Extends

* [`quaisError`](/sdk/content/interfaces/quaisError)\<`"MISSING_ARGUMENT"`>

## Properties

| Property        | Type                                               | Description                                                                                                                    | Inherited from                                                    |
| :-------------- | :------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------- |
| `code`          | [`ErrorCode`](/sdk/content/type-aliases/ErrorCode) | The string error code.                                                                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`code`         |
| `count`         | `number`                                           | The number of arguments received.                                                                                              | -                                                                 |
| `error?`        | `Error`                                            | Any related error.                                                                                                             | [`quaisError`](/sdk/content/interfaces/quaisError).`error`        |
| `expectedCount` | `number`                                           | The number of arguments expected.                                                                                              | -                                                                 |
| `info?`         | `Record`\<`string`, `any`>                         | Additional info regarding the error that may be useful.<br /><br />This is generally helpful mostly for human-based debugging. | [`quaisError`](/sdk/content/interfaces/quaisError).`info`         |
| `shortMessage`  | `string`                                           | A short message describing the error, with minimal additional details.                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`shortMessage` |


# NetworkError
Source: https://docs.qu.ai/sdk/content/interfaces/NetworkError



This Error indicates a problem connecting to a network.

## Extends

* [`quaisError`](/sdk/content/interfaces/quaisError)\<`"NETWORK_ERROR"`>

## Properties

| Property       | Type                                               | Description                                                                                                                    | Inherited from                                                    |
| :------------- | :------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------- |
| `code`         | [`ErrorCode`](/sdk/content/type-aliases/ErrorCode) | The string error code.                                                                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`code`         |
| `error?`       | `Error`                                            | Any related error.                                                                                                             | [`quaisError`](/sdk/content/interfaces/quaisError).`error`        |
| `event`        | `string`                                           | The network event.                                                                                                             | -                                                                 |
| `info?`        | `Record`\<`string`, `any`>                         | Additional info regarding the error that may be useful.<br /><br />This is generally helpful mostly for human-based debugging. | [`quaisError`](/sdk/content/interfaces/quaisError).`info`         |
| `shortMessage` | `string`                                           | A short message describing the error, with minimal additional details.                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`shortMessage` |


# NeuteredAddressInfo
Source: https://docs.qu.ai/sdk/content/interfaces/NeuteredAddressInfo



Interface representing information about a neutered address.

## Extended by

* [`QiAddressInfo`](/sdk/content/interfaces/QiAddressInfo)


# NonceExpiredError
Source: https://docs.qu.ai/sdk/content/interfaces/NonceExpiredError



The sending account has already used this nonce in a transaction that has been included.

## Extends

* [`quaisError`](/sdk/content/interfaces/quaisError)\<`"NONCE_EXPIRED"`>

## Properties

| Property       | Type                                                                 | Description                                                                                                                    | Inherited from                                                    |
| :------------- | :------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------- |
| `code`         | [`ErrorCode`](/sdk/content/type-aliases/ErrorCode)                   | The string error code.                                                                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`code`         |
| `error?`       | `Error`                                                              | Any related error.                                                                                                             | [`quaisError`](/sdk/content/interfaces/quaisError).`error`        |
| `info?`        | `Record`\<`string`, `any`>                                           | Additional info regarding the error that may be useful.<br /><br />This is generally helpful mostly for human-based debugging. | [`quaisError`](/sdk/content/interfaces/quaisError).`info`         |
| `shortMessage` | `string`                                                             | A short message describing the error, with minimal additional details.                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`shortMessage` |
| `transaction`  | [`TransactionRequest`](/sdk/content/type-aliases/TransactionRequest) | The transaction.                                                                                                               | -                                                                 |


# OutpointInfo
Source: https://docs.qu.ai/sdk/content/interfaces/OutpointInfo





# Provider
Source: https://docs.qu.ai/sdk/content/interfaces/Provider



A **Provider** is the primary method to interact with the read-only content on Ethereum.

It allows access to details about accounts, blocks and transactions and the ability to query event logs and simulate
contract execution.

Account data includes the [**balance**](/sdk/content/interfaces/Provider#getbalance),
[**getTransactionCount**](/sdk/content/interfaces/Provider#gettransactioncount), [**code**](/sdk/content/interfaces/Provider#getcode) and
[**state trie storage**](/sdk/content/interfaces/Provider#getstorage).

Simulating execution can be used to [**call**](/sdk/content/interfaces/Provider#call), [**estimateGas**](/sdk/content/interfaces/Provider#estimategas)
and [**get transaction result**](/sdk/content/interfaces/Provider#gettransactionresult).

The [**broadcastTransaction**](/sdk/content/interfaces/Provider#broadcasttransaction) is the only method which allows updating the
blockchain, but it is usually accessed by a [Signer](../interfaces/Signer), since a private key must be used to sign
the transaction before it can be broadcast.

## Extends

* [`ContractRunner`](/sdk/content/interfaces/ContractRunner).[`EventEmitterable`](/sdk/content/interfaces/EventEmitterable)\<[`ProviderEvent`](/sdk/content/type-aliases/ProviderEvent)>

## Properties

| Property           | Type                                                                                                                                                               | Description                                                                                                                                                                                                                                                            | Overrides                                                                    | Inherited from                                                               |
| :----------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------- | :--------------------------------------------------------------------------- |
| `provider`         | [`Provider`](/sdk/content/interfaces/Provider)                                                                                                                     | The provider iteself.<br /><br />This is part of the necessary API for executing a contract, as it provides a common property on any<br />[**ContractRunner**](/sdk/content/interfaces/ContractRunner) that can be used to access the read-only portion of the runner. | [`ContractRunner`](/sdk/content/interfaces/ContractRunner).`provider`        | [`ContractRunner`](/sdk/content/interfaces/ContractRunner).`provider`        |
| `sendTransaction?` | (`tx`: [`TransactionRequest`](/sdk/content/type-aliases/TransactionRequest)) => `Promise`\<[`TransactionResponse`](/sdk/content/type-aliases/TransactionResponse)> | Required for state mutating calls                                                                                                                                                                                                                                      | [`ContractRunner`](/sdk/content/interfaces/ContractRunner).`sendTransaction` | [`ContractRunner`](/sdk/content/interfaces/ContractRunner).`sendTransaction` |

## Methods

### addListener()

```ts theme={null}
addListener(
   event, 
   listener, 
zone?): Promise<Provider>
```

Alias for [**on**](/sdk/content/interfaces/EventEmitterable#on).

#### Parameters

| Parameter  | Type                                                       |
| :--------- | :--------------------------------------------------------- |
| `event`    | [`ProviderEvent`](/sdk/content/type-aliases/ProviderEvent) |
| `listener` | [`Listener`](/sdk/content/type-aliases/Listener)           |
| `zone`?    | [`Zone`](/sdk/content/enumerations/Zone)                   |

#### Returns

`Promise`\<[`Provider`](/sdk/content/interfaces/Provider)>

#### Inherited from

[`EventEmitterable`](/sdk/content/interfaces/EventEmitterable).[`addListener`](/sdk/content/interfaces/EventEmitterable#addlistener)

#### Source

[utils/events.ts:61](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/events.ts#L61)

***

### broadcastTransaction()

```ts theme={null}
broadcastTransaction(
   zone, 
   signedTx, 
from?): Promise<TransactionResponse>
```

Broadcasts the `signedTx` to the network, adding it to the memory pool of any node for which the transaction
meets the rebroadcast requirements.

#### Parameters

| Parameter  | Type                                                   | Description                               |
| :--------- | :----------------------------------------------------- | :---------------------------------------- |
| `zone`     | [`Zone`](/sdk/content/enumerations/Zone)               | The zone to broadcast the transaction to. |
| `signedTx` | `string`                                               | The signed transaction to broadcast.      |
| `from`?    | [`AddressLike`](/sdk/content/type-aliases/AddressLike) | The address that signed the transaction.  |

#### Returns

`Promise`\<[`TransactionResponse`](/sdk/content/type-aliases/TransactionResponse)>

A promise resolving to the transaction response.

#### Throws

If the transaction is invalid or the transaction is replaced.

#### Source

[providers/provider.ts:2900](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2900)

***

### calculateConversionAmount()

#### calculateConversionAmount(from, to, value)

```ts theme={null}
calculateConversionAmount(
   from, 
   to, 
value): Promise<bigint>
```

Calculate the conversion amount between two addresses from different ledgers.

##### Parameters

| Parameter | Type                                                     | Description             |
| :-------- | :------------------------------------------------------- | :---------------------- |
| `from`    | `string`                                                 | The source address      |
| `to`      | `string`                                                 | The destination address |
| `value`   | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The amount to convert   |

##### Returns

`Promise`\<`bigint`>

A promise resolving to the converted amount

##### Source

[providers/provider.ts:3047](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L3047)

#### calculateConversionAmount(transactionArgs)

```ts theme={null}
calculateConversionAmount(transactionArgs): Promise<bigint>
```

Calculate the conversion amount between two addresses from different ledgers.

##### Parameters

| Parameter         | Type                           | Description                                              |
| :---------------- | :----------------------------- | :------------------------------------------------------- |
| `transactionArgs` | `ConversionTransactionRequest` | The transaction arguments containing from, to, and value |

##### Returns

`Promise`\<`bigint`>

A promise resolving to the converted amount

##### Source

[providers/provider.ts:3055](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L3055)

***

### call()

```ts theme={null}
call(tx): Promise<string>
```

Simulate the execution of `tx`. If the call reverts, it will throw a
[CallExceptionError](../interfaces/CallExceptionError) which includes the revert data.

#### Parameters

| Parameter | Type                                                                 | Description                  |
| :-------- | :------------------------------------------------------------------- | :--------------------------- |
| `tx`      | [`TransactionRequest`](/sdk/content/type-aliases/TransactionRequest) | The transaction to simulate. |

#### Returns

`Promise`\<`string`>

A promise resolving to the result of the execution.

#### Overrides

`ContractRunner.call`

#### Throws

If the transaction execution reverts.

#### Source

[providers/provider.ts:2888](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2888)

***

### createAccessList()

```ts theme={null}
createAccessList(tx): Promise<AccessList>
```

Required for populating access lists for state mutating calls

#### Parameters

| Parameter | Type                     | Description |
| :-------- | :----------------------- | :---------- |
| `tx`      | `QuaiTransactionRequest` |             |

#### Returns

`Promise`\<[`AccessList`](/sdk/content/type-aliases/AccessList)>

#### Overrides

`ContractRunner.createAccessList`

#### Source

[providers/provider.ts:2878](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2878)

***

### destroy()

```ts theme={null}
destroy(): void
```

Shutdown any resources this provider is using. No additional calls should be made to this provider after calling
this.

#### Returns

`void`

#### Source

[providers/provider.ts:2746](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2746)

***

### emit()

```ts theme={null}
emit(
   event, 
   zone?, ...
args?): Promise<boolean>
```

Triggers each listener for `event` with the `args`.

#### Parameters

| Parameter  | Type                                                       |
| :--------- | :--------------------------------------------------------- |
| `event`    | [`ProviderEvent`](/sdk/content/type-aliases/ProviderEvent) |
| `zone`?    | [`Zone`](/sdk/content/enumerations/Zone)                   |
| ...`args`? | `any`\[]                                                   |

#### Returns

`Promise`\<`boolean`>

#### Inherited from

[`EventEmitterable`](/sdk/content/interfaces/EventEmitterable).[`emit`](/sdk/content/interfaces/EventEmitterable#emit)

#### Source

[utils/events.ts:36](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/events.ts#L36)

***

### estimateFeeForQi()

```ts theme={null}
estimateFeeForQi(tx): Promise<bigint>
```

Estimate the fee for a Qi transaction.

#### Parameters

| Parameter | Type                         | Description                              |
| :-------- | :--------------------------- | :--------------------------------------- |
| `tx`      | `QiPerformActionTransaction` | The transaction to estimate the fee for. |

#### Returns

`Promise`\<`bigint`>

A promise resolving to the estimated fee.

#### Source

[providers/provider.ts:2870](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2870)

***

### estimateGas()

```ts theme={null}
estimateGas(tx): Promise<bigint>
```

Estimates the amount of gas required to executre `tx`.

#### Parameters

| Parameter | Type                                                                 | Description                              |
| :-------- | :------------------------------------------------------------------- | :--------------------------------------- |
| `tx`      | [`TransactionRequest`](/sdk/content/type-aliases/TransactionRequest) | The transaction to estimate the gas for. |

#### Returns

`Promise`\<`bigint`>

A promise resolving to the estimated gas.

#### Overrides

`ContractRunner.estimateGas`

#### Throws

If the transaction execution reverts.

#### Source

[providers/provider.ts:2862](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2862)

***

### getBalance()

```ts theme={null}
getBalance(address, blockTag?): Promise<bigint>
```

Get the account balance (in wei) of `address`. If `blockTag` is specified and the node supports archive access
for that `blockTag`, the balance is as of that [**BlockTag**](/sdk/content/type-aliases/BlockTag).

#### Parameters

| Parameter   | Type                                                   | Description                              |
| :---------- | :----------------------------------------------------- | :--------------------------------------- |
| `address`   | [`AddressLike`](/sdk/content/type-aliases/AddressLike) | The address to fetch the balance for.    |
| `blockTag`? | [`BlockTag`](/sdk/content/type-aliases/BlockTag)       | The block tag to fetch the balance from. |

#### Returns

`Promise`\<`bigint`>

A promise resolving to the balance.

#### Note

On nodes without archive access enabled, the `blockTag` may be
**silently ignored** by the node, which may cause issues if relied on.

#### Source

[providers/provider.ts:2796](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2796)

***

### getBlock()

```ts theme={null}
getBlock(
   shard, 
   blockHashOrBlockTag, 
prefetchTxs?): Promise<null | Block>
```

Resolves to the block for `blockHashOrBlockTag`.

If `prefetchTxs`, and the backend supports including transactions with block requests, all transactions will be
included and the [**Block**](/sdk/content/classes/Block) object will not need to make remote calls for getting transactions.

#### Parameters

| Parameter             | Type                                             | Description                           |
| :-------------------- | :----------------------------------------------- | :------------------------------------ |
| `shard`               | [`Shard`](/sdk/content/enumerations/Shard)       | The shard to fetch the block from.    |
| `blockHashOrBlockTag` | [`BlockTag`](/sdk/content/type-aliases/BlockTag) | The block hash or block tag to fetch. |
| `prefetchTxs`?        | `boolean`                                        | If true, prefetch the transactions.   |

#### Returns

`Promise`\<`null` | [`Block`](/sdk/content/classes/Block)>

A promise resolving to the block or null if not found.

#### Throws

If the block is not found.

#### Source

[providers/provider.ts:2917](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2917)

***

### getBlockNumber()

```ts theme={null}
getBlockNumber(shard): Promise<number>
```

Get the current block number.

#### Parameters

| Parameter | Type                                       | Description                               |
| :-------- | :----------------------------------------- | :---------------------------------------- |
| `shard`   | [`Shard`](/sdk/content/enumerations/Shard) | The shard to fetch the block number from. |

#### Returns

`Promise`\<`number`>

A promise resolving to the block number.

#### Source

[providers/provider.ts:2757](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2757)

***

### getCode()

```ts theme={null}
getCode(address, blockTag?): Promise<string>
```

Get the bytecode for `address`.

#### Parameters

| Parameter   | Type                                                   | Description                           |
| :---------- | :----------------------------------------------------- | :------------------------------------ |
| `address`   | [`AddressLike`](/sdk/content/type-aliases/AddressLike) | The address to fetch the code for.    |
| `blockTag`? | [`BlockTag`](/sdk/content/type-aliases/BlockTag)       | The block tag to fetch the code from. |

#### Returns

`Promise`\<`string`>

A promise resolving to the code stored at the address.

#### Note

On nodes without archive access enabled, the `blockTag` may be
**silently ignored** by the node, which may cause issues if relied on.

#### Source

[providers/provider.ts:2838](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2838)

***

### getFeeData()

```ts theme={null}
getFeeData(zone, txType): Promise<FeeData>
```

Get the best guess at the recommended [**FeeData**](/sdk/content/classes/FeeData).

#### Parameters

| Parameter | Type                                     | Description                                                                  |
| :-------- | :--------------------------------------- | :--------------------------------------------------------------------------- |
| `zone`    | [`Zone`](/sdk/content/enumerations/Zone) | The shard to fetch the fee data from.                                        |
| `txType`  | `boolean`                                | The transaction type to fetch the fee data for (true for Quai, false for Qi) |

#### Returns

`Promise`\<[`FeeData`](/sdk/content/classes/FeeData)>

A promise resolving to the fee data.

#### Source

[providers/provider.ts:2774](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2774)

***

### getLatestQiToQuaiRate()

```ts theme={null}
getLatestQiToQuaiRate(zone, amt): Promise<bigint>
```

Resolves to the current Quai rate for the given amount.

#### Parameters

| Parameter | Type                                     | Description                              |
| :-------- | :--------------------------------------- | :--------------------------------------- |
| `zone`    | [`Zone`](/sdk/content/enumerations/Zone) | -                                        |
| `amt`     | `bigint`                                 | The amount in quais to get the rate for. |

#### Returns

`Promise`\<`bigint`>

A promise resolving to the latest Quai rate.

#### Source

[providers/provider.ts:3019](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L3019)

***

### getLatestQuaiToQiRate()

```ts theme={null}
getLatestQuaiToQiRate(zone, amt): Promise<bigint>
```

Resolves to the current Quai rate for the given amount.

#### Parameters

| Parameter | Type                                     | Description                             |
| :-------- | :--------------------------------------- | :-------------------------------------- |
| `zone`    | [`Zone`](/sdk/content/enumerations/Zone) | -                                       |
| `amt`     | `bigint`                                 | The amount in quai to get the rate for. |

#### Returns

`Promise`\<`bigint`>

A promise resolving to the latest Quai->Qi rate.

#### Source

[providers/provider.ts:3035](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L3035)

***

### getLockedBalance()

```ts theme={null}
getLockedBalance(address): Promise<bigint>
```

Get the locked balance for `address`.

#### Parameters

| Parameter | Type                                                   | Description                                  |
| :-------- | :----------------------------------------------------- | :------------------------------------------- |
| `address` | [`AddressLike`](/sdk/content/type-aliases/AddressLike) | The address to fetch the locked balance for. |

#### Returns

`Promise`\<`bigint`>

A promise resolving to the locked balance.

#### Source

[providers/provider.ts:2804](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2804)

***

### getLogs()

```ts theme={null}
getLogs(filter): Promise<Log[]>
```

Resolves to the list of Logs that match `filter`

#### Parameters

| Parameter | Type                                                                                                           | Description          |
| :-------- | :------------------------------------------------------------------------------------------------------------- | :------------------- |
| `filter`  | [`Filter`](/sdk/content/interfaces/Filter) \| [`FilterByBlockHash`](/sdk/content/interfaces/FilterByBlockHash) | The filter to apply. |

#### Returns

`Promise`\<[`Log`](/sdk/content/classes/Log)\[]>

A promise resolving to the logs.

#### Source

[providers/provider.ts:2960](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2960)

***

### getNetwork()

```ts theme={null}
getNetwork(): Promise<Network>
```

Get the connected [**Network**](/sdk/content/classes/Network).

#### Returns

`Promise`\<[`Network`](/sdk/content/classes/Network)>

A promise resolving to the network.

#### Source

[providers/provider.ts:2765](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2765)

***

### getOutpointsByAddress()

```ts theme={null}
getOutpointsByAddress(address): Promise<Outpoint[]>
```

Get the UTXO entries for `address`.

#### Parameters

| Parameter | Type                                                   | Description                                |
| :-------- | :----------------------------------------------------- | :----------------------------------------- |
| `address` | [`AddressLike`](/sdk/content/type-aliases/AddressLike) | The address to fetch the UTXO entries for. |

#### Returns

`Promise`\<`Outpoint`\[]>

A promise resolving to the UTXO entries.

#### Note

On nodes without archive access enabled, the `blockTag` may be
**silently ignored** by the node, which may cause issues if relied on.

#### Source

[providers/provider.ts:2814](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2814)

***

### getPendingHeader()

```ts theme={null}
getPendingHeader(): Promise<WorkObjectLike>
```

Get a work object to package a transaction in.

#### Returns

`Promise`\<`WorkObjectLike`>

A promise resolving to the work object.

#### Source

[providers/provider.ts:2781](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2781)

***

### getProtocolExpansionNumber()

```ts theme={null}
getProtocolExpansionNumber(): Promise<number>
```

Resolves to the number indicating the size of the network

#### Returns

`Promise`\<`number`>

A promise resolving to the current network size.

#### Source

[providers/provider.ts:2989](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2989)

***

### getQiToQuaiRateAtBlock()

```ts theme={null}
getQiToQuaiRateAtBlock(
   zone, 
   blockTag, 
amt): Promise<bigint>
```

Resolves to the current Quai rate for the given amount.

#### Parameters

| Parameter  | Type                                             | Description                              |
| :--------- | :----------------------------------------------- | :--------------------------------------- |
| `zone`     | [`Zone`](/sdk/content/enumerations/Zone)         | -                                        |
| `blockTag` | [`BlockTag`](/sdk/content/type-aliases/BlockTag) | -                                        |
| `amt`      | `bigint`                                         | The amount in quais to get the rate for. |

#### Returns

`Promise`\<`bigint`>

A promise resolving to the latest Quai rate.

#### Source

[providers/provider.ts:3011](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L3011)

***

### getQuaiToQiRateAtBlock()

```ts theme={null}
getQuaiToQiRateAtBlock(
   zone, 
   blockTag, 
amt): Promise<bigint>
```

Resolves to the current Quai rate for the given amount.

#### Parameters

| Parameter  | Type                                             | Description                              |
| :--------- | :----------------------------------------------- | :--------------------------------------- |
| `zone`     | [`Zone`](/sdk/content/enumerations/Zone)         | -                                        |
| `blockTag` | [`BlockTag`](/sdk/content/type-aliases/BlockTag) | -                                        |
| `amt`      | `bigint`                                         | The amount in quais to get the rate for. |

#### Returns

`Promise`\<`bigint`>

A promise resolving to the latest Quai rate.

#### Source

[providers/provider.ts:3027](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L3027)

***

### getStorage()

```ts theme={null}
getStorage(
   address, 
   position, 
blockTag?): Promise<string>
```

Get the storage slot value for `address` at slot `position`.

#### Parameters

| Parameter   | Type                                                     | Description                              |
| :---------- | :------------------------------------------------------- | :--------------------------------------- |
| `address`   | [`AddressLike`](/sdk/content/type-aliases/AddressLike)   | The address to fetch the storage from.   |
| `position`  | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The position to fetch the storage from.  |
| `blockTag`? | [`BlockTag`](/sdk/content/type-aliases/BlockTag)         | The block tag to fetch the storage from. |

#### Returns

`Promise`\<`string`>

A promise resolving to the storage value.

#### Note

On nodes without archive access enabled, the `blockTag` may be
**silently ignored** by the node, which may cause issues if relied on.

#### Source

[providers/provider.ts:2850](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2850)

***

### getTransaction()

```ts theme={null}
getTransaction(hash): Promise<null | TransactionResponse | ExternalTransactionResponse>
```

Resolves to the transaction for `hash`.

If the transaction is unknown or on pruning nodes which discard old transactions this resolves to `null`.

#### Parameters

| Parameter | Type     | Description                    |
| :-------- | :------- | :----------------------------- |
| `hash`    | `string` | The transaction hash to fetch. |

#### Returns

`Promise`\<`null` | [`TransactionResponse`](/sdk/content/type-aliases/TransactionResponse) | `ExternalTransactionResponse`>

A promise resolving to the transaction or null if not found.

#### Source

[providers/provider.ts:2927](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2927)

***

### getTransactionCount()

```ts theme={null}
getTransactionCount(address, blockTag?): Promise<number>
```

Get the number of transactions ever sent for `address`, which is used as the `nonce` when sending a transaction.
If `blockTag` is specified and the node supports archive access for that `blockTag`, the transaction count is as
of that [**BlockTag**](/sdk/content/type-aliases/BlockTag).

#### Parameters

| Parameter   | Type                                                   | Description                                        |
| :---------- | :----------------------------------------------------- | :------------------------------------------------- |
| `address`   | [`AddressLike`](/sdk/content/type-aliases/AddressLike) | The address to fetch the transaction count for.    |
| `blockTag`? | [`BlockTag`](/sdk/content/type-aliases/BlockTag)       | The block tag to fetch the transaction count from. |

#### Returns

`Promise`\<`number`>

A promise resolving to the transaction count.

#### Note

On nodes without archive access enabled, the `blockTag` may be
**silently ignored** by the node, which may cause issues if relied on.

#### Source

[providers/provider.ts:2827](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2827)

***

### getTransactionReceipt()

```ts theme={null}
getTransactionReceipt(hash): Promise<null | TransactionReceipt>
```

Resolves to the transaction receipt for `hash`, if mined.

If the transaction has not been mined, is unknown or on pruning nodes which discard old transactions this
resolves to `null`.

#### Parameters

| Parameter | Type     | Description                                    |
| :-------- | :------- | :--------------------------------------------- |
| `hash`    | `string` | The transaction hash to fetch the receipt for. |

#### Returns

`Promise`\<`null` | [`TransactionReceipt`](/sdk/content/classes/TransactionReceipt)>

A promise resolving to the transaction receipt or null if not
found.

#### Source

[providers/provider.ts:2939](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2939)

***

### getTransactionResult()

```ts theme={null}
getTransactionResult(hash): Promise<null | string>
```

Resolves to the result returned by the executions of `hash`.

This is only supported on nodes with archive access and with the necessary debug APIs enabled.

#### Parameters

| Parameter | Type     | Description                                   |
| :-------- | :------- | :-------------------------------------------- |
| `hash`    | `string` | The transaction hash to fetch the result for. |

#### Returns

`Promise`\<`null` | `string`>

A promise resolving to the result or null if not found.

#### Source

[providers/provider.ts:2949](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2949)

***

### getTxPoolContent()

```ts theme={null}
getTxPoolContent(zone): Promise<txpoolContentResponse>
```

Resolves to the current content of the transaction pool.

#### Parameters

| Parameter | Type                                     |
| :-------- | :--------------------------------------- |
| `zone`    | [`Zone`](/sdk/content/enumerations/Zone) |

#### Returns

`Promise`\<`txpoolContentResponse`>

A promise resolving to the transaction pool content.

#### Source

[providers/provider.ts:2996](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2996)

***

### listenerCount()

```ts theme={null}
listenerCount(event?): Promise<number>
```

Resolves to the number of listeners for `event`.

#### Parameters

| Parameter | Type                                                       |
| :-------- | :--------------------------------------------------------- |
| `event`?  | [`ProviderEvent`](/sdk/content/type-aliases/ProviderEvent) |

#### Returns

`Promise`\<`number`>

#### Inherited from

[`EventEmitterable`](/sdk/content/interfaces/EventEmitterable).[`listenerCount`](/sdk/content/interfaces/EventEmitterable#listenercount)

#### Source

[utils/events.ts:41](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/events.ts#L41)

***

### listeners()

```ts theme={null}
listeners(event?): Promise<Listener[]>
```

Resolves to the listeners for `event`.

#### Parameters

| Parameter | Type                                                       |
| :-------- | :--------------------------------------------------------- |
| `event`?  | [`ProviderEvent`](/sdk/content/type-aliases/ProviderEvent) |

#### Returns

`Promise`\<[`Listener`](/sdk/content/type-aliases/Listener)\[]>

#### Inherited from

[`EventEmitterable`](/sdk/content/interfaces/EventEmitterable).[`listeners`](/sdk/content/interfaces/EventEmitterable#listeners)

#### Source

[utils/events.ts:46](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/events.ts#L46)

***

### off()

```ts theme={null}
off(
   event, 
   listener?, 
zone?): Promise<Provider>
```

Unregister the `listener` for `event`. If `listener` is unspecified, all listeners are unregistered.

#### Parameters

| Parameter   | Type                                                       |
| :---------- | :--------------------------------------------------------- |
| `event`     | [`ProviderEvent`](/sdk/content/type-aliases/ProviderEvent) |
| `listener`? | [`Listener`](/sdk/content/type-aliases/Listener)           |
| `zone`?     | [`Zone`](/sdk/content/enumerations/Zone)                   |

#### Returns

`Promise`\<[`Provider`](/sdk/content/interfaces/Provider)>

#### Inherited from

[`EventEmitterable`](/sdk/content/interfaces/EventEmitterable).[`off`](/sdk/content/interfaces/EventEmitterable#off)

#### Source

[utils/events.ts:51](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/events.ts#L51)

***

### on()

```ts theme={null}
on(
   event, 
   listener, 
zone?): Promise<Provider>
```

Registers a `listener` that is called whenever the `event` occurs until unregistered.

#### Parameters

| Parameter  | Type                                                       |
| :--------- | :--------------------------------------------------------- |
| `event`    | [`ProviderEvent`](/sdk/content/type-aliases/ProviderEvent) |
| `listener` | [`Listener`](/sdk/content/type-aliases/Listener)           |
| `zone`?    | [`Zone`](/sdk/content/enumerations/Zone)                   |

#### Returns

`Promise`\<[`Provider`](/sdk/content/interfaces/Provider)>

#### Inherited from

[`EventEmitterable`](/sdk/content/interfaces/EventEmitterable).[`on`](/sdk/content/interfaces/EventEmitterable#on)

#### Source

[utils/events.ts:26](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/events.ts#L26)

***

### once()

```ts theme={null}
once(
   event, 
   listener, 
zone?): Promise<Provider>
```

Registers a `listener` that is called the next time `event` occurs.

#### Parameters

| Parameter  | Type                                                       |
| :--------- | :--------------------------------------------------------- |
| `event`    | [`ProviderEvent`](/sdk/content/type-aliases/ProviderEvent) |
| `listener` | [`Listener`](/sdk/content/type-aliases/Listener)           |
| `zone`?    | [`Zone`](/sdk/content/enumerations/Zone)                   |

#### Returns

`Promise`\<[`Provider`](/sdk/content/interfaces/Provider)>

#### Inherited from

[`EventEmitterable`](/sdk/content/interfaces/EventEmitterable).[`once`](/sdk/content/interfaces/EventEmitterable#once)

#### Source

[utils/events.ts:31](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/events.ts#L31)

***

### removeAllListeners()

```ts theme={null}
removeAllListeners(event?): Promise<Provider>
```

Unregister all listeners for `event`.

#### Parameters

| Parameter | Type                                                       |
| :-------- | :--------------------------------------------------------- |
| `event`?  | [`ProviderEvent`](/sdk/content/type-aliases/ProviderEvent) |

#### Returns

`Promise`\<[`Provider`](/sdk/content/interfaces/Provider)>

#### Inherited from

[`EventEmitterable`](/sdk/content/interfaces/EventEmitterable).[`removeAllListeners`](/sdk/content/interfaces/EventEmitterable#removealllisteners)

#### Source

[utils/events.ts:56](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/events.ts#L56)

***

### removeListener()

```ts theme={null}
removeListener(
   event, 
   listener, 
zone?): Promise<Provider>
```

Alias for [**off**](/sdk/content/interfaces/EventEmitterable#off).

#### Parameters

| Parameter  | Type                                                       |
| :--------- | :--------------------------------------------------------- |
| `event`    | [`ProviderEvent`](/sdk/content/type-aliases/ProviderEvent) |
| `listener` | [`Listener`](/sdk/content/type-aliases/Listener)           |
| `zone`?    | [`Zone`](/sdk/content/enumerations/Zone)                   |

#### Returns

`Promise`\<[`Provider`](/sdk/content/interfaces/Provider)>

#### Inherited from

[`EventEmitterable`](/sdk/content/interfaces/EventEmitterable).[`removeListener`](/sdk/content/interfaces/EventEmitterable#removelistener)

#### Source

[utils/events.ts:66](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/events.ts#L66)

***

### txPoolInspect()

```ts theme={null}
txPoolInspect(zone): Promise<txpoolInspectResponse>
```

Resolves to the current content of the transaction pool.

#### Parameters

| Parameter | Type                                     |
| :-------- | :--------------------------------------- |
| `zone`    | [`Zone`](/sdk/content/enumerations/Zone) |

#### Returns

`Promise`\<`txpoolInspectResponse`>

A promise resolving to the transaction pool inspect.

#### Source

[providers/provider.ts:3003](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L3003)

***

### waitForBlock()

```ts theme={null}
waitForBlock(shard, blockTag?): Promise<Block>
```

Resolves to the block at `blockTag` once it has been mined.

This can be useful for waiting some number of blocks by using the `currentBlockNumber + N`.

#### Parameters

| Parameter   | Type                                             | Description                        |
| :---------- | :----------------------------------------------- | :--------------------------------- |
| `shard`     | [`Shard`](/sdk/content/enumerations/Shard)       | The shard to fetch the block from. |
| `blockTag`? | [`BlockTag`](/sdk/content/type-aliases/BlockTag) | The block tag to fetch.            |

#### Returns

`Promise`\<[`Block`](/sdk/content/classes/Block)>

A promise resolving to the block.

#### Source

[providers/provider.ts:2982](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2982)

***

### waitForTransaction()

```ts theme={null}
waitForTransaction(
   hash, 
   confirms?, 
timeout?): Promise<null | TransactionReceipt>
```

Waits until the transaction `hash` is mined and has `confirms` confirmations.

#### Parameters

| Parameter   | Type     | Description                                           |
| :---------- | :------- | :---------------------------------------------------- |
| `hash`      | `string` | The transaction hash to wait for.                     |
| `confirms`? | `number` | The number of confirmations to wait for.              |
| `timeout`?  | `number` | The number of milliseconds to wait before timing out. |

#### Returns

`Promise`\<`null` | [`TransactionReceipt`](/sdk/content/classes/TransactionReceipt)>

A promise resolving to the transaction receipt or null if not
found.

#### Source

[providers/provider.ts:2971](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2971)


# QiAddressInfo
Source: https://docs.qu.ai/sdk/content/interfaces/QiAddressInfo



Interface representing an address in the Qi HD wallet.

## Extends

* [`NeuteredAddressInfo`](/sdk/content/interfaces/NeuteredAddressInfo)


# SerializedHDWallet
Source: https://docs.qu.ai/sdk/content/interfaces/SerializedHDWallet



Interface representing the serialized state of an HD wallet.

## Extended by

* [`SerializedQiHDWallet`](/sdk/content/interfaces/SerializedQiHDWallet)


# SerializedQiHDWallet
Source: https://docs.qu.ai/sdk/content/interfaces/SerializedQiHDWallet



## Extends

* [`SerializedHDWallet`](/sdk/content/interfaces/SerializedHDWallet)


# Signer
Source: https://docs.qu.ai/sdk/content/interfaces/Signer



A Signer represents an account on the Ethereum Blockchain, and is most often backed by a private key represented by a
mnemonic or residing on a Hardware Wallet.

The API remains abstract though, so that it can deal with more advanced exotic Signing entities, such as Smart
Contract Wallets or Virtual Wallets (where the private key may not be known).

## Extends

* [`Addressable`](/sdk/content/interfaces/Addressable).[`ContractRunner`](/sdk/content/interfaces/ContractRunner)

## Properties

| Property   | Type                                                     | Description                                                                            | Overrides                                                             |
| :--------- | :------------------------------------------------------- | :------------------------------------------------------------------------------------- | :-------------------------------------------------------------------- |
| `provider` | `null` \| [`Provider`](/sdk/content/interfaces/Provider) | The [**Provider**](/sdk/content/interfaces/Provider) attached to this Signer (if any). | [`ContractRunner`](/sdk/content/interfaces/ContractRunner).`provider` |

## Methods

### call()

```ts theme={null}
call(tx): Promise<string>
```

Evaluates th tx by running it against the current Blockchain state. This cannot change state and has no cost in
ether, as it is effectively simulating execution.

This can be used to have the Blockchain perform computations based on its state (e.g. running a Contract's
getters) or to simulate the effect of a transaction before actually performing an operation.

#### Parameters

| Parameter | Type                                                                 | Description              |
| :-------- | :------------------------------------------------------------------- | :----------------------- |
| `tx`      | [`TransactionRequest`](/sdk/content/type-aliases/TransactionRequest) | The transaction to call. |

#### Returns

`Promise`\<`string`>

A promise resolving to the result of the call.

#### Overrides

`ContractRunner.call`

#### Source

[signers/signer.ts:124](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/signers/signer.ts#L124)

***

### connect()

```ts theme={null}
connect(provider): Signer
```

Returns a new instance of this Signer connected to provider or detached from any Provider if null.

#### Parameters

| Parameter  | Type                                                     | Description                 |
| :--------- | :------------------------------------------------------- | :-------------------------- |
| `provider` | `null` \| [`Provider`](/sdk/content/interfaces/Provider) | The Provider to connect to. |

#### Returns

[`Signer`](/sdk/content/interfaces/Signer)

A new instance of this Signer.

#### Throws

If the Signer cannot be connected to the Provider.

#### Source

[signers/signer.ts:31](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/signers/signer.ts#L31)

***

### createAccessList()

```ts theme={null}
createAccessList(tx): Promise<AccessList>
```

Creates an AccessList for the transaction. This is used to specify which addresses the transaction might touch.

#### Parameters

| Parameter | Type                                                                 | Description |
| :-------- | :------------------------------------------------------------------- | :---------- |
| `tx`      | [`TransactionRequest`](/sdk/content/type-aliases/TransactionRequest) |             |

#### Returns

`Promise`\<[`AccessList`](/sdk/content/type-aliases/AccessList)>

A promise resolving to the access list.

#### Overrides

`ContractRunner.createAccessList`

#### Source

[signers/signer.ts:112](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/signers/signer.ts#L112)

***

### estimateGas()

```ts theme={null}
estimateGas(tx): Promise<bigint>
```

Estimates the required gas required to execute tx on the Blockchain. This will be the expected amount a
transaction will require as its `gasLimit` to successfully run all the necessary computations and store the
needed state that the transaction intends.

Keep in mind that this is **best efforts**, since the state of the Blockchain is in flux, which could affect
transaction gas requirements.

#### Parameters

| Parameter | Type                                                                 | Description                          |
| :-------- | :------------------------------------------------------------------- | :----------------------------------- |
| `tx`      | [`TransactionRequest`](/sdk/content/type-aliases/TransactionRequest) | The transaction to estimate gas for. |

#### Returns

`Promise`\<`bigint`>

A promise resolving to the estimated gas.

#### Overrides

`ContractRunner.estimateGas`

#### Throws

UNPREDICTABLE\_GAS\_LIMIT A transaction that is believed by the node to likely fail will throw an error
during gas estimation. This could indicate that it will actually fail or that the circumstances are simply too
complex for the node to take into account. In these cases, a manually determined `gasLimit` will need to be
made.

#### Source

[signers/signer.ts:104](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/signers/signer.ts#L104)

***

### getAddress()

```ts theme={null}
getAddress(): Promise<string>
```

Get the address of the Signer.

#### Returns

`Promise`\<`string`>

The address of the Signer.

#### Overrides

[`Addressable`](/sdk/content/interfaces/Addressable).[`getAddress`](/sdk/content/interfaces/Addressable#getaddress)

#### Throws

If the Signer has no address.

#### Source

[signers/signer.ts:42](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/signers/signer.ts#L42)

***

### getNonce()

```ts theme={null}
getNonce(blockTag?): Promise<number>
```

Gets the next nonce required for this Signer to send a transaction.

#### Parameters

| Parameter   | Type                                             | Description                                                                                                                                          |
| :---------- | :----------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------- |
| `blockTag`? | [`BlockTag`](/sdk/content/type-aliases/BlockTag) | The blocktag to base the transaction count on, keep in mind many nodes do not honour this value<br />  and silently ignore it \[default: `"latest"`] |

#### Returns

`Promise`\<`number`>

The next nonce.

#### Source

[signers/signer.ts:51](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/signers/signer.ts#L51)

***

### populateCall()

```ts theme={null}
populateCall(tx): Promise<TransactionLike>
```

Prepares a [TransactionRequest](/sdk/content/type-aliases/TransactionRequest) for calling:

* Resolves `to` and `from` addresses
* If `from` is specified , check that it matches this Signer

#### Parameters

| Parameter | Type                                                                 | Description         |
| :-------- | :------------------------------------------------------------------- | :------------------ |
| `tx`      | [`TransactionRequest`](/sdk/content/type-aliases/TransactionRequest) | The call to prepare |

#### Returns

`Promise`\<[`TransactionLike`](/sdk/content/interfaces/TransactionLike)>

A promise resolving to the prepared transaction.

#### Source

[signers/signer.ts:65](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/signers/signer.ts#L65)

***

### populateQuaiTransaction()

```ts theme={null}
populateQuaiTransaction(tx): Promise<TransactionLike>
```

Prepares a [TransactionRequest](/sdk/content/type-aliases/TransactionRequest) for sending to the network by populating any missing properties:

* Resolves `to` and `from` addresses
* If `from` is specified , check that it matches this Signer
* Populates `nonce` via `signer.getNonce("pending")`
* Populates `gasLimit` via `signer.estimateGas(tx)`
* Populates `chainId` via `signer.provider.getNetwork()`
* Populates `type` and relevant fee data for that type (`gasPrice`)

#### Parameters

| Parameter | Type                                                                 | Description                 |
| :-------- | :------------------------------------------------------------------- | :-------------------------- |
| `tx`      | [`TransactionRequest`](/sdk/content/type-aliases/TransactionRequest) | The transaction to prepare. |

#### Returns

`Promise`\<[`TransactionLike`](/sdk/content/interfaces/TransactionLike)>

A promise resolving to the prepared transaction.

#### Throws

If the transaction is invalid.

#### Note

Some Signer implementations may skip populating properties that
are populated downstream; for example JsonRpcSigner defers to the
node to populate the nonce and fee data.

#### Source

[signers/signer.ts:84](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/signers/signer.ts#L84)

***

### sendTransaction()

```ts theme={null}
sendTransaction(tx): Promise<TransactionResponse>
```

Sends `tx` to the Network. The `signer.populateTransaction(tx)` is called first to ensure all necessary
properties for the transaction to be valid have been popualted first.

#### Parameters

| Parameter | Type                                                                 | Description              |
| :-------- | :------------------------------------------------------------------- | :----------------------- |
| `tx`      | [`TransactionRequest`](/sdk/content/type-aliases/TransactionRequest) | The transaction to send. |

#### Returns

`Promise`\<[`TransactionResponse`](/sdk/content/type-aliases/TransactionResponse)>

A promise resolving to the transaction response.

#### Overrides

`ContractRunner.sendTransaction`

#### Throws

If the transaction is invalid.

#### Source

[signers/signer.ts:147](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/signers/signer.ts#L147)

***

### signMessage()

```ts theme={null}
signMessage(message): Promise<string>
```

Signs an [EIP-191](https://eips.ethereum.org/EIPS/eip-191) prefixed personal message.

If the `message` is a string, it is signed as UTF-8 encoded bytes. It is **not** interpretted as a
[BytesLike](../type-aliases/BytesLike); so the string `"0x1234"` is signed as six characters, **not** two bytes.

To sign that example as two bytes, the Uint8Array should be used (i.e. `new Uint8Array([ 0x12, 0x34 ])`).

#### Parameters

| Parameter | Type                     | Description          |
| :-------- | :----------------------- | :------------------- |
| `message` | `string` \| `Uint8Array` | The message to sign. |

#### Returns

`Promise`\<`string`>

A promise resolving to the signed message.

#### Throws

If the message is invalid.

#### Source

[signers/signer.ts:161](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/signers/signer.ts#L161)

***

### signTransaction()

```ts theme={null}
signTransaction(tx): Promise<string>
```

Signs `tx`, returning the fully signed transaction. This does not populate any additional properties within the
transaction.

#### Parameters

| Parameter | Type                                                                 | Description              |
| :-------- | :------------------------------------------------------------------- | :----------------------- |
| `tx`      | [`TransactionRequest`](/sdk/content/type-aliases/TransactionRequest) | The transaction to sign. |

#### Returns

`Promise`\<`string`>

A promise resolving to the signed transaction.

#### Throws

If the transaction is invalid.

#### Source

[signers/signer.ts:137](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/signers/signer.ts#L137)

***

### signTypedData()

```ts theme={null}
signTypedData(
   domain, 
   types, 
value): Promise<string>
```

Signs the [EIP-712](https://eips.ethereum.org/EIPS/eip-712) typed data.

#### Parameters

| Parameter | Type                                                                               | Description                   |
| :-------- | :--------------------------------------------------------------------------------- | :---------------------------- |
| `domain`  | [`TypedDataDomain`](/sdk/content/interfaces/TypedDataDomain)                       | The domain of the typed data. |
| `types`   | `Record`\<`string`, [`TypedDataField`](/sdk/content/interfaces/TypedDataField)\[]> | The types of the typed data.  |
| `value`   | `Record`\<`string`, `any`>                                                         | The value of the typed data.  |

#### Returns

`Promise`\<`string`>

A promise resolving to the signed typed data.

#### Source

[signers/signer.ts:171](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/signers/signer.ts#L171)


# Subscriber
Source: https://docs.qu.ai/sdk/content/interfaces/Subscriber



A **Subscriber** manages a subscription.

Only developers sub-classing [**AbstractProvider**](/sdk/content/classes/AbstractProvider) will care about this, if they are
modifying a low-level feature of how subscriptions operate.

## Properties

| Property           | Type     | Description                                                                                                                                           |
| :----------------- | :------- | :---------------------------------------------------------------------------------------------------------------------------------------------------- |
| `pollingInterval?` | `number` | The frequency (in ms) to poll for events, if polling is used by the subscriber.<br /><br />For non-polling subscribers, this must return `undefined`. |

## Methods

### pause()

```ts theme={null}
pause(dropWhilePaused?): void
```

Called when the subscription should pause.

If `dropWhilePaused`, events that occur while paused should not be emitted
[**Subscriber.resume**](/sdk/content/interfaces/Subscriber#resume).

#### Parameters

| Parameter          | Type      | Description                               |
| :----------------- | :-------- | :---------------------------------------- |
| `dropWhilePaused`? | `boolean` | If `true`, events that occur while paused |

#### Returns

`void`

#### Source

[providers/abstract-provider.ts:233](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L233)

***

### resume()

```ts theme={null}
resume(): void
```

Resume a paused subscriber.

#### Returns

`void`

#### Source

[providers/abstract-provider.ts:238](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L238)

***

### start()

```ts theme={null}
start(): void
```

Called initially when a subscriber is added the first time.

#### Returns

`void`

#### Source

[providers/abstract-provider.ts:218](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L218)

***

### stop()

```ts theme={null}
stop(): void
```

Called when there are no more subscribers to the event.

#### Returns

`void`

#### Source

[providers/abstract-provider.ts:223](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L223)


# TransactionLike
Source: https://docs.qu.ai/sdk/content/interfaces/TransactionLike



A **TransactionLike** is a JSON representation of a transaction.

## Properties

| Property     | Type                                                                 | Description                               |
| :----------- | :------------------------------------------------------------------- | :---------------------------------------- |
| `chainId?`   | `null` \| [`BigNumberish`](/sdk/content/type-aliases/BigNumberish)   | The chain ID the transaction is valid on. |
| `hash?`      | `null` \| `string`                                                   | The hash of the transaction.              |
| `signature?` | `null` \| [`SignatureLike`](/sdk/content/type-aliases/SignatureLike) | The signature for the transaction         |
| `type`       | `null` \| `number`                                                   | The type.                                 |


# TransactionReceiptParams
Source: https://docs.qu.ai/sdk/content/interfaces/TransactionReceiptParams



A **TransactionReceiptParams** encodes the minimal required properties for a formatted transaction receipt.

## Properties

| Property             | Type                                                         | Description                                                                                                                                                                                                                                  |
| :------------------- | :----------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `blockHash`          | `string`                                                     | The block hash of the block that included this transaction.                                                                                                                                                                                  |
| `blockNumber`        | `number`                                                     | The block number of the block that included this transaction.                                                                                                                                                                                |
| `contractAddress`    | `null` \| `string`                                           | If the transaction was directly deploying a contract, the [**to**](/sdk/content/interfaces/TransactionReceiptParams) will be<br />null, the `data` will be initcode and if successful, this will be the address of the contract deployed.    |
| `cumulativeGasUsed`  | `bigint`                                                     | The total amount of gas consumed during the entire block up to and including this transaction.                                                                                                                                               |
| `effectiveGasPrice?` | `null` \| `bigint`                                           | The actual gas price per gas charged for this transaction.                                                                                                                                                                                   |
| `from`               | `string`                                                     | The sender of the transaction.                                                                                                                                                                                                               |
| `gasPrice?`          | `null` \| `bigint`                                           | The actual gas price per gas charged for this transaction.                                                                                                                                                                                   |
| `gasUsed`            | `bigint`                                                     | The amount of gas consumed executing this transaciton.                                                                                                                                                                                       |
| `hash`               | `string`                                                     | The transaction hash.                                                                                                                                                                                                                        |
| `index`              | `number`                                                     | The transaction index.                                                                                                                                                                                                                       |
| `logs`               | readonly [`LogParams`](/sdk/content/interfaces/LogParams)\[] | The logs emitted during the execution of this transaction.                                                                                                                                                                                   |
| `logsBloom`          | `string`                                                     | The bloom filter for the logs emitted during execution of this transaction.                                                                                                                                                                  |
| `status`             | `null` \| `number`                                           | The status of the transaction execution. If `1` then the the transaction returned success, if `0` then the<br />transaction was reverted. For pre-byzantium blocks, this is usually null, but some nodes may have backfilled this<br />data. |
| `to`                 | `null` \| `string`                                           | The target of the transaction. If null, the transaction was trying to deploy a transaction with the `data` as the<br />initi=code.                                                                                                           |
| `type`               | `number`                                                     | The [EIP-2718](https://eips.ethereum.org/EIPS/eip-2718) envelope type.                                                                                                                                                                       |


# TypedDataDomain
Source: https://docs.qu.ai/sdk/content/interfaces/TypedDataDomain



The domain for an [EIP-712](https://eips.ethereum.org/EIPS/eip-712) payload.

## Properties

| Property             | Type                                                               | Description                                                     |
| :------------------- | :----------------------------------------------------------------- | :-------------------------------------------------------------- |
| `chainId?`           | `null` \| [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The chain ID of the signing domain.                             |
| `name?`              | `null` \| `string`                                                 | The human-readable name of the signing domain.                  |
| `salt?`              | `null` \| [`BytesLike`](/sdk/content/type-aliases/BytesLike)       | A salt used for purposes decided by the specific domain.        |
| `verifyingContract?` | `null` \| `string`                                                 | The the address of the contract that will verify the signature. |
| `version?`           | `null` \| `string`                                                 | The major version of the signing domain.                        |


# TypedDataField
Source: https://docs.qu.ai/sdk/content/interfaces/TypedDataField



A specific field of a structured [EIP-712](https://eips.ethereum.org/EIPS/eip-712) type.

## Properties

| Property | Type     | Description            |
| :------- | :------- | :--------------------- |
| `name`   | `string` | The field name.        |
| `type`   | `string` | The type of the field. |


# WebSocketLike
Source: https://docs.qu.ai/sdk/content/interfaces/WebSocketLike



A generic interface to a Websocket-like object.


# AccessList
Source: https://docs.qu.ai/sdk/content/type-aliases/AccessList



```ts theme={null}
type AccessList: AccessListEntry[];
```

An ordered collection of [**AccessList** ](/sdk/content/type-aliases/AccessList) entries.

## Source

[transaction/index.ts:19](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/index.ts#L19)


# AccessListEntry
Source: https://docs.qu.ai/sdk/content/type-aliases/AccessListEntry



```ts theme={null}
type AccessListEntry: {
  "address": string;
  "storageKeys": string[];
};
```

A single [**AccessList** ](/sdk/content/type-aliases/AccessList) entry of storage keys (slots) for an address.

## Type declaration

### address

```ts theme={null}
address: string;
```

### storageKeys

```ts theme={null}
storageKeys: string[];
```

## Source

[transaction/index.ts:12](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/index.ts#L12)


# AccessListish
Source: https://docs.qu.ai/sdk/content/type-aliases/AccessListish



```ts theme={null}
type AccessListish: AccessList | [string, string[]][] | Record<string, string[]>;
```

Any quais-supported access list structure.

## Source

[transaction/index.ts:26](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/index.ts#L26)


# BlockTag
Source: https://docs.qu.ai/sdk/content/type-aliases/BlockTag



```ts theme={null}
type BlockTag: BigNumberish | string;
```

A **BlockTag** specifies a specific block.

**numeric value** - specifies the block height, where the genesis block is block 0; many operations accept a negative
value which indicates the block number should be deducted from the most recent block. A numeric value may be a
`number`, `bigint`, or a decimal of hex string.

**blockhash** - specifies a specific block by its blockhash; this allows potentially orphaned blocks to be specifed,
without ambiguity, but many backends do not support this for some operations.

## Source

[providers/provider.ts:43](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L43)


# DebugEventBrowserProvider
Source: https://docs.qu.ai/sdk/content/type-aliases/DebugEventBrowserProvider



```ts theme={null}
type DebugEventBrowserProvider: {
  "action": "sendEip1193Payload";
  "payload": {
     "method": string;
     "params": any[];
    };
 } | {
  "action": "receiveEip1193Result";
  "result": any;
 } | {
  "action": "receiveEip1193Error";
  "error": Error;
};
```

The possible additional events dispatched when using the `"debug"` event on a
[**BrowserProvider**](/sdk/content/classes/BrowserProvider).

## Source

[providers/provider-browser.ts:40](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-browser.ts#L40)


# ErrorCode
Source: https://docs.qu.ai/sdk/content/type-aliases/ErrorCode



```ts theme={null}
type ErrorCode: 
  | "UNKNOWN_ERROR"
  | "NOT_IMPLEMENTED"
  | "UNSUPPORTED_OPERATION"
  | "NETWORK_ERROR"
  | "SERVER_ERROR"
  | "TIMEOUT"
  | "BAD_DATA"
  | "CANCELLED"
  | "BUFFER_OVERRUN"
  | "NUMERIC_FAULT"
  | "INVALID_ARGUMENT"
  | "MISSING_ARGUMENT"
  | "UNEXPECTED_ARGUMENT"
  | "VALUE_MISMATCH"
  | "CALL_EXCEPTION"
  | "INSUFFICIENT_FUNDS"
  | "NONCE_EXPIRED"
  | "REPLACEMENT_UNDERPRICED"
  | "TRANSACTION_REPLACED"
  | "UNCONFIGURED_NAME"
  | "OFFCHAIN_FAULT"
  | "TRANSACTION_NOT_FOUND"
  | "TRANSACTION_ALREADY_KNOWN"
  | "ACTION_REJECTED"
  | "PROVIDER_FAILED_TO_INITIALIZE";
```

All errors emitted by quais have an **ErrorCode** to help identify and coalesce errors to simplify programmatic
analysis.

Each **ErrorCode** is the `code` proerty of a coresponding [**quaisError**](/sdk/content/interfaces/quaisError).

**Generic Errors**

**`"UNKNOWN_ERROR"`** - see [**UnknownError**](/sdk/content/interfaces/UnknownError)

**`"NOT_IMPLEMENTED"`** - see [**NotImplementedError**](/sdk/content/interfaces/NotImplementedError)

**`"UNSUPPORTED_OPERATION"`** - see [**UnsupportedOperationError**](/sdk/content/interfaces/UnsupportedOperationError)

**`"NETWORK_ERROR"`** - see [**NetworkError**](/sdk/content/interfaces/NetworkError)

**`"SERVER_ERROR"`** - see [**ServerError**](/sdk/content/interfaces/ServerError)

**`"TIMEOUT"`** - see [**TimeoutError**](/sdk/content/interfaces/TimeoutError)

**`"BAD_DATA"`** - see [**BadDataError**](/sdk/content/interfaces/BadDataError)

**`"CANCELLED"`** - see [**CancelledError**](/sdk/content/interfaces/CancelledError)

**Operational Errors**

**`"BUFFER_OVERRUN"`** - see [**BufferOverrunError**](/sdk/content/interfaces/BufferOverrunError)

**`"NUMERIC_FAULT"`** - see [**NumericFaultError**](/sdk/content/interfaces/NumericFaultError)

**Argument Errors**

**`"INVALID_ARGUMENT"`** - see [**InvalidArgumentError**](/sdk/content/interfaces/InvalidArgumentError)

**`"MISSING_ARGUMENT"`** - see [**MissingArgumentError**](/sdk/content/interfaces/MissingArgumentError)

**`"UNEXPECTED_ARGUMENT"`** - see [**UnexpectedArgumentError**](/sdk/content/interfaces/UnexpectedArgumentError)

**Blockchain Errors**

**`"CALL_EXCEPTION"`** - see [**CallExceptionError**](/sdk/content/interfaces/CallExceptionError)

**`"INSUFFICIENT_FUNDS"`** - see [**InsufficientFundsError**](/sdk/content/interfaces/InsufficientFundsError)

**`"NONCE_EXPIRED"`** - see[**NonceExpiredError**](/sdk/content/interfaces/NonceExpiredError)

**`"REPLACEMENT_UNDERPRICED"`** - see [**ReplacementUnderpricedError**](/sdk/content/interfaces/ReplacementUnderpricedError)

**`"TRANSACTION_REPLACED"`** - see [**TransactionReplacedError**](/sdk/content/interfaces/TransactionReplacedError)

**User Interaction Errors**

**`"ACTION_REJECTED"`** - see [**ActionRejectedError**](/sdk/content/interfaces/ActionRejectedError)

## Source

[utils/errors.ts:122](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/errors.ts#L122)


# JsonRpcApiProviderOptions
Source: https://docs.qu.ai/sdk/content/type-aliases/JsonRpcApiProviderOptions



```ts theme={null}
type JsonRpcApiProviderOptions: {
  "batchMaxCount": number;
  "batchMaxSize": number;
  "batchStallTime": number;
  "cacheTimeout": number;
  "shardPaths": ShardPaths | ShardPaths[] | false;
  "shardPorts": ShardPorts | ShardPorts[] | false;
  "shards": Shard[] | Shard[][] | false;
  "staticNetwork": null | Network | boolean;
  "usePathing": boolean;
};
```

Options for configuring a [**JsonRpcApiProvider**](/sdk/content/classes/JsonRpcApiProvider). Much of this is targeted towards
sub-classes, which often will not expose any of these options to their consumers.

**`polling`** - use the polling strategy is used immediately for events; otherwise, attempt to use filters and fall
back onto polling (default: `false`)

**`staticNetwork`** - do not request chain ID on requests to validate the underlying chain has not changed (default:
`null`)

This should **ONLY** be used if it is **certain** that the network cannot change, such as when using INFURA (since
the URL dictates the network). If the network is assumed static and it does change, this can have tragic
consequences. For example, this **CANNOT** be used with MetaMask, since the used can select a new network from the
drop-down at any time.

**`batchStallTime`** - how long (ms) to aggregate requests into a single batch. `0` indicates batching will only
encompass the current event loop. If `batchMaxCount = 1`, this is ignored. (default: `10`)

**`batchMaxSize`** - target maximum size (bytes) to allow per batch request (default: 1Mb)

**`batchMaxCount`** - maximum number of requests to allow in a batch. If `batchMaxCount = 1`, then batching is
disabled. (default: `100`)

**`cacheTimeout`** - passed as AbstractProviderOptions | **AbstractProviderOptions**.

## Type declaration

### batchMaxCount?

```ts theme={null}
optional batchMaxCount: number;
```

### batchMaxSize?

```ts theme={null}
optional batchMaxSize: number;
```

### batchStallTime?

```ts theme={null}
optional batchStallTime: number;
```

### cacheTimeout?

```ts theme={null}
optional cacheTimeout: number;
```

### shardPaths?

```ts theme={null}
optional shardPaths: ShardPaths | ShardPaths[] | false;
```

### shardPorts?

```ts theme={null}
optional shardPorts: ShardPorts | ShardPorts[] | false;
```

### shards?

```ts theme={null}
optional shards: Shard[] | Shard[][] | false;
```

### staticNetwork?

```ts theme={null}
optional staticNetwork: null | Network | boolean;
```

### usePathing?

```ts theme={null}
optional usePathing: boolean;
```

## Source

[providers/provider-jsonrpc.ts:210](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L210)


# JsonRpcError
Source: https://docs.qu.ai/sdk/content/type-aliases/JsonRpcError



```ts theme={null}
type JsonRpcError: {
  "error": {
     "code": number;
     "data": any;
     "message": string;
     "shard": Shard;
    };
  "id": number;
};
```

A JSON-RPC error, which are returned on failure from a JSON-RPC server.

## Type declaration

### error

```ts theme={null}
error: {
  "code": number;
  "data": any;
  "message": string;
  "shard": Shard;
};
```

The response error.

### error.code

```ts theme={null}
code: number;
```

### error.data?

```ts theme={null}
optional data: any;
```

### error.message?

```ts theme={null}
optional message: string;
```

### error.shard?

```ts theme={null}
optional shard: Shard;
```

### id

```ts theme={null}
id: number;
```

The response ID to match it to the relevant request.

## Source

[providers/provider-jsonrpc.ts:147](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L147)


# JsonRpcPayload
Source: https://docs.qu.ai/sdk/content/type-aliases/JsonRpcPayload



```ts theme={null}
type JsonRpcPayload: {
  "id": number;
  "jsonrpc": "2.0";
  "method": string;
  "params": any[] | Record<string, any>;
};
```

A JSON-RPC payload, which are sent to a JSON-RPC server.

## Type declaration

### id

```ts theme={null}
id: number;
```

The JSON-RPC request ID.

### jsonrpc

```ts theme={null}
jsonrpc: "2.0";
```

A required constant in the JSON-RPC specification.

### method

```ts theme={null}
method: string;
```

The JSON-RPC request method.

### params

```ts theme={null}
params: any[] | Record<string, any>;
```

The JSON-RPC request parameters.

## Source

[providers/provider-jsonrpc.ts:103](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L103)


# JsonRpcResult
Source: https://docs.qu.ai/sdk/content/type-aliases/JsonRpcResult



```ts theme={null}
type JsonRpcResult: {
  "id": number;
  "result": any;
};
```

A JSON-RPC result, which are returned on success from a JSON-RPC server.

## Type declaration

### id

```ts theme={null}
id: number;
```

The response ID to match it to the relevant request.

### result

```ts theme={null}
result: any;
```

The response result.

## Source

[providers/provider-jsonrpc.ts:130](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-jsonrpc.ts#L130)


# MinedTransactionResponse
Source: https://docs.qu.ai/sdk/content/type-aliases/MinedTransactionResponse



```ts theme={null}
type MinedTransactionResponse: QuaiMinedTransactionResponse | QiMinedTransactionResponse;
```

A **MinedTransactionResponse** is an interface representing a transaction which has been mined and allows for a type
guard for its property values being defined.

## Source

[providers/provider.ts:1458](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1458)


# Networkish
Source: https://docs.qu.ai/sdk/content/type-aliases/Networkish



```ts theme={null}
type Networkish: 
  | Network
  | number
  | bigint
  | string
  | {
  "chainId": number;
  "name": string;
};
```

A Networkish can be used to allude to a Network, by specifying:

* A [Network](/sdk/content/classes/Network) object
* A well-known (or registered) network name
* A well-known (or registered) chain ID
* An object with sufficient details to describe a network

## Source

[providers/network.ts:21](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/network.ts#L21)


# OrphanFilter
Source: https://docs.qu.ai/sdk/content/type-aliases/OrphanFilter



```ts theme={null}
type OrphanFilter: {
  "hash": string;
  "number": number;
  "orphan": "drop-block";
 } | {
  "orphan": "drop-transaction";
  "other": {
     "blockHash": string;
     "blockNumber": number;
     "hash": string;
    };
  "tx": {
     "blockHash": string;
     "blockNumber": number;
     "hash": string;
    };
 } | {
  "orphan": "reorder-transaction";
  "other": {
     "blockHash": string;
     "blockNumber": number;
     "hash": string;
    };
  "tx": {
     "blockHash": string;
     "blockNumber": number;
     "hash": string;
    };
 } | {
  "log": {
     "address": string;
     "blockHash": string;
     "blockNumber": number;
     "data": string;
     "index": number;
     "topics": ReadonlyArray<string>;
     "transactionHash": string;
    };
  "orphan": "drop-log";
};
```

An Orphan Filter allows detecting when an orphan block has resulted in dropping a block or transaction or has
resulted in transactions changing order.

Not currently fully supported.

## Source

[providers/provider.ts:2525](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2525)


# PerformActionFilter
Source: https://docs.qu.ai/sdk/content/type-aliases/PerformActionFilter



```ts theme={null}
type PerformActionFilter: {
  "address": string | string[];
  "fromBlock": BlockTag;
  "nodeLocation": NodeLocation;
  "toBlock": BlockTag;
  "topics": (null | string | string[])[];
 } | {
  "address": string | string[];
  "blockHash": string;
  "nodeLocation": NodeLocation;
  "topics": (null | string | string[])[];
};
```

A normalized filter used for [**PerformActionRequest**](/sdk/content/type-aliases/PerformActionRequest) objects.

## Source

[providers/abstract-provider.ts:463](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L463)


# PerformActionRequest
Source: https://docs.qu.ai/sdk/content/type-aliases/PerformActionRequest



```ts theme={null}
type PerformActionRequest: 
  | {
  "method": "broadcastTransaction";
  "signedTransaction": string;
  "zone": Zone;
 }
  | {
  "method": "calculateConversionAmount";
  "transactionArgs": ConversionTransactionRequest;
 }
  | {
  "blockTag": BlockTag;
  "method": "call";
  "transaction": PerformActionTransaction;
  "zone": Zone;
 }
  | {
  "method": "chainId";
  "zone": Zone;
 }
  | {
  "method": "estimateGas";
  "transaction": PerformActionTransaction;
  "zone": Zone;
 }
  | {
  "method": "estimateFeeForQi";
  "transaction": QiPerformActionTransaction;
  "zone": Zone;
 }
  | {
  "method": "createAccessList";
  "transaction": PerformActionTransaction;
  "zone": Zone;
 }
  | {
  "address": string;
  "blockTag": BlockTag;
  "method": "getBalance";
  "zone": Zone;
 }
  | {
  "address": string;
  "method": "getLockedBalance";
  "zone": Zone;
 }
  | {
  "address": string;
  "method": "getOutpointsByAddress";
  "zone": Zone;
 }
  | {
  "blockTag": BlockTag;
  "includeTransactions": boolean;
  "method": "getBlock";
  "shard": Shard;
 }
  | {
  "blockHash": string;
  "includeTransactions": boolean;
  "method": "getBlock";
  "shard": Shard;
 }
  | {
  "method": "getBlockNumber";
  "shard": Shard;
 }
  | {
  "address": string;
  "blockTag": BlockTag;
  "method": "getCode";
  "zone": Zone;
 }
  | {
  "method": "getGasPrice";
  "txType": boolean;
  "zone": Zone;
 }
  | {
  "filter": PerformActionFilter;
  "method": "getLogs";
  "zone": Zone;
 }
  | {
  "address": string;
  "blockTag": BlockTag;
  "method": "getStorage";
  "position": bigint;
  "zone": Zone;
 }
  | {
  "hash": string;
  "method": "getTransaction";
  "zone": Zone;
 }
  | {
  "address": string;
  "blockTag": BlockTag;
  "method": "getTransactionCount";
  "zone": Zone;
 }
  | {
  "hash": string;
  "method": "getTransactionReceipt";
  "zone": Zone;
 }
  | {
  "hash": string;
  "method": "getTransactionResult";
  "zone": Zone;
 }
  | {
  "method": "getRunningLocations";
  "now": boolean;
  "shard": Shard;
 }
  | {
  "method": "getProtocolTrieExpansionCount";
  "shard": Shard;
 }
  | {
  "amt": string;
  "blockTag": BlockTag;
  "method": "qiToQuai";
  "zone": Zone;
 }
  | {
  "amt": string;
  "blockTag": BlockTag;
  "method": "quaiToQi";
  "zone": Zone;
 }
  | {
  "method": "getProtocolExpansionNumber";
 }
  | {
  "method": "getPendingHeader";
 }
  | {
  "method": "getTxPoolContent";
  "zone": Zone;
 }
  | {
  "method": "txPoolInspect";
  "zone": Zone;
 }
  | {
  "addresses": string[];
  "endHash": string;
  "method": "getOutpointDeltasForAddressesInRange";
  "startHash": string;
  "zone": Zone;
};
```

The [**AbstractProvider**](/sdk/content/classes/AbstractProvider) methods will normalize all values and pass this type to
AbstractProvider.\_perform | **AbstractProvider.\_perform**.

## Source

[providers/abstract-provider.ts:538](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L538)


# PerformActionTransaction
Source: https://docs.qu.ai/sdk/content/type-aliases/PerformActionTransaction



```ts theme={null}
type PerformActionTransaction: QuaiPerformActionTransaction | QiPerformActionTransaction;
```

A normalized transactions used for [**PerformActionRequest**](/sdk/content/type-aliases/PerformActionRequest) objects.

## Source

[providers/abstract-provider.ts:483](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L483)


# PreparedTransactionRequest
Source: https://docs.qu.ai/sdk/content/type-aliases/PreparedTransactionRequest



```ts theme={null}
type PreparedTransactionRequest: QuaiPreparedTransactionRequest | QiPreparedTransactionRequest;
```

A **PreparedTransactionRequest** is identical to a [**TransactionRequest**](/sdk/content/type-aliases/TransactionRequest) except all the
property types are strictly enforced.

## Source

[providers/provider.ts:276](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L276)


# ProviderEvent
Source: https://docs.qu.ai/sdk/content/type-aliases/ProviderEvent



```ts theme={null}
type ProviderEvent: 
  | string
  | (string | string[])[]
  | EventFilter
  | OrphanFilter
  | AccessesFilter;
```

A **ProviderEvent** provides the types of events that can be subscribed to on a [**Provider**](/sdk/content/interfaces/Provider).

Each provider may include additional possible events it supports, but the most commonly supported are:

**`"block"`** - calls the listener with the current block number on each new block.

**`"error"`** - calls the listener on each async error that occurs during the event loop, with the error.

**`"debug"`** - calls the listener on debug events, which can be used to troubleshoot network errors, provider
problems, etc.

**`transaction hash`** - calls the listener on each block after the transaction has been mined; generally `.once` is
more appropriate for this event.

**`Array`** - calls the listener on each log that matches the filter.

[**EventFilter**](/sdk/content/interfaces/EventFilter) - calls the listener with each matching log

## Source

[providers/provider.ts:2709](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2709)


# Subscription
Source: https://docs.qu.ai/sdk/content/type-aliases/Subscription



```ts theme={null}
type Subscription: 
  | {
  "tag": string;
  "type":   | "close"
     | "debug"
     | "error"
     | "finalized"
     | "network"
     | "safe";
  "zone": Zone;
 }
  | {
  "tag": string;
  "type": "block" | "pending";
  "zone": Zone;
 }
  | {
  "hash": string;
  "tag": string;
  "type": "transaction";
  "zone": Zone;
 }
  | {
  "filter": AccessesFilter;
  "tag": string;
  "type": "accesses";
  "zone": Zone;
 }
  | {
  "hash": string;
  "tag": string;
  "type": "qiTransaction";
  "zone": Zone;
 }
  | {
  "filter": EventFilter;
  "tag": string;
  "type": "event";
  "zone": Zone;
 }
  | {
  "filter": OrphanFilter;
  "tag": string;
  "type": "orphan";
  "zone": Zone;
};
```

The value passed to the AbstractProvider.\_getSubscriber | **AbstractProvider.\_getSubscriber** method.

Only developers sub-classing [**AbstractProvider**](/sdk/content/classes/AbstractProvider) will care about this, if they are
modifying a low-level feature of how subscriptions operate.

## Source

[providers/abstract-provider.ts:164](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/abstract-provider.ts#L164)


# TopicFilter
Source: https://docs.qu.ai/sdk/content/type-aliases/TopicFilter



```ts theme={null}
type TopicFilter: (null | string | string[])[];
```

A **TopicFilter** provides a struture to define bloom-filter queries.

Each field that is `null` matches **any** value, a field that is a `string` must match exactly that value and and
`array` is effectively an `OR`-ed set, where any one of those values must match.

## Source

[providers/provider.ts:2605](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L2605)


# TransactionRequest
Source: https://docs.qu.ai/sdk/content/type-aliases/TransactionRequest



```ts theme={null}
type TransactionRequest: QuaiTransactionRequest | QiTransactionRequest;
```

A **TransactionRequest** is a transactions with potentially various properties not defined, or with less strict types
for its values.

This is used to pass to various operations, which will internally coerce any types and populate any necessary values.

## Source

[providers/provider.ts:164](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L164)


# TransactionResponse
Source: https://docs.qu.ai/sdk/content/type-aliases/TransactionResponse



```ts theme={null}
type TransactionResponse: QuaiTransactionResponse | QiTransactionResponse;
```

A **TransactionResponse** is an interface representing either a Quai or Qi transaction that has been mined into a
block.

## Source

[providers/provider.ts:1697](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider.ts#L1697)


# TransactionResponseParams
Source: https://docs.qu.ai/sdk/content/type-aliases/TransactionResponseParams



```ts theme={null}
type TransactionResponseParams: QuaiTransactionResponseParams | QiTransactionResponseParams;
```

A **TransactionResponseParams** encodes the minimal required properties for a formatted transaction response for
either a Qi or Quai transaction.

## Source

[providers/formatting.ts:393](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/formatting.ts#L393)


# WebSocketCreator
Source: https://docs.qu.ai/sdk/content/type-aliases/WebSocketCreator



```ts theme={null}
type WebSocketCreator: () => WebSocketLike;
```

A function which can be used to re-create a WebSocket connection on disconnect.

## Returns

[`WebSocketLike`](/sdk/content/interfaces/WebSocketLike)

## Source

[providers/provider-websocket.ts:50](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/providers/provider-websocket.ts#L50)


# denominations
Source: https://docs.qu.ai/sdk/content/variables/denominations



```ts theme={null}
const denominations: bigint[];
```

List of supported Qi denominations.

## Source

[transaction/utxo.ts:88](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/transaction/utxo.ts#L88)


# Current Ambassadors
Source: https://docs.qu.ai/get-involved/active-ambassadors

Meet our dedicated team of global Quai Network representatives.

## 🇧🇩 Bangladesh

* <img alt="Mohsin" /> **Mohsin**\
  Twitter: [@MohsinI13658106](https://twitter.com/MohsinI13658106)\
  Languages: Bengali, Hindi, English

* <img alt="core_block" /> **Aiob khan**\
  Twitter: [@core\_block](https://twitter.com/core_block)\
  Languages: Bengali, English

## 🇬🇧 British

* <img alt="swimgood" /> **swimgood**\
  Twitter: [@tonwontonwon](https://twitter.com/tonwontonwon)\
  Languages: English, Korean

## 🇳🇬 Nigeria

* <img alt="IsaYalwa" /> **IsaYalwa**\
  Twitter: [@IsaYalwa](https://twitter.com/IsaYalwa)\
  Languages: Hausa, English

* <img alt="egoegodifi" /> **egoego**\
  Twitter: [@egoegodifi](https://twitter.com/egoegodifi)\
  Languages: Igbo, Pidgin, English

* <img alt="0x_Noor" /> **Noor**\
  Twitter: [@0x\_Noor](https://twitter.com/0x_Noor)\
  Languages: Hausa, English

* <img alt="mvstafah" /> **Muhammad Yusuf Bawah**\
  Twitter: [@mvstafah](https://twitter.com/mvstafah)\
  Languages: Hausa, English

## 🇺🇸 USA

* <img alt="steph_curdy" /> **Steph Macurdy**\
  Twitter: [@steph\_curdy](https://twitter.com/steph_curdy)\
  Languages: English

* <img alt="lysss302" /> **Lyss**\
  Twitter: [@lysss302](https://twitter.com/lysss302)\
  Languages: English, Spanish

* <img alt="lostpeanut_" /> **Broc Tolifson**\
  Twitter: [@lostpeanut\_](https://twitter.com/lostpeanut_)\
  Languages: English

* <img alt="JimWallberg" /> **Noah**\
  Twitter: [@JimWallberg](https://twitter.com/JimWallberg)\
  Languages: English

* <img alt="quaiboss" /> **Quai Boss**\
  Twitter: [@quaiboss](https://twitter.com/quaiboss)\
  Languages: English

* <img alt="CryptoEmpressX" /> **CryptoEmpressX**\
  Twitter: [@CryptoEmpressX](https://twitter.com/CryptoEmpressX)\
  Languages: English

* <img alt="cosmoshoss" /> **Hoss**\
  Twitter: [@cosmoshoss](https://twitter.com/cosmoshoss)\
  Languages: English

## 🇻🇳 Vietnam

* <img alt="Kennguyen_xyz" /> **Ken Nguyen**\
  Twitter: [@Kennguyen\_xyz](https://twitter.com/Kennguyen_xyz)\
  Languages: Vietnamese, English

## 🌍 Other

* <img alt="TwhitNub101" /> **AlphaMine**\
  Twitter: [@TwhitNub101](https://twitter.com/TwhitNub101)\
  Languages: English

* <img alt="grstans" /> **Eleex**\
  Twitter: [@grstans](https://twitter.com/grstans)\
  Languages: English

* <img alt="Kyrylo22" /> **Kiri**\
  Twitter: [@Kyrylo22](https://twitter.com/Kyrylo22)\
  Languages: English

* <img alt="HemantVajaria" /> **Kishore Satpute**\
  Twitter: [@HemantVajaria](https://twitter.com/HemantVajaria)\
  Languages: English

* <img alt="MaresalSKH" /> **Maresal**\
  Twitter: [@MaresalSKH](https://twitter.com/MaresalSKH)\
  Languages: English

* <img alt="MutantMatt0x" /> **MMatt**\
  Twitter: [@MutantMatt0x](https://twitter.com/MutantMatt0x)\
  Languages: English

* <img alt="hashcoin0" /> **Sun**\
  Twitter: [@hashcoin0](https://twitter.com/hashcoin0)\
  Languages: English

* <img alt="SuburbanCrypto" /> **Suburban Crypto**\
  Twitter: [@SuburbanCrypto](https://twitter.com/SuburbanCrypto)\
  Languages: English

* <img alt="viewhero1" /> **Nakanishi**\
  Twitter: [@viewhero1](https://twitter.com/viewhero1)\
  Languages: English

* <img alt="reddtactt" /> **Reddtactt**\
  Twitter: [@reddtactt](https://twitter.com/reddtactt)\
  Languages: English

* <img alt="ibridrapid" /> **IRIT**\
  Twitter: [@ibridrapid](https://twitter.com/ibridrapid)\
  Languages: English

* <img alt="Vadimbarclay" /> **Vadim**\
  Twitter: [@Vadimbarclay](https://twitter.com/Vadimbarclay)\
  Languages: English

* <img alt="thecrackofdan" /> **Dan**\
  Twitter: [@thecrackofdan](https://twitter.com/thecrackofdan)\
  Languages: English

## Join Our Ambassador Program

We're always looking for passionate community members to join our ambassador program. If you're interested in becoming a Quai Network Ambassador, visit the [Become a Quai Ambassador](/get-involved/ambassadors) page to learn more and apply.


# Ambassador Resources
Source: https://docs.qu.ai/get-involved/ambassador-resources

Access the tools and materials you need to represent Quai Network in your community.

<Note>
  All resources on this page are available for Quai Ambassadors to use in their community-building efforts.
</Note>

## Ambassador Program Overview

As a Quai Ambassador, you're a vital bridge between the Quai Network and your local community. The graphic above highlights the key aspects of the ambassador program and how you can contribute to growing the ecosystem.

## Branding Resources

Access official Quai Network branding materials to ensure consistent representation across all your initiatives.

<Card title="Quai Network Media Kit" icon="images" href="https://quainetworkcommunity.notion.site/Quai-Network-Media-Kit-47d2fbb174f04b7f9e02ce42da110715">
  Access the comprehensive Quai Network media kit including logos, presentation templates, social media assets, and brand guidelines.
</Card>

## Community Channels

Connect with Quai Network communities in different languages:

<CardGroup>
  <Card title="Announcements" icon="bullhorn" href="https://t.me/QuaiNetwork_Announcements">
    Official Quai Network announcements channel
  </Card>

  <Card title="Russian" icon="telegram" href="https://t.me/QuaiNetwork_Ru">
    Русскоязычное сообщество Quai Network
  </Card>

  <Card title="Hindi & Urdu" icon="telegram" href="https://t.me/QuaiNetworkHindi_Urdu">
    Quai Network हिंदी और اردو समुदाय
  </Card>

  <Card title="Mandarin" icon="telegram" href="https://t.me/QuaiNetwork_Mandarin">
    Quai Network 中文社区
  </Card>

  <Card title="Indonesian" icon="telegram" href="https://t.me/QuaiNetwork_Indonesian">
    Komunitas Quai Network Indonesia
  </Card>

  <Card title="Vietnamese" icon="telegram" href="https://t.me/QuaiNetwork_Vietnamese">
    Cộng đồng Quai Network Việt Nam
  </Card>

  <Card title="Turkish" icon="telegram" href="https://t.me/QuaiNetwork_Turkish">
    Quai Network Türkiye Topluluğu
  </Card>

  <Card title="Korean" icon="telegram" href="https://t.me/Quai_Korea">
    Quai Network 한국 커뮤니티
  </Card>

  <Card title="Ukrainian" icon="telegram" href="https://t.me/quainetworkua">
    Українська спільнота Quai Network
  </Card>
</CardGroup>

## Multilingual Resources

Use these resources to introduce Quai Network to non-English speaking communities:

| Language   | One-Pager PDF                                                                                     |
| ---------- | ------------------------------------------------------------------------------------------------- |
| English    | [Download](https://drive.google.com/file/d/1tPy9Q50QJUpgKo7dC5lMiErYgdQDB51z/view?usp=drive_link) |
| Mandarin   | [Download](https://drive.google.com/file/d/1QNK8SNlGuDSBJ8BfZH_em-LonKK5wRtQ/view?usp=sharing)    |
| Vietnamese | [Download](https://drive.google.com/file/d/1Ier9S8YCqhSeyJCgHjCjaoUtIbmTpCe8/view?usp=sharing)    |
| Russian    | [Download](https://drive.google.com/file/d/16euKIuiWGp3avXxl6XmT_EDqaUUtgsZ8/view?usp=sharing)    |
| Hindi      | [Download](https://drive.google.com/file/d/1wmZ_x_6kcQerSSAusgwF7hNg8_Fqj-Bm/view?usp=drive_link) |
| Bengali    | [Download](https://drive.google.com/file/d/15vLByCGXnkwS1HAEgmh14ZCfKYBmojUe/view?usp=drive_link) |
| Korean     | [Download](https://drive.google.com/file/d/1W-khTedLiOjy_NFsD23mzokPoht3E-AU/view?usp=sharing)    |
| Spanish    | [Download](https://drive.google.com/file/d/1vc36soGhYHBzr3kQ55KMwMmOv0eaAEVC/view?usp=drive_link) |
| Japanese   | [Download](https://drive.google.com/file/d/1b4WLvY9bPU-aXubWbLiPOT715gsy6wNy/view?usp=drive_link) |
| Romanian   | [Download](https://drive.google.com/file/d/1R4jy8oDJI9EH5Kfhe3BKIY2y87KIFlPc/view?usp=sharing)    |

## Educational Materials

<img alt="Quai Network Ambassador Program Overview" />

<Note type="warning">
  More educational materials are coming soon. Stay tuned for comprehensive resources to help you share Quai Network with your community.
</Note>

<div>
  <CardGroup>
    <Card title="Introduction to Quai" icon="chalkboard-user" href="#">
      A beginner-friendly presentation explaining Quai Network's core concepts.
    </Card>

    <Card title="Technical Workshop" icon="code" href="#">
      Materials for conducting hands-on technical workshops.
    </Card>
  </CardGroup>

  <CardGroup>
    <Card title="Community Meetup Kit" icon="people-group" href="#">
      Everything you need to host successful local meetups.
    </Card>

    <Card title="FAQ Document" icon="circle-question" href="#">
      Comprehensive answers to common questions about Quai Network.
    </Card>
  </CardGroup>
</div>

## Ambassador Support

For any questions or additional resource needs, please contact the Ambassador Program team:

* **Email**: [team@dominantstrategies.io](mailto:team@dominantstrategies.io)
* **Discord**: Join the [Quai Network Discord](https://discord.gg/quai)


# Become a Quai Ambassador
Source: https://docs.qu.ai/get-involved/ambassadors

Join our global community of advocates and help grow the Quai Network ecosystem.

<Note>
  The Quai Network Ambassador Program is actively recruiting passionate community members who want to help drive adoption worldwide.
</Note>

## What is a Quai Ambassador?

Quai Ambassadors are passionate volunteers who represent the Quai Network in their local communities and online. They play a crucial role in expanding awareness, educating new users, and fostering local communities around the world's first truly decentralized monetary system.

As an ambassador, you'll have direct access to the core team, exclusive resources, and the opportunity to shape the future of Quai Network in your region.

## Ambassador Skills

The best Ambassadors understand Quai Network in detail and can represent the project in public.

| Skill                       | Description                                                                                                                            |
| --------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
| **Public Speaking**         | Confidently communicate complex ideas about Quai Network to diverse audiences through presentations, panels, and casual conversations. |
| **Professional Background** | Leverage your experience and expertise to represent Quai Network with credibility, whether from tech, finance, academia, or beyond.    |
| **Community Involvement**   | Actively engage with crypto communities online and offline, fostering education, collaboration, and adoption of the Quai ecosystem.    |

## Ambassador Expectations

To become a Quai Ambassador, we expect that you:

| Expectation           | Description                                                                      |
| --------------------- | -------------------------------------------------------------------------------- |
| Community Respect     | Uphold the values of the Quai community and engage respectfully with all members |
| Public Representation | Willingly represent Quai Network at events, online forums, and social media      |
| Active Participation  | Regularly volunteer time to support community initiatives and growth             |
| Event Hosting         | Organize and facilitate local meetups to expand the Quai ecosystem               |
| Education             | Help onboard new users by teaching them about Quai's technology and benefits     |

## Benefits of Becoming an Ambassador

* Direct communication channel with the Quai core team
* Early access to product updates and announcements
* Exclusive ambassador swag and recognition
* Opportunity to speak at official Quai events
* Network with other blockchain enthusiasts globally

<Card title="Apply to Become a Quai Ambassador" icon="user-plus" href="https://quai.typeform.com/to/UIMQdXIe">
  Join our global community of advocates and help shape the future of decentralized finance.
</Card>

## Ambassador Resources

Visit our [Ambassador Resources](/get-involved/ambassador-resources) page to access materials that will help you represent Quai Network effectively.

## Active Ambassadors

Meet our global team of dedicated Quai Ambassadors on the [Active Ambassadors](/get-involved/active-ambassadors) page.


# How to Get Involved
Source: https://docs.qu.ai/get-involved/index

Discover the various ways to participate in and contribute to the Quai Network ecosystem.

<Note>
  Join the growing Quai Network community and help shape the future of money.
</Note>

## Ways to Get Involved

<CardGroup>
  <Card title="Become an Ambassador" icon="user-group" href="/get-involved/ambassadors">
    Represent Quai Network in your local community and help expand our global presence.
  </Card>

  <Card title="Ambassador Resources" icon="toolbox" href="/get-involved/ambassador-resources">
    Access tools and materials to effectively educate others about Quai Network.
  </Card>
</CardGroup>

<CardGroup>
  <Card title="Current Ambassadors" icon="globe" href="/get-involved/active-ambassadors">
    Meet our global team of Quai Network representatives.
  </Card>

  <Card title="Contribute to Code" icon="code" href="https://github.com/dominant-strategies/go-quai">
    Help develop and improve the Quai Network codebase on GitHub.
  </Card>
</CardGroup>

<CardGroup>
  <Card title="Join Community Calls" icon="microphone" href="https://discord.gg/quai">
    Participate in regular community discussions and updates.
  </Card>

  <Card title="Run a Node" icon="server" href="/guides/client/node">
    Support the network's decentralization by running your own node.
  </Card>
</CardGroup>

## Community Channels

Connect with the Quai Network community through our official channels:

| Channel  | Purpose               | Link                                                        |
| -------- | --------------------- | ----------------------------------------------------------- |
| Discord  | Main community hub    | [Join Discord](https://discord.gg/quai)                     |
| Twitter  | News and updates      | [Follow @QuaiNetwork](https://twitter.com/QuaiNetwork)      |
| Telegram | Global community chat | [Join Telegram](https://t.me/QuaiNetwork)                   |
| YouTube  | Educational content   | [Subscribe](https://youtube.com/@QuaiNetwork)               |
| GitHub   | Open source code      | [View Repositories](https://github.com/dominant-strategies) |

## Community Governance

Quai Network is committed to building a community-owned and operated system. We're working on governance mechanisms that will allow community members to have a voice in the network's future development.

Stay tuned for updates on governance proposals and voting mechanisms.

## Building on Quai

Developers interested in building applications on Quai Network can refer to our comprehensive [Developer Documentation](/build) to get started.


# Media Kit
Source: https://docs.qu.ai/get-involved/quai-media-kit

Brand guidelines and media assets for Quai Network, Pelagus, and Blip.

<Card title="Brand Guide Outline" href="https://drive.google.com/file/d/1kDyNRAyE8SoWlbMiEr9tZiHDRQrWsHGu/view?usp=sharing">
  The Quai Network brand guide is essential for cultivating a cohesive brand identity.
</Card>

## Quai Network Logos and Wordmarks

<Card title="Brand Guide Logos Archive" icon="file-arrow-down" href="https://drive.google.com/file/d/1qMfwJJ0yNNsyoFlZ3tcLjugk-4XjQ5Vi/view?usp=drive_link">
  The logo package includes every lockup/wordmark/logo included in Quai Network's brand guidelines in PNG and SVG format in black and white colorways.
</Card>

<Columns>
  <Card title="Black Font Logos" href="https://drive.google.com/drive/folders/1wWyHwKuQDQr_ZaPAk3ErsItLkQMh_c6-?usp=sharing">
    Quai Network logo pack in .SVG and .PNG formats.
  </Card>

  <Card title="White Font Logos" href="https://drive.google.com/drive/folders/13xahBHQa0ECS7dCRfGYZXiZyIVGiGECn?usp=sharing">
    Quai Network logo pack in .SVG, .PNG, and .AI formats.
  </Card>

  <Card title="Qi Logos" href="https://drive.google.com/drive/folders/1W24Q4A-j-CdA78b81dS5huZUqRCkoVp6?usp=sharing">
    Qi and Wrapped Qi logos in .SVG and .PNG formats.
  </Card>
</Columns>

## Fonts

<Frame>
  <img alt="The three fonts used in Quai Network typography, Yapari, Bai Jamjuree, and Monorama." />
</Frame>

Our brand's typography is thoughtfully selected to optimize communication. Yapari is employed for headlines, offering a bold and distinct appearance. Bai Jamjuree serves as the workhorse for body text and other essential copy, ensuring readability and coherence. Monorama is reserved for subheadings and detail text, subtly contributing to a well-balanced typographic scheme. This selection aims to facilitate clear and effective communication while maintaining a simple and understated aesthetic.

<Card title="Download here" href="https://drive.google.com/drive/folders/15ATIIFt7UWcL_SCs7JAACCxOEQe2mXlE?usp=drive_link" />

## Color Pallet

The Quai color palette is predominantly monotone, using different shades between black and white, but there is a bold red to use as an accent color. This vivid red serves as a dynamic focal point, injecting energy and vibrancy into our visual identity. Its deliberate and consistent use contributes to brand recognition and reinforces a cohesive and impactful design language for the Quai brand.

<Frame>
  <img alt="Quai colors: QUAI RED HEX: #E22981 RGB: 226.1,1 CMYH: 1.180.108.1 PURE BLACK HEX: #088880 RGB: 8.8.0 СМУН: 91.29.62.92 DARK GREY HEX: #8F0FBF RGB: 52.52.57 CMYH: 62.58.55.62 MID GREY HEX: #646464 RGB: 108.108,108 CMYH: 56.46.45.34 LIGHT GREY HEX: #A1A1A1 AGB: 161, 161 161 CMYH: 39.38.31.9 OFF-WHITE HEX: #E2E2E2 RGB: 226.226.226 CMYH: 14.18.11.8 PURE WHITE HEX: #FFFFFF RGB: 25S.255.25S CMYH: 8.8.8.8" />
</Frame>

## Pelagus and Blip Assets

<Columns>
  <Card title="Blip Assets Pack" href="https://drive.google.com/drive/folders/1mRUejSG7H5rUG0zEIuFOCMh6Eebb40ru?usp=drive_link">
    Blip logos and app images in .SVG and .PNG formats.
  </Card>

  <Card title="Pelagus Assets Pack" href="https://drive.google.com/drive/folders/1VKR5j2P1vgVapNoaW2PZCDEOeooNBMxU?usp=drive_link">
    Pelagus Wallet logos and app images in .SVG and .PNG formats.
  </Card>

  <Card title="Kipper Assets Pack" href="https://drive.google.com/drive/folders/1dPP_-rbXm3PF9B_oShThLALZN-VOzALC?usp=drive_link">
    Kipper logos and app images in .SVG and .PNG formats.
  </Card>
</Columns>


# Containerized Node Deployment
Source: https://docs.qu.ai/guides/client/containerized-node

Checklist for running a go-quai node with Docker, Kubernetes, and reverse proxies.

Running go-quai inside containers introduces networking, resource, and configuration constraints that do not exist on bare metal. This guide covers the requirements across three layers: Docker image and container runtime, Kubernetes orchestration, and reverse proxy configuration.

## Docker

These apply whether you run standalone Docker or Docker inside Kubernetes.

### Published Image

Use the published image when you do not need to modify the go-quai source:

```bash theme={null}
docker pull quainetwork/go-quai:latest
```

The official image is published under the `quainetwork` Docker Hub organization.

### Local Image Build

<Steps>
  <Step title="Use a minimal base image">
    Use `alpine` or `distroless` to reduce attack surface. Ensure the image includes `libc` dependencies required by go-quai's CGO components (LevelDB, kawpow).
  </Step>

  <Step title="Copy the chain config into the image">
    Bake the default configuration files into the image so the node can start without external volume mounts for config.
  </Step>

  <Step title="Expose both TCP and UDP on the p2p port">
    In your `Dockerfile`, declare both protocols:

    ```dockerfile theme={null}
    EXPOSE 4002/tcp
    EXPOSE 4002/udp
    ```
  </Step>
</Steps>

### Basic Start

The container image uses `go-quai start` by default, so a basic node can be started without passing any go-quai flags:

```bash theme={null}
docker run -d \
  --name go-quai \
  --restart unless-stopped \
  --ulimit nofile=65536:65536 \
  --cpus=4 \
  --memory=8g \
  -v /mnt/ssd/quai-data:/root/.local/share/go-quai \
  -p 4002:4002/tcp \
  -p 4002:4002/udp \
  -p 8001:8001/tcp \
  -p 9001:9001/tcp \
  quainetwork/go-quai:latest
```

Replace `/mnt/ssd/quai-data` with the host directory that should store chain data. If you already run go-quai on the host, this is commonly `~/.local/share/go-quai`.

For mining, slice selection, environment selection, coinbase configuration, and other node runtime flags, use the same flags documented in the [Run a Node guide](/guides/client/node). To pass go-quai flags to the container, include the `start` subcommand after the image name:

```bash theme={null}
docker run ... quainetwork/go-quai:latest start --node.slices='[0 0]'
```

### Container Runtime

<Steps>
  <Step title="Raise the file descriptor limit to 65536+">
    The default container ulimit is often 1024. libp2p's dial limiter will throttle outbound peer connections at low FD counts, reducing connectivity and forcing circuit relay fallback.

    ```bash theme={null}
    docker run --ulimit nofile=65536:65536 ...
    ```
  </Step>

  <Step title="Allocate sufficient CPU">
    go-quai performs PoW verification (kawpow, scrypt) on every received block. CPU starvation delays block processing and causes orphans. Allocate a minimum of 4 cores.

    ```bash theme={null}
    docker run --cpus=4 ...
    ```
  </Step>

  <Step title="Allocate sufficient memory">
    The working set is approximately 2 GB (LevelDB memdb + buffer pool + kawpow cache). Set the memory limit to at least 2x the working set to avoid GC thrashing.

    ```bash theme={null}
    docker run --memory=8g ...
    ```
  </Step>

  <Step title="Use local SSD storage for chain data">
    LevelDB is I/O intensive. Mount chain data from a local SSD, not network-attached storage.

    ```bash theme={null}
    docker run -v /mnt/ssd/quai-data:/root/.local/share/go-quai ...
    ```
  </Step>

  <Step title="Publish p2p ports on the host">
    The container must be directly reachable by peers. Publish both TCP and UDP on the p2p port.

    ```bash theme={null}
    docker run -p 4002:4002/tcp -p 4002:4002/udp ...
    ```
  </Step>

  <Step title="Enable pprof for diagnostics">
    Always enable pprof in containerized environments for debugging performance issues.

    ```bash theme={null}
    docker run ... quainetwork/go-quai:latest start --node.pprof=true
    ```
  </Step>
</Steps>

### Docker-Specific Options

These options are specific to containerized deployments:

| Option                                      | Purpose                                                                                                               |
| ------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- |
| `-v <host-path>:/root/.local/share/go-quai` | Persists chain data outside the container.                                                                            |
| `-p 4002:4002/tcp -p 4002:4002/udp`         | Publishes the p2p port for direct peer connections.                                                                   |
| `-p 8001:8001/tcp -p 9001:9001/tcp`         | Publishes the default WebSocket and HTTP RPC ports. Only expose these on trusted networks or behind a proxy/firewall. |
| `--network=host`                            | Uses host networking instead of Docker bridge networking. Remove `-p` port mappings when using host networking.       |
| `--ulimit nofile=65536:65536`               | Raises the file descriptor limit for peer connections and database files.                                             |
| `--cpus` and `--memory`                     | Applies resource limits. Use at least 4 CPUs and 8 GB memory for normal operation.                                    |
| `--restart unless-stopped`                  | Restarts the container after daemon restarts or node crashes unless explicitly stopped.                               |

### Public P2P Address

Most standalone Docker deployments can start without explicit p2p address flags. If the node is behind Kubernetes, host networking, a reverse proxy, or any setup where automatic NAT detection advertises the wrong address, pass an explicit public multiaddr:

```bash theme={null}
docker run ... quainetwork/go-quai:latest start \
  --node.external-addr=/ip4/<PUBLIC_IP>/tcp/4002 \
  --node.force-public=true \
  --node.portmap=false
```

`--node.external-addr` is the public address peers should dial. `--node.force-public` skips NAT detection, and `--node.portmap=false` disables automatic NAT port mapping when the port is already explicitly published.

***

## Kubernetes

These apply on top of the Docker requirements when orchestrating with Kubernetes.

### Resource Configuration

<Steps>
  <Step title="Use Guaranteed QoS to prevent CPU throttling">
    Burstable pods are subject to CFS (Completely Fair Scheduler) throttling. When the node gets throttled mid-block-processing, it cannot validate blocks in time, causing orphans. Set requests equal to limits.

    ```yaml theme={null}
    resources:
      requests:
        cpu: "4"
        memory: "8Gi"
      limits:
        cpu: "4"
        memory: "8Gi"
    ```
  </Step>

  <Step title="Raise file descriptor limits">
    Set ulimits via the container entrypoint or runtime class configuration. Verify inside the pod with `ulimit -n`.
  </Step>
</Steps>

### Networking

<Steps>
  <Step title="Use hostNetwork or hostPort for p2p ports">
    Overlay networks (Flannel, Calico, Cilium) add NAT layers that prevent direct peer connections. libp2p falls back to circuit relay when it cannot establish direct connections, adding significant latency.

    ```yaml theme={null}
    # Option A: hostNetwork (simplest, gives full host networking)
    spec:
      hostNetwork: true
      dnsPolicy: ClusterFirstWithHostNet

    # Option B: hostPort (exposes only specific ports)
    ports:
      - containerPort: 4002
        hostPort: 4002
        protocol: TCP
      - containerPort: 4002
        hostPort: 4002
        protocol: UDP
    ```
  </Step>

  <Step title="Set the external address flag to the host's public IP">
    The node must advertise an address that peers can actually reach.

    ```yaml theme={null}
    args:
      - --node.external-addr=/ip4/<PUBLIC_IP>/tcp/4002
      - --node.force-public=true
      - --node.portmap=false
    ```
  </Step>

  <Step title="Ensure network policies allow both ingress and egress">
    If using Cilium or Calico network policies, remember that once any policy selects an endpoint, all unmatched traffic is denied. You must explicitly allow:

    * Ingress to the p2p port from external peers
    * Egress to other peers and DNS
  </Step>

  <Step title="Verify pod labels match network policy selectors">
    A common mistake is defining a network policy that selects on labels the pod does not have. The policy silently does nothing and traffic may be blocked or unexpectedly open.

    ```bash theme={null}
    # Verify labels match
    kubectl get pods -n <namespace> --show-labels
    kubectl get networkpolicy -n <namespace> -o yaml
    ```
  </Step>
</Steps>

### Storage

<Steps>
  <Step title="Use local PersistentVolumes for chain data">
    Chain data must survive pod restarts. Use a `PersistentVolumeClaim` backed by local SSD storage, not network-attached volumes.
  </Step>

  <Step title="Pin pods to specific nodes">
    Use `nodeSelector` or node affinity to keep the pod on the same host as its local storage and maintain a stable network identity.

    ```yaml theme={null}
    spec:
      nodeSelector:
        kubernetes.io/hostname: <target-node>
    ```
  </Step>
</Steps>

### Availability

<Steps>
  <Step title="Set a PodDisruptionBudget">
    Prevent Kubernetes from evicting the node pod during rolling updates or cluster maintenance.

    ```yaml theme={null}
    apiVersion: policy/v1
    kind: PodDisruptionBudget
    metadata:
      name: quai-node-pdb
    spec:
      maxUnavailable: 0
      selector:
        matchLabels:
          app: quai-node
    ```
  </Step>
</Steps>

***

## Reverse Proxy (nginx)

If the node sits behind a reverse proxy (e.g., nginx on an edge VPS forwarding to the node), these settings are critical.

<Warning>
  A misconfigured proxy is the single most common cause of orphan rate issues in containerized deployments. The proxy sits in the critical path of every peer connection.
</Warning>

### Configuration

<Steps>
  <Step title="Use the stream module, not http">
    P2P traffic is raw TCP/UDP, not HTTP. Use nginx's `stream` module.

    ```nginx theme={null}
    stream {
        # ...
    }
    ```
  </Step>

  <Step title="Set proxy_timeout to 300s or higher">
    P2P connections are long-lived with idle periods between block messages. A low timeout (e.g., 1s) terminates connections during idle periods, forcing peers to reconnect through circuit relay.

    ```nginx theme={null}
    proxy_timeout 300s;
    proxy_connect_timeout 10s;
    ```
  </Step>

  <Step title="Create separate server blocks for TCP and UDP">
    `listen <port>;` is TCP only. QUIC transport requires an explicit UDP listener. Without it, UDP traffic is silently dropped even if the port is exposed.

    ```nginx theme={null}
    stream {
        upstream backend_tcp {
            server <node-address>:4002;
        }

        upstream backend_udp {
            server <node-address>:4002;
        }

        server {
            listen 4002;
            proxy_pass backend_tcp;
            proxy_timeout 300s;
            proxy_connect_timeout 10s;
        }

        server {
            listen 4002 udp reuseport;
            proxy_pass backend_udp;
            proxy_timeout 300s;
            proxy_responses 0;
        }
    }
    ```
  </Step>

  <Step title="Set proxy_responses to 0 for UDP">
    `proxy_responses 1` closes the UDP session after a single response packet. QUIC requires many packets per session. Set to `0` (unlimited) and let `proxy_timeout` handle session cleanup.
  </Step>

  <Step title="Raise worker_connections">
    The default of 1024 may be insufficient for a p2p node maintaining hundreds of peer connections. Set to 4096 or higher.

    ```nginx theme={null}
    events {
        worker_connections 4096;
    }
    ```
  </Step>
</Steps>

***

## Monitoring

<Tabs>
  <Tab title="CPU Throttling">
    Check if the container is being CPU-throttled by CFS:

    ```bash theme={null}
    # From inside the container
    cat /sys/fs/cgroup/cpu.stat | grep throttled

    # From Prometheus
    # Alert on: container_cpu_cfs_throttled_periods_total
    ```
  </Tab>

  <Tab title="File Descriptors">
    ```bash theme={null}
    # Inside the container
    ulimit -n

    # Check current usage
    ls /proc/1/fd | wc -l
    ```
  </Tab>

  <Tab title="pprof">
    Grab profiles to diagnose performance issues:

    ```bash theme={null}
    curl -o profile.pb.gz "http://<node-ip>:8085/debug/pprof/profile?seconds=30"
    curl -o heap.pb.gz "http://<node-ip>:8085/debug/pprof/heap"
    curl -o goroutine.pb.gz "http://<node-ip>:8085/debug/pprof/goroutine"
    curl -o mutex.pb.gz "http://<node-ip>:8085/debug/pprof/mutex"
    ```
  </Tab>

  <Tab title="Proxy Connectivity">
    Verify the proxy is listening on both protocols:

    ```bash theme={null}
    ss -tulnp | grep 4002
    ```

    You should see both TCP and UDP entries.
  </Tab>
</Tabs>

***

## Bare Metal vs Containerized Comparison

| Factor              | Bare Metal              | Containerized (Default)             | Fix                             |
| ------------------- | ----------------------- | ----------------------------------- | ------------------------------- |
| CPU scheduling      | Unthrottled             | CFS quota throttling                | Guaranteed QoS, dedicated cores |
| Networking          | Direct peer connections | NAT/overlay, circuit relay fallback | `hostNetwork` or `hostPort`     |
| File descriptors    | System default (65536+) | Container default (1024)            | Raise ulimit to 65536+          |
| Memory              | Unrestricted            | Cgroup OOM risk                     | Set limits to 2x working set    |
| Storage I/O         | Local NVMe/SSD          | Potentially network-attached        | Use local PVs                   |
| Connection lifetime | Unlimited               | Proxy may terminate early           | `proxy_timeout 300s`            |


# Run A Containerized Local Developer Network
Source: https://docs.qu.ai/guides/client/local-node

Run a containerized instance of Quai Network on a local machine.

## Introduction

Here, we'll installing and running a local instance of Quai Network in a containerized environment. The local network instance contains one full node, one CPU miner for each of the 9 shards, and multiple accounts with pre-loaded Quai and Qi balance. The containerized local network instance is designed to provide an easily configurable, low overhead development environment for builders.

## Install Dependencies

To run a local instance of Quai Network, you'll need to install a few dependencies.

<Steps>
  <Step title="Install Docker Compose">
    There are two methods to install Docker Compose:

    1. Install [Docker Desktop](https://docs.docker.com/compose/install/), which bundles Docker Compose. (**recommended**)
    2. Install the [Docker Compose plugin](https://docs.docker.com/compose/install/linux/) via CLI.

    If you're unsure which method is best for you, visit the [Installing Docker Compose](https://docs.docker.com/compose/install/) page for more information.
  </Step>

  <Step title="Install Local Node Runner">
    To install the Local Node Runner, you'll need to clone the [quai-local-node](https://github.com/dominant-strategies/quai-local-node) repository and navigate to it.

    ```bash theme={null}
    git clone https://github.com/dominant-strategies/quai-local-node
    cd quai-local-node
    ```
  </Step>
</Steps>

## Run Local Instance

Now that we've installed Docker Compose and navigated to the quai-local-node repository, we can run the local network instance.

### Start

To start the local network instance in a Docker container, run:

<Tabs>
  <Tab title="Run in Background">`bash docker-compose up -d `</Tab>
  <Tab title="Run in Foreground">`bash docker-compose up `</Tab>
</Tabs>

After running this command, you'll see each of the processes start up. One go-quai container, and 9 instances of quai-cpu-miner (one for each shard) should initialize like so:

```bash theme={null}
[+] Running 10/10
 ⠿ Container quai-local-node-paxos2-quai-cpu-miner-1   Started
 ⠿ Container quai-local-node-cyprus1-quai-cpu-miner-1  Started
 ⠿ Container quai-local-node-cyprus2-quai-cpu-miner-1  Started
 ⠿ Container quai-local-node-hydra2-quai-cpu-miner-1   Started
 ⠿ Container quai-local-node-paxos1-quai-cpu-miner-1   Started
 ⠿ Container quai-local-node-cyprus3-quai-cpu-miner-1  Started
 ⠿ Container quai-local-node-go-quai-1                 Started
 ⠿ Container quai-local-node-paxos3-quai-cpu-miner-1   Started
 ⠿ Container quai-local-node-hydra1-quai-cpu-miner-1   Started
 ⠿ Container quai-local-node-hydra3-quai-cpu-miner-1   Started
```

### View Logs

To view the logs for the `go-quai` container from your terminal, run:

```bash theme={null}
## print global logs
docker logs quai-local-node-go-quai-1

## follow global logs
docker logs -f --tail 0 quai-local-node-go-quai-1
```

If you'd like to access logs for a specific shard, you'll need to navigate to the `quai-local-node-go-quai-1` container and print logs directly.

```bash theme={null}
## navigate to go-quai container
docker exec -it quai-local-node-go-quai-1 sh

## follow logs for a specific zone
tail -f nodelogs/zone-0-0.log

## follow logs for a specific region
tail -f nodelogs/region-1.log
```

### Stop

If your local network instance is running in the background, run the following command to stop:

```bash theme={null}
docker-compose down
```

If your local network instance is running in the foreground, you can exit the terminal or use `CTRL+C` to stop the container.

## Custom Network Configuration

<Warning>
  The below configuration section is **only necessary for running non-default configurations**. If you only want to run the default network
  configuration of 9 slices and miners, you can skip this section.
</Warning>

The `quai-local-node` is configured to run all 9 shards (slices) and a CPU miner for each shard by default. It is recommended to run the default configuration for most use-cases. If you want to run a custom slice configuration, the section below details how to do so.

To alter the default local network configuration, you'll need to:

* Edit the slices the local node is running in the `config.toml` file
* Edit the number of CPU miners to match the number of shards in the `docker-compose.yml` file

<Steps>
  <Step title="Configure Slices">
    To start slice configuration, open the node config file with a text editor:

    ```bash theme={null}
    vim config/go-quai/config.toml
    ```

    Inside of this directory is the `config.toml` file. The config file has a `slices` variable with a default value of all 9 slices.

    ```toml theme={null}
    slices = '[0 0],[0 1],[0 2],[1 0],[1 1],[1 2],[2 0],[2 1],[2 2]'
    ```

    Edit the `slices` variable to match the number of shards you want to run. For example, if you want to run 3 shards, you could set the `slices` variable to `[0 0],[0 1],[0 2]`.
  </Step>

  <Step title="Configure CPU Miners">
    To edit the CPU miner config, you'll need to edit the `docker-compose.yml` file. Open the `docker-compose.yml` file with a text editor:

    ```bash theme={null}
    vim docker-compose.yml
    ```

    Each of the miner instances in the config file has a `replica` variable that defaults to `1`. If this value is set to `1`, a miner for that chain will be spun up on start, if the value is set to `0` the miner will not be spun up on start.

    ```yml theme={null}
    cyprus1-quai-cpu-miner:
      image: quainetwork/quai-cpu-miner:0.1.0-test.4
      volumes:
        - ./config/quai-cpu-miner/cyprus1-config.yaml:/root/config/config.yaml
      deploy:
        resources:
          limits:
            cpus: '1'
        replicas: 1
      command: ['./build/bin/quai-cpu-miner']
      networks:
        - quainet
    ```

    We need to ensure that a CPU miner is spun up (`replica` is set to `1`) for each of the slices we configured in the node above. For example, if we're running slices `[0 0],[0 1],[0 2]`, we need to set the `replica` value for the cyprus1, cyprus2, and cyprus3 miners to `1` and all the others to `0`.

    ```yml theme={null}
    cyprus1-quai-cpu-miner:
      ...
      replicas: 1

    cyprus2-quai-cpu-miner:
      ...
      replicas: 1

    cyprus3-quai-cpu-miner:
      ...
      replicas: 1

    paxos1-quai-cpu-miner:
      ...
      replicas: 0

    etc...
    ```
  </Step>
</Steps>

After matching the slices the node is running to the CPU miner configurations, you can [start up](#run-local-instance) your custom local network instance.

## Interacting With The Local Network

To interact with the local network instance, you can use the [Quais SDK](/sdk/introduction) or [JSON RPC API](/build/playground/overview). The network is accesible via specific networking ports on `localhost`.

| Shard    | HTTP Port | WS Port |
| -------- | --------- | ------- |
| Prime    | 9001      | 8001    |
| Cyprus   | 9002      | 8002    |
| Paxos    | 9003      | 8003    |
| Hydra    | 9004      | 8004    |
| Cyprus 1 | 9200      | 8200    |
| Cyprus 2 | 9201      | 8201    |
| Cyprus 3 | 9202      | 8202    |
| Paxos 1  | 9220      | 8220    |
| Paxos 2  | 9221      | 8221    |
| Paxos 3  | 9222      | 8222    |
| Hydra 1  | 9240      | 8240    |
| Hydra 2  | 9241      | 8241    |
| Hydra 3  | 9242      | 8242    |

### SDK

You can use the Quais SDK to create a provider connected to your local network instance and get chain data and send transactions.

```ts theme={null}
import { quais } from 'quais'

// create local provider
const provider = new quais.JsonRpcProvider('http://localhost')

// get block number on cyprus 1
const currentBlock = await provider.getBlockNumber('Cyprus1')
```

### JSON RPC API

You can make requests to your local network using the [JSON RPC API](/build/playground/overview) and [cURL](https://curl.se/):

```bash theme={null}
# get paxos 3 gas price
curl --request POST \
  --url http://localhost:9222 \
  --header 'Content-Type: application/json' \
  --data '{
  "jsonrpc": "2.0",
  "method": "quai_gasPrice",
  "params": [],
  "id": 1
}'
```

## Accounts

The local network we just spun up starts with a number of accounts pre-loaded with Quai and Qi tokens for each shard. A full list of accounts with pre-loaded balances, sorted by shard and ledger, can be found in the [genallocs](https://github.com/dominant-strategies/quai-local-node/tree/main/genallocs) directory of the quai-local-node repository.

<Warning>
  These accounts are for local testing purposes and should not be used in any production environment. They are not secure and should only be
  used for testing.
</Warning>

For quick reference, 1 account for each shard and ledger can be found below:

### Quai Accounts

| Shard   | Address                                    | Private Key                                                        | Balance    |
| ------- | ------------------------------------------ | ------------------------------------------------------------------ | ---------- |
| Cyprus1 | 0x000001273B55E9e5998328216dB1b130c231221C | 0xb3c87ca9645adcf75be5c4d6609fd257f897fd53849c7ecca81acae9966a6ec0 | 10000 Quai |
| Cyprus2 | 0x010001D025371794a6eDb5feE8aC2F384EdD7463 | 0xcea8ebb619f8e4ea11ee75cb72221a6f39591a99d7cf688de9f30832809fb751 | 10000 Quai |
| Cyprus3 | 0x02000415996A1B0cFF4b2FD078c779cF6C3E9AaC | 0xfc86fae56f462d2ae43bca8f819b1137c9e3150ba3ff79d4d5068b6e39c1c975 | 10000 Quai |
| Paxos1  | 0x10000197Ec7c3e6ce4D9a832c0641528c5e268A6 | 0x01d872f0bc5f94490c2ed9026d58a116656dcb3c997f42062d01799e5b458062 | 10000 Quai |
| Paxos2  | 0x11000207A6723c18085c12F50F62929bb78932c4 | 0x1d7a3a668ac8b20bf538a6d1060de043f10b1db5f1df2140fa0e8d479820e763 | 10000 Quai |
| Paxos3  | 0x120000833E752B14A00eBB2c00eF0FD7C90C2123 | 0xc0061e94c526e7d9d97a2874f129e72e4f821a8f78ca2fd8198c005bc14e2a92 | 10000 Quai |
| Hydra1  | 0x2000011eCb5FDEA6Eb074cbe60b6Ad372948d99a | 0xc77fb4c5b1612f702ef097561f75ee5876987ef547977020a86528fbc9f7bbbc | 10000 Quai |
| Hydra2  | 0x2100042dEf9D880e029Ca948f97C180c202bd743 | 0x44af4c54c44d96bbf3d9c602967822246381d2287fe544fd5480d05b25b80bb9 | 10000 Quai |
| Hydra3  | 0x2200035A5A89846AD708d8732B6c85dFAbE35489 | 0x8cd878d69b1b848b3c98c623e4e56e3b0ed1035984f6f721a99ef716637e3382 | 10000 Quai |

### Qi Accounts

| Shard   | Address                                    | Private Key                                                        | Balance   |
| ------- | ------------------------------------------ | ------------------------------------------------------------------ | --------- |
| Cyprus1 | 0x0080038f1C9a96b196914939301F9a46d7E27e7E | 0x5b18d340e2e5172a90dfcc43c800519cf4a77b82750b8964b3f421dc929eac53 | 100000 Qi |
| Cyprus2 | 0x01800Daf0f10f7d0CceF2B77893d5a7f86D6D406 | 0x4500c9cef91ac29479cf50a00c49d27ba14e84df83b8e332db34fa1cbdd799b7 | 100000 Qi |
| Cyprus3 | 0x02800a7c404409166D903Dd3421595112f1DaF4D | 0xbc144acdd4d53488e4005d404f42450a879eb1015a6f4bbf80956b4810b5a068 | 100000 Qi |
| Paxos1  | 0x1080049337283F6c3aDfD535835258a03CF2b921 | 0x511930ce12cbf86325eb2652459b6a47b75ddc892a09549f094f0011062a11f4 | 100000 Qi |
| Paxos2  | 0x1180008531658Aa78161D00689267725C771aD3d | 0x89086104efd789c7de9ee69beb44ad70818a772a90b6d3f3ec26da930a47a2da | 100000 Qi |
| Paxos3  | 0x12800163E05c66e107864D9c18067468cf79990f | 0xa7995e0942e6510a2fd3461c0dbe081fc8e79c6e891fd2fcde5897e41700789a | 100000 Qi |
| Hydra1  | 0x208000B3ED3a21D2018E72533D55679760C7a8d2 | 0x36f009591733e706085ba4b6c3c6bbc8e35fa5e9f075979650523c18f18dacec | 100000 Qi |
| Hydra2  | 0x218000a39174Db63f0047DC571CB2279d6D29434 | 0xf07d9c6d2ee5cd1f5661d87afea21cd21e4a52ff1ea4851b7507b4ef673c4311 | 100000 Qi |
| Hydra3  | 0x228003fD91A5B55dBAfc95384e3A8DBf30B21AA8 | 0x2c1b28175b12d8fdeb8355918fcb7492fcbc7b118ecf301cd928477815084312 | 100000 Qi |


# Run A Node
Source: https://docs.qu.ai/guides/client/node

How to start and run a Quai Network node.

<Warning>
  Running go-quai on Windows or WSL2 is not currently supported.
</Warning>

### Requirements

To run a Quai Network node, the following specifications are suggested:

<CardGroup>
  <Card icon="microchip" title="Fast CPU with 8+ cores" />

  <Card icon="usb-drive" title="16GB+ RAM" />

  <Card icon="server" title="Fast SSD with at least 1TB free space" />

  <Card icon="signal-stream" title="10+ MBit/sec download Internet service" />
</CardGroup>

## Install Dependencies

<Steps>
  <Step title="Go v1.23.0+">
    <Tabs>
      <Tab title="Linux Snap Install">
        *Snap is not default installed on all Linux distros*

        ```bash theme={null}
          # install snapd if you don't have it already
          sudo apt install snapd

          # install go
          sudo snap install go --classic
        ```
      </Tab>

      <Tab title="MacOS Install">
        Before installing go, make sure you have [homebrew](https://brew.sh/) installed as it is not installed by default on MacOS.

        ```bash theme={null}
        brew install go
        ```
      </Tab>
    </Tabs>

    If you're not on Ubuntu or MacOS, instructions on how to install go directly can be found on the [golang installation page](https://go.dev/doc/install).
  </Step>

  <Step title="Git, Make, and G++">
    <Tabs>
      <Tab title="Linux Install">
        Install git, make, and g++ with the following command:

        ```bash theme={null}
        # install git and make
        sudo apt install git make g++
        ```
      </Tab>

      <Tab title="MacOS Install">
        Install git and make with the following command:

        <Info>
          MacOS machines already have g++ installed.
        </Info>

        ```bash theme={null}
        # install git and make
        brew install git make
        ```
      </Tab>
    </Tabs>
  </Step>
</Steps>

## Node Configuration

### Start

<AccordionGroup>
  <Accordion title="Mainnet (Colosseum)">
    ```bash theme={null}
    # Clone go-quai and checkout latest release
    git clone https://github.com/dominant-strategies/go-quai
    cd go-quai
    git checkout <latest-tag>
    make go-quai

    # Start node
    ./build/bin/go-quai start \
    --node.slices '[0 0]' \
    --node.quai-coinbases '0x0000000000000000000000000000000000000001' \
    --node.qi-coinbases '0x0080000000000000000000000000000000000001' \
    ```
  </Accordion>

  <Accordion title="Mainnet Testnet (Orchard)">
    <Warning>
      The Orchard testnet requires using the `orchard` branch of go-quai. Using any other branch or tag will result in sync issues or genesis incompatibility.
    </Warning>

    ```bash theme={null}
    # Clone go-quai and checkout orchard branch
    git clone https://github.com/dominant-strategies/go-quai
    cd go-quai
    git checkout orchard
    make go-quai

    # Start node
    ./build/bin/go-quai start \
    --node.slices '[0 0]' \
    --node.genesis-nonce 62242624366553750196964614682162313 \
    --node.environment "orchard" \
    --node.quai-coinbases '0x0000000000000000000000000000000000000001' \
    --node.qi-coinbases '0x0080000000000000000000000000000000000001' \
    ```
  </Accordion>

  <Accordion title="Local Developer Network">
    ```bash theme={null}
    # Clone go-quai and checkout latest release
    git clone https://github.com/dominant-strategies/go-quai
    cd go-quai
    git checkout <latest-tag>
    make go-quai # make debug is also available for line by line debugging


    # Start node
    ./build/bin/go-quai start \
    --node.slices '[0 0]' \
    --node.environment "local" \
    --node.quai-coinbases '0x0000000000000000000000000000000000000001' \
    --node.qi-coinbases '0x0080000000000000000000000000000000000001' \
    ```
  </Accordion>
</AccordionGroup>

<Warning>
  The coinbase values above are set to dummy values. If you do not replace them
  with your own addresses, you will not receive block rewards.
</Warning>

This will spin up a node using the values of the `node.slices`, `node.quai-coinbases`, `node.qi-coinbases` flags in your command. Logs should begin printing to the terminal.

### Stop

Stopping your node should be done any time you make changes to your config file or prior to shutting your machine down. A node instance can terminated using `CTRL+C`.

<Note>
  If you're running a miner, `CTRL+C` may not work. You must kill the miner
  process prior to stopping the node.
</Note>

### Environment Variables

There are a few key variables required to run a Quai node. **They will be passed as arguments in the [start command](#start)**.

* `quai-coinbases` and `qi-coinbases`: the addresses in each ledger that block rewards and miner tips are paid to.
* `miner-preference`: the percentage of block rewards that should be paid out on average in Quai or Qi tokens.
* `slices`: the slices of the network that the node will run.

<Note>
  There are a number of more advanced parameters that can be passed as arguments
  that *will not be covered* in this article.
</Note>

<Steps>
  <Step title="Configure Mining Addresses">
    Coinbases will be passed to the `start` command similar to below, with your own addresses for the chains that you intend to mine. You can generate addresses for each shard and ledger easily with [Pelagus Wallet](https://chromewebstore.google.com/detail/pelagus/nhccebmfjcbhghphpclcfdkkekheegop).

    You must generate **unique Quai and Qi addresses** for each shard your node is running and **pass them as coinbase flags to the run command**. There is a unique coinbases flag for each ledger:

    * `quai-coinbases`: Coinbases for Quai ledger
    * `qi-coinbases`: Coinbases for Qi ledger

    ```bash theme={null}
    # single slice node running cyprus1, one quai address + one qi address
    --node.quai-coinbases '0x0000000000000000000000000000000000000000'
    --node.qi-coinbases '0x0080000000000000000000000000000000000000'
    ```

    <Note>
      The Qi mining address starts with a "0x00...", this is not to be confused with the Qi payment address. You can find the Qi mining address in the settings of the Pelagus Wallet.
    </Note>
  </Step>

  <Step title="Block Reward Prefernce">
    The Quai protocol can payout block rewards and miner tips in either [Quai](/learn/tokenomics/quai-emissions) or [Qi](/learn/tokenomics/qi-emissions) tokens. While miners have no ability to determine what token their miner tips are paid out in, the do have the ability to set their block reward payout token preference to either Quai or Qi.

    Block reward token preference can be set using the `miner-preference` flag. The `miner-preference` flag is a percentage scale that can be set to values between 0 and 1, indicating the proportion of block rewards that should be paid out in Quai or Qi tokens.

    Some examples:

    * `0`: 100% Quai preference, all block rewards are paid out in Quai
    * `0.25`: 3/1 Quai preference
    * `0.5`: Even split, on average block rewards are paid out equally in Quai and Qi
    * `0.75`: 3/1 Qi preference
    * `1`: 100% Qi preference, all block rewards are paid out in Qi

    Pass the `miner-preference` flag in the `start` command with a value between 0 and 1 like below:

    ```bash theme={null}
    # no preference (default)
    --node.miner-preference 0.5
    ```

    ```bash theme={null}
    # 100% Quai preference
    --node.miner-preference 0
    ```

    ```bash theme={null}
    # 100% Qi preference
    --node.miner-preference 1
    ```
  </Step>

  <Step title="Reward Lockup Period">
    The Quai protocol immediately pays out block rewards as blocks are mined, but are subject to a lockup period.

    * Quai Block rewards are sent to the coinbase of the miner after the lockup period has elapsed.
    * Qi Block reward tokens are sent to the coinbase of the miner and register as balance, but are deemed "not spendable" until they are unlocked.

    The lockup period is configurable by miners using the `--node.coinbase-lockup` flag. The protocol provides additional incentives for miners to lock up their block rewards for a longer period of time.

    The available values for `--node.coinbase-lockup` and their corresponding period and reward boost are:

    | Lock Byte | Period (blocks) | Period (days) | Year 1 | Year 2 | Year 3 | Year 4 | Year 5+ |
    | --------- | --------------- | ------------- | ------ | ------ | ------ | ------ | ------- |
    | `0*`      | 241,920         | 2 weeks       | 0%     | 0%     | 0%     | 0%     | 0%      |
    | `1`       | 1,555,200       | 3 months      | 3.50%  | 2.68%  | 1.86%  | 1.04%  | 0.22%   |
    | `2`       | 3,110,400       | 6 months      | 10.00% | 7.66%  | 5.31%  | 2.97%  | 0.63%   |
    | `3`       | 6,220,800       | 12 months     | 25.00% | 19.14% | 13.28% | 7.42%  | 1.56%   |

    <sub>\*Base maturity period</sub>

    <Note>The reward percentage decreases linearly between each year shown in the table.</Note>

    Pass the `--node.coinbase-lockup` flag in the `start` command like below:

    ```bash theme={null}
    # minimum lockup (default)
    --node.coinbase-lockup 0
    ```

    ```bash theme={null}
    # maximum lockup
    --node.coinbase-lockup 3
    ```
  </Step>

  <Step title="Slices">
    Set the `node.slices` flag in your run command to whichever slices of the network you would like to run.

    In the codebase, a slice is identified by its [region and zone index](/client/node#networking-and-conventions). Region and zone indices are 0-indexed and range from 0-2.

    <Tip>The Colosseum Mainnet and Orchard Testnet only support the `[0 0]` slice.</Tip>

    ```bash theme={null}
    # single slice node running cyprus1
    --node.slices '[0 0]'
    ```
  </Step>

  <Step title="Network Environment & Genesis Nonce">
    To connect to Quai, you must have the correct genesis nonce for the intended network. The nonce acts as a password that allows your node to correctly compute the first canonical block in the chain.

    You'll pass the genesis nonce to your node on start-up using the `--node.genesis-nonce` flag.

    ```bash theme={null}
    # Orchard Testnet geneis nonce
    --node.genesis-nonce 62242624366553750196964614682162313
    --node.environment "orchard"
    ```

    Options for `--node.environment` are: `"colosseum"` (mainnet), `"orchard"` (mainnet testnet), `"garden"` (mainnet devnet), and `"local"`.

    | Environment | Description       | Genesis Nonce                       |
    | ----------- | ----------------- | ----------------------------------- |
    | `colosseum` | Mainnet           | 23621466532946281564673705261963422 |
    | `orchard`   | Mainnet testnet   | 62242624366553750196964614682162313 |
    | `local`     | Local development | N/A                                 |
  </Step>

  <Step title="Run an Index Node">
    To provide UTXO data to external clients your node will need to index all UTXO address information. To enable this you'll pass the following flag to your client upon startup. Keep in mind this will consume more storage than running without it.

    ```bash theme={null}
    # Index UTXO address information
    --node.index-address-utxos "true"
    ```

    <Tip>When starting your node with this flag you must sync from an official [snapshot](/guides/client/node#download-and-sync-from-snapshot). If you disable and re-enable this flag in the future you will need to re-sync from an official [snapshot](/guides/client/node#download-and-sync-from-snapshot).</Tip>
  </Step>
</Steps>

## Check Log Output

Starting a node will run all instances of go-quai in the foreground and also create a directory named nodelogs to store more specific logs from the node. Outputs from the node will be piped to a context specific `.log` file inside of the nodelogs directory. To view the log output for a specific location, use:

```bash theme={null}
# view global logs (recommended)
tail -f nodelogs/global.log

# view specific region or zone logs
tail -f nodelogs/region-0.log
# OR
tail -f nodelogs/zone-0-0.log
```

Checking the node logs output is the best way to *verify that your full node is running correctly*. You can also easily view node logs in your favorite IDE or text editor.

The outputs of a node that has **started correctly** should look similar to below.

```log theme={null}
INFO   [10-02|19:42:12.077] Loading config from file: /root/.config/go-quai/config.toml
INFO   [10-02|19:42:12.108] Loading config from environment variables with prefix: 'GO_QUAI_'
INFO   [10-02|19:42:12.109] Global logger started                         fields.level=info path=./nodelogs/global.log
INFO   [10-02|19:42:12.137] Starting v0.19.0-pre on the lighthouse network
INFO   [10-02|19:42:12.137] node version                                  commit= date=
INFO   [10-02|19:42:12.867] node created: 12D3KooWKQgbSobfca6KnB55XZtMyntSaCNXTaTdoisPGzrgKFjA
INFO   [10-02|19:42:13.182] Coinbase Addresses: map[cyprus1:0x0000000000000000000000000000000000000000]
INFO   [10-02|19:42:13.469] Finished connecting miner endpoints
INFO   [10-02|19:42:14.576] Finished connecting miner endpoints
INFO   [10-02|19:42:14.577] starting P2P node...
INFO   [10-02|19:42:14.577] Starting metrics
INFO   [10-02|19:42:14.578] Event: 'Local address updated': /ip4/127.0.0.1/tcp/4001/p2p/12D3KooWKQgbSobfca6KnB55XZtMyntSaCNXTaTdoisPGzrgKFjA
```

**To stop log outputs to the terminal, you can use CTRL+C.**

<Warning>Depending on what your node is currently doing, your logs may not look **exactly** the same as above.</Warning>

## Checking Sync Progress

If your node has started correctly, it will begin syncing chain state from peers. There are a few ways to check the progress of the sync.

From the **command line**, we can run the following command(s) to print the list of blocks that have been appended. **Replace** `location-to-print-here.log` **with the file name of the logs you'd like to print**.

```bash theme={null}
# Print all appended blocks
cat nodelogs/location-to-print-here.log | grep Appended

# Continuously print new appended blocks
tail -f nodelogs/location-to-print-here.log | grep Appended

# Continuously print appended blocks across all chains
tail -f nodelogs/* | grep Appended
```

The output should look similar to below:

```bash theme={null}
INFO   [09-18|10:18:17.273] Appended new block                       number=[102 1934 40392] hash=0x0000067368b679ce7994dbd6e3dfe93a5e5fe16642a6083604fd405556836cbe difficulty=405369 uncles=0 txs=0 etxs=0 gas=0 gasLimit=5000000 root=0x7df4c77d1463a5e4c7d5f5446476e34df01cf14b6226b7d83ccab072bc302edc order=2 location=[0 0] elapsed=2.019ms
INFO   [09-18|10:18:17.736] Appended new block                       number=[102 1934 40393] hash=0x0000285b7ffa020c8f9f5f8832381593170d1d7618ad2fae8202350a0d81acac difficulty=405875 uncles=0 txs=0 etxs=0 gas=0 gasLimit=5000000 root=0x81954cf5d93a979890641acffe7496965ff4602ad2b24d24ab5356ba52072c39 order=2 location=[0 0] elapsed=1.933ms
INFO   [09-18|10:18:17.803] Appended new block                       number=[102 1934 40394] hash=0x00000d6f0d100a8d254088090876a6ab911720af7e7bc6454f5d1a01417f786f difficulty=406382 uncles=0 txs=0 etxs=0 gas=0 gasLimit=5000000 root=0x8eb0b430e2df8f91a180b6f29fea46430c9014ccde42fa538df62bf3251dff03 order=2 location=[0 0] elapsed=2.005ms
INFO   [09-18|10:18:18.511] Appended new block                       number=[102 1934 40395] hash=0x00001211f391c0a162701ad0dcbdef47f4efe96b3fb5f77e1f0b75b6ff439312 difficulty=406889 uncles=0 txs=0 etxs=0 gas=0 gasLimit=5000000 root=0xc810b3d05f9a9b7f4fee3da271d3544cba26b6368f84ee5e5e885cbe4fd11cab order=2 location=[0 0] elapsed=2.147ms
```

**To check the progress of your node's sync, compare the number of the latest block output from the above command to the current height of the chain you're running on the** [**Quai node stats page**](https://stats.quai.network/).

<Warning>
  If your node temporarily stops appending during sync, do not stop it. Allow it to continue running, and only reach out for support if the
  node has not appended a block for over 1 hour.
</Warning>

## Update Your Node

<Warning>
  Initiating the node update process while the node or manager are currently running could cause issues. Make sure to stop all processes before updating.
</Warning>

To update a node, first **make sure to stop all instances of go-quai** before proceeding.

After stopping the node, you should pull any updated code using:

```bash theme={null}
git fetch --all
```

Checkout the [latest release of go-quai](https://github.com/dominant-strategies/go-quai/tags):

```bash theme={null}
git checkout put-latest-release-here
```

Finally, rebuild the source using:

```bash theme={null}
make go-quai
```

After pulling any new code and rebuilding the source, you can safely restart the node and continue running.

## Reset and Clear

<Warning>
  Resetting your node and clearing your database will remove any state you have synced. This is a non-reversible action and any commands noted below should be utilized with caution.
</Warning>

Developers and node runners may find that situations arise where they need to completely clear your node of synced state or do a full reset in the case of an issue or bug. A full reset of a node involves stopping the node, clearing the current nodelogs, and removing all synced state.

**Reminder, resetting your node is non-reversible and should only be done if you understand the implications of removing all synced state.**

<Tabs>
  <Tab title="Linux">
    For **Linux Machines**, we'll remove the `nodelogs` directory and the base `~/.local/share/go-quai` directory which contains all synced state. To do this, run the following command:

    ```bash theme={null}
    rm -rf nodelogs ~/.local/share/go-quai
    ```
  </Tab>

  <Tab title="MacOS">
    For **MacOS machines**, we'll use a different command to remove the same directories:

    ```bash theme={null}
    rm -rf nodelogs ~/Library/Application\ Support/go-quai
    ```
  </Tab>
</Tabs>

After running the above command, the node has been fully reset and is ready to be restarted.

## Create Backup/Snapshot

You can create your own backup or snapshot to:

* Store for later.
* Move to another machine.

1. Shut down the node cleanly. You can use `ctrl+c`.
2. Remove the peer db. It is stored in the genesis hash folder.

   <Tabs>
     <Tab title="Mainnet">
       ```bash theme={null}
       # Linux
       rm -rf ~/.local/share/go-quai/0xd0c4fae4dc06d3558c7631f6665cca93931cfc8891729fe1bdaa1024b0db9c98

       # MacOS
       rm -rf ~/Library/Application\ Support/go-quai/0xd0c4fae4dc06d3558c7631f6665cca93931cfc8891729fe1bdaa1024b0db9c98
       ```
     </Tab>

     <Tab title="Orchard">
       ```bash theme={null}
       # Linux
       rm -rf ~/.local/share/go-quai/0x0a66d053d111b0f8321aa82904a75b0a74768f8c14d783edf8b5929c33d44df2

       # MacOS
       rm -rf ~/Library/Application\ Support/go-quai/0x0a66d053d111b0f8321aa82904a75b0a74768f8c14d783edf8b5929c33d44df2
       ```
     </Tab>
   </Tabs>
3. Compress the database for smaller storage and faster transfers.

   <Tabs>
     <Tab title="Linux">
       ```bash theme={null}
       tar -I zstd -cvf mainnet-snapshot.tar.zst ~/.local/share/go-quai
       ```
     </Tab>

     <Tab title="MacOS">
       Ensure that zstd is installed in your version of MacOS. You can run:

       ```bash theme={null}
       brew install zstd
       tar --use-compress-program=zstd -cvf mainnet-snapshot.tar.zst ~/Library/Application\ Support/go-quai
       ```
     </Tab>
   </Tabs>

## Download and Sync from Snapshot

Common reasons for syncing from a snapshot include:

* Reducing syncing times
* Restarting a node on a new machine/drive

<Warning>
  Please be aware that when you are syncing from a snapshot, you are trusting the contents of the snapshot. For your node to fully verify the network, you must sync from genesis.
</Warning>

To restore your node's database from a snapshot you'll first need to **stop your node**. You can then download the latest official snapshot from the official snapshot link or from the CLI by running the command below. The link will be added and periodically updated here once the first snapshot for Quai Mainnet is taken.

<Tabs>
  <Tab title="Mainnet">
    ```bash theme={null}
    wget https://snapshot.qu.ai/mainnet-snapshot.tar.zst
    ```

    <Tabs>
      <Tab title="Linux">
        To restore your database from a snapshot, use:

        ```bash theme={null}
          # Remove current db
          # This command will permanently delete all state that you have synced thus far
          rm -rf ~/.local/share/go-quai

          # Expand compressed db
          tar -I 'zstd -T0' -xvf mainnet-snapshot.tar.zst

          # Copy db into db directory
          cp -r mainnet-snapshot ~/.local/share/go-quai
        ```
      </Tab>

      <Tab title="MacOS">
        To restore your database from a snapshot, use:

        ```bash theme={null}
          # Remove current db
          # This command will permanently delete all state that you have synced thus far
          rm -rf ~/Library/Application\ Support/go-quai

          # Expand compressed db
          tar --use-compress-program='zstd -T0' -xvf mainnet-snapshot.tar.zst

          # Copy db into db directory
          cp -r mainnet-snapshot ~/Library/Application\ Support/go-quai
        ```
      </Tab>
    </Tabs>
  </Tab>

  <Tab title="Orchard Testnet">
    ```bash theme={null}
    wget https://snapshot.qu.ai/orchard-snapshot.tar.zst
    ```

    <Tabs>
      <Tab title="Linux">
        To restore your database from a snapshot, use:

        ```bash theme={null}
          # Remove current db
          # This command will permanently delete all state that you have synced thus far
          rm -rf ~/.local/share/go-quai

          # Expand compressed db
          tar -I 'zstd -T0' -xvf orchard-snapshot.tar.zst

          # Copy db into db directory
          cp -r orchard-snapshot ~/.local/share/go-quai
        ```
      </Tab>

      <Tab title="MacOS">
        To restore your database from a snapshot, use:

        ```bash theme={null}
          # Remove current db
          # This command will permanently delete all state that you have synced thus far
          rm -rf ~/Library/Application\ Support/go-quai

          # Expand compressed db
          tar --use-compress-program='zstd -T0' -xvf orchard-snapshot.tar.zst

          # Copy db into db directory
          cp -r orchard-snapshot ~/Library/Application\ Support/go-quai
        ```
      </Tab>
    </Tabs>
  </Tab>
</Tabs>


# Node Monitoring
Source: https://docs.qu.ai/guides/client/node-monitoring

Monitor the performance of your Quai Network Node.

## Introduction

Monitoring your node's performance in real time allows you to ensure that it is running smoothly and efficiently. The go-quai client bundles a monitoring solution that allows you to track the health and performance of your node. This guide will walk you through setting up Grafana and Prometheus to monitor your node.

## Prerequisites

|                                                   |                                                   |
| ------------------------------------------------- | ------------------------------------------------- |
| [Quai Network Node](/participate/node/run-a-node) | A Quai Network node to enable monitoring for.     |
| [Grafana](https://grafana.com/)                   | An open-source analytics and monitoring solution. |
| [Prometheus](https://prometheus.io/)              | An open-source monitoring and alerting toolkit.   |

## Install Dependencies

<Note>
  If you are configuring monitoring for an external node, you will need to forward the Prometheus and Grafana ports to your local machine.
  Grafana runs on **port 3000**, and Prometheus runs on **port 9090** by default.
</Note>

### Prometheus

Installing Prometheus can be done from the command line using your favorite package manager. Run the following command to install Prometheus on a Linux machine:

```bash theme={null}
sudo apt install prometheus -y
```

On first install, it can be useful to enable the Prometheus service to start on boot. This will prevent you from having to manually start the service every time you reboot your machine. To enable the Prometheus service, run the following command:

```bash theme={null}
sudo systemctl enable prometheus
```

### Grafana

You can install Grafana by following the instructions on the [official Grafana download page](https://grafana.com/grafana/download?edition=oss).

For example, on Ubuntu, you can install Grafana using the following commands:

```bash theme={null}
sudo apt-get install -y adduser libfontconfig1 musl
wget https://dl.grafana.com/oss/release/grafana_10.4.2_amd64.deb
sudo dpkg -i grafana_10.4.2_amd64.deb
```

## Configuration

Prometheus requires a configuration file to scrape metrics from your node. `go-quai` has a pre-configured Prometheus configuration file that you can use. To use this configuration file, run the following command:

```bash theme={null}
# navigate to the go-quai directory
cd go-quai

# copy the configuration file
sudo cp metrics_config/prometheus.yml /etc/prometheus/
```

<Note>
  You only need to copy the configuration file once. If you have already copied the file, you do not need to run the command again.
</Note>

## Initialize Node Monitoring

To start monitoring your node, you'll need to ensure that both Prometheus and Grafana are running. You can start both services using the following commands:

```bash theme={null}
sudo systemctl start prometheus
sudo systemctl start grafana-server.service
```

Once both services are running, you'll need to start your Quai Network node with the `--metrics.enabled` flag. This will enable Prometheus to scrape metrics from your node. To start your node with the `--metrics.enabled` flag, run your normal node startup command with the metrics flag added to it:

```bash theme={null}
# start your node with the added metrics flag
./build/bin/go-quai start <--startup-flags> --metrics.enabled
```

If you're not familiar with other go-quai startup flags, refer to the [Run a Node](/guides/client/node#environment-variables) guide.

### Access Grafana

To access Grafana, open your web browser and navigate to `http://localhost:3000`. You will be prompted to log in. The default username and password are both `admin`.

<Warning>
  If you are monitoring a local machine, you may keep the default password and username or change them. **If you are monitoring an external
  node, i.e. you have forwarded your ports, it is highly recommended to change the default password and username**.
</Warning>

### Add Prometheus to Grafana

Once you have logged into Grafana, we need to add Prometheus as a data source. To do this, follow these steps:

<Steps>
  <Step title="Open Connections Menu">Click on `Connections` in the left-hand menu.</Step>
  <Step title="Add New Connection">In the connections menu, Click on `Add new connection`.</Step>
  <Step title="Select Prometheus">Select `Prometheus` from the list of data sources. You may need to search for it.</Step>

  <Step title="Add New Data Source">
    Click on `Add new data source` in the upper right. This will take you to a settings tab where you can configure Prometheus.
  </Step>

  <Step title="Set Prometheus Server URL">
    In the `Connection` section of the settings tab, enter the following URL:

    * `http://localhost:9090` if you're monitoring a local machine
    * `http://EXTERNALIPADDRESS:9090` if you are monitoring an external node
  </Step>
</Steps>

After adding Prometheus as a data source, we can create a dashboard to monitor our node. To do this, follow these steps:

<Steps>
  <Step title="Open Dashboards">Click on `Dashboards` in the left-hand menu.</Step>
  <Step title="Create New Dashboard">Click the `New` button.</Step>
  <Step title="Import Configuration">Click the `Import` button.</Step>

  <Step title="Paste Configuration">
    Paste the configuration file located in `metrics_config/grafana_metrics.json` into the text box. You can find the configuration file
    [here](https://github.com/dominant-strategies/go-quai/blob/main/metrics_config/grafana_metrics.json)
  </Step>
</Steps>

### Monitor Your Node

After setting the data source and importing the configuration file, you should see a dashboard similar to the one below that displays the health and performance of your node. **Your node is now being monitored in real time.**

<Frame>
  <img />
</Frame>


# Solo Mining (StratumX)
Source: https://docs.qu.ai/guides/client/solo-mining

Mine Quai Network directly using the built-in Stratum server for 100% block rewards.

## Introduction

Quai Network includes a built-in Stratum v1 compatible server that allows you to mine directly to your node without a mining pool. This is a **solo mining** setup where you receive 100% of any block rewards directly to your configured address - there are no pool fees.

The Stratum server translates between the standard Stratum mining protocol and Quai's workshare system. Miners connect using standard stratum-compatible software and receive jobs derived from pending Quai headers. Valid shares that meet the workshare difficulty are submitted to the node.

### Requirements

In order to solo mine on Quai Network, you'll need the following:

<CardGroup>
  <Card title="Synced go-quai node" href="/guides/client/node" icon="computer" />

  <Card title="Quai or Qi address" href="/learn/use-quai" icon="wallet" />

  <Card title="Mining hardware" icon="microchip" />
</CardGroup>

## Quick Start

Enable the Stratum server by adding these flags when starting your go-quai node:

```bash theme={null}
go-quai start \
  --node.stratum-enabled \
  --node.stratum-sha-addr "0.0.0.0:3333" \
  --node.stratum-scrypt-addr "0.0.0.0:3334" \
  --node.stratum-kawpow-addr "0.0.0.0:3335" \
  --node.stratum-api-addr "0.0.0.0:3336" \
  --node.stratum-name "my-node"
```

<Warning>
  Do not start mining before confirming your node has fully synced. Mining while your node is not synced will result in the mining of **invalid blocks** and **wasted hash**.
</Warning>

## Configuration Flags

The Stratum server can be configured using the following command-line flags:

| Flag                         | Default        | Description                                   |
| ---------------------------- | -------------- | --------------------------------------------- |
| `--node.stratum-enabled`     | `false`        | Enable stratum endpoints                      |
| `--node.stratum-sha-addr`    | `0.0.0.0:3333` | Listen address for SHA256 miners              |
| `--node.stratum-scrypt-addr` | `0.0.0.0:3334` | Listen address for Scrypt miners              |
| `--node.stratum-kawpow-addr` | `0.0.0.0:3335` | Listen address for KawPoW miners              |
| `--node.stratum-api-addr`    | `0.0.0.0:3336` | Listen address for HTTP API                   |
| `--node.stratum-name`        | `""`           | Unique node identifier (for multi-node pools) |

## Supported Algorithms

Each algorithm has its own dedicated port:

| Port | Algorithm | Compatible Hardware |
| ---- | --------- | ------------------- |
| 3333 | SHA-256   | SHA-256 ASICs       |
| 3334 | Scrypt    | Scrypt ASICs        |
| 3335 | KawPoW    | GPUs                |

Connect your miner to the appropriate port for your hardware.

## Miner Configuration

Configure your mining software with the following settings:

| Setting      | Value                                  |
| ------------ | -------------------------------------- |
| **Pool URL** | `stratum+tcp://<node-ip>:<port>`       |
| **Username** | Your payout address (Quai or Qi)       |
| **Password** | Optional: `d=<difficulty>` (see below) |

### Payout Address

You can mine to either a **Quai** or **Qi** address:

* **Quai address**: Rewards paid in Quai
* **Qi address**: Rewards paid in Qi

### Password Field (Optional)

The password field accepts optional parameters:

| Parameter             | Description                 |
| --------------------- | --------------------------- |
| `d=<difficulty>`      | Set custom share difficulty |
| `frequency=<seconds>` | Set job update frequency    |
| `lock=<lock-period>`  | Set lock period preference  |

Combine multiple parameters with `,` separator:

* `d=1000` - Submit shares at difficulty 1000
* `d=500,frequency=2` - Difficulty 500, jobs every 2 seconds
* `d=500,lock=3` - Difficulty 500, lock rewards for 12 months
* `x` or empty - Use default workshare difficulty

<Note>
  Custom difficulty only affects share submission rate for liveness tracking. Only shares meeting the network workshare difficulty are submitted to the node for rewards.
</Note>

## Mining Examples

### SHA-256 Mining

```bash theme={null}
# Connect to SHA256 port (3333)
Pool-URL: stratum+tcp://<YourNodeIP>:3333 
Username: 0xYourQuaiAddress
Password: x

# With custom difficulty
Pool-URL: stratum+tcp://<YourNodeIP>:3333
Username: 0xYourQuaiAddress 
Password: d=1000000000
```

### Scrypt Mining

```bash theme={null}
# Connect to Scrypt port (3334)
Pool-URL: stratum+tcp://<YourNodeIP>:3334 
Username: 0xYourQuaiAddress
Password: x

# With custom difficulty
# Connect to Scrypt port (3334)
Pool-URL: stratum+tcp://<YourNodeIP>:3334 
Username: 0xYourQuaiAddress
Password: d=100000
```

### KawPoW Mining (GPU)

```bash theme={null}
# Connect to KawPoW port (3335)
kawpowminer -U -P stratum+tcp://<0xYourQuaiAddress>.worker@<YourNodeIP>:3335

# With custom difficulty
kawpowminer -U -P stratum+tcp://<0xYourQuaiAddress>.worker:d=1@<YourNodeIP>:3335
```

<Note>
  If your miner and node are on the same machine, use `127.0.0.1` or `localhost`. If they are on different machines, use the IP address of your node and ensure the ports are accessible (check firewall settings).
</Note>

## Monitoring & Statistics

The Stratum server exposes an HTTP API for statistics and monitoring at the configured `--node.stratum-api-addr` (default: `0.0.0.0:3336`).

### Available Endpoints

#### Pool-wide Statistics

| Endpoint                | Description                                  |
| ----------------------- | -------------------------------------------- |
| `GET /api/pool/stats`   | Pool overview with hashrate, workers, shares |
| `GET /api/pool/blocks`  | Blocks found by this node                    |
| `GET /api/pool/workers` | All connected workers                        |
| `GET /api/pool/shares`  | Share history with luck stats                |

#### Miner-specific Statistics

| Endpoint                           | Description                  |
| ---------------------------------- | ---------------------------- |
| `GET /api/miner/{address}/stats`   | Stats for a specific address |
| `GET /api/miner/{address}/workers` | Workers for an address       |

#### Real-time Updates

| Endpoint      | Description                              |
| ------------- | ---------------------------------------- |
| `WS /api/ws`  | WebSocket for live updates (1s interval) |
| `GET /health` | Health check                             |

#### Standard Pool Format

| Endpoint          | Description                |
| ----------------- | -------------------------- |
| `GET /api/stats`  | Standard pool stats format |
| `GET /api/miners` | All miners list            |
| `GET /api/blocks` | Block history              |

### Example API Response

**GET /api/pool/stats**

```json theme={null}
{
  "nodeName": "my-node",
  "workersTotal": 5,
  "workersConnected": 3,
  "hashrate": 1250000000000,
  "sharesValid": 1234,
  "sharesStale": 12,
  "sharesInvalid": 2,
  "blocksFound": 1,
  "uptime": 3600.5,
  "sha": {
    "hashrate": 500000000000,
    "workers": 2
  },
  "scrypt": {
    "hashrate": 250000000,
    "workers": 1
  },
  "kawpow": {
    "hashrate": 749750000000,
    "workers": 2
  }
}
```

## Logging

Stratum logs are written to `nodelogs/stratum.log`. Set log level with `--global.log-level`.

Log entries include:

* Connection events
* Job notifications
* Share submissions (accepted/rejected)
* Difficulty adjustments

## Troubleshooting

### "no pending header" errors

The node may not be synced. Ensure your node is fully synced and connected to the network.

### "authorization failed"

Verify your Quai/Qi address format is correct. The address should be a valid Ethereum-style address (0x...).

### High reject rate

* Ensure you're connecting to the correct port for your hardware
* Verify miner supports the difficulty being sent
* Check `nodelogs/stratum.log` for errors
* Confirm your node is fully synced

### Connection timeout

The server uses TCP keepalive. Stale connections are detected when writes fail. Ensure your firewall allows connections to the configured ports.

### Cannot connect to node

* Verify the Stratum server is enabled with `--node.stratum-enabled`
* Check that the node is running and accessible
* Ensure firewall rules allow connections on ports 3333-3336
* If connecting from a remote machine, use the node's IP address instead of `127.0.0.1`

## How It Works

The Stratum server acts as a bridge between standard mining hardware/software and Quai Network's workshare system:

```
┌─────────────┐     Stratum v1      ┌─────────────────┐
│   Miner     │ ◄────────────────►  │  Stratum Server │
│  (ASIC/GPU) │    TCP :3333-3335   │   (built-in)    │
└─────────────┘                     └────────┬────────┘
                                             │
                                             │ GetPendingHeader()
                                             │ ReceiveMinedHeader()
                                             ▼
                                    ┌─────────────────┐
                                    │   Quai Node     │
                                    │    Backend      │
                                    └─────────────────┘
```

### Job Flow

1. Miner connects to algorithm-specific port and subscribes (`mining.subscribe`)
2. Miner authorizes with address (`mining.authorize`)
3. Server fetches pending header from node
4. Server constructs stratum job from AuxPow data
5. Server sends difficulty and job to miner
6. Miner finds valid nonce and submits (`mining.submit`)
7. Server validates share against workshare target
8. If valid, server submits workshare to node
9. Server sends new job to miner

Jobs refresh every second to keep miners on latest work.

## Difficulty Calculation

Stratum difficulty is derived from Quai workshare difficulty:

* **SHA-256**: `minerDiff = ShaDiff / 2^32`
* **Scrypt**: `minerDiff = ScryptDiff / 65536`
* **KawPoW**: `minerDiff = KawpowDiff / 2^32`

## Version Rolling (ASICBoost)

The server supports version rolling for compatible ASICs. When a miner sends `mining.configure` with version-rolling capability, the server acknowledges and sends the allowed version mask.


# Building an NFT dApp
Source: https://docs.qu.ai/guides/development/nftdapp

A guide to building an NFT dApp on Quai Network

## Introduction

This article shows how to build and deploy a fully functional NFT dApp on Quai network's Orchard Testnet.

## Prerequisites

To deploy contracts and build a webapp frontend we'll need a few tool-kits and dependencies. Here's an overview of all the main dependencies we'll be using.

|                                                                                               |                                                                              |
| --------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------- |
| [**NodeJS**](https://nodejs.org/en/download/)                                                 | Javascript runtime environment. Use the LTS version.                         |
| [**hardhat-example**](https://github.com/dominant-strategies/hardhat-example)                 | A Hardhat project with sample contracts and deploy scripts for Quai Network. |
| [**hardhat-deploy-metadata**](https://github.com/dominant-strategies/hardhat-deploy-metadata) | A plugin for hardhat that uploads contract metadata to IPFS                  |
| [**Quais.js**](https://www.npmjs.com/package/quais)                                           | A JavaScript library for interacting with Quai Network.                      |
| [**OpenZeppelin**](https://www.openzeppelin.com/)                                             | Tools for building smart contracts in Solidity.                              |
| [**NextJS**](https://nextjs.org/)                                                             | Javascript framework providing server-side rendering for React apps.         |
| [**Chakra UI**](https://www.chakra-ui.com/)                                                   | UI Styling framework for React apps.                                         |

## Walkthrough

Today we’re going to be building an NFT dApp on QUAI complete with a web interface for interacting with it and managing some of the properties like mint price and total supply.

To have the best experience when following this guide we recommend you use the Chrome browser on either MacOS or Linux. Additionally, download and install VSCode if you don’t already have it as we’ll be working both in the terminal and editing code directly in order to build this app. Lastly, we'll be building our webapp using Node.js so it will be important to have that installed and setup ahead of time.

### Get a Quai Wallet with Funds

In order to build this app you will need to have a wallet with some funds in it.

You can get the Pelagus wallet at [pelaguswallet.io](https://pelaguswallet.io) and acquire some testnet Quai from the [faucet](https://orchard.faucet.quai.network).

### Setup The Development Environment

Let’s make a directory for our development work.

```bash theme={null}
mkdir ~/Devspace && cd ~/Devspace
```

Now let’s initialize our new Next.js app. Run the following command which asks you a few questions. You can use the values below.

```bash theme={null}
npx create-next-app@latest
```

![npxcreate](https://raw.githubusercontent.com/dominant-strategies/quai-nft-dapp/refs/heads/main/github-artifacts/walkthrough-images/npxcreate.png)

### Building and Deploying the NFT Smart Contract

Once the Next.js app is created we can open the `quai-nft-dapp` folder in VSCode and run a new terminal.

For building and deploying the NFT smart contract on Quai, we’ll use the official [hardhat-example](https://github.com/dominant-strategies/hardhat-example) repo as a reference.

The reference repo on github has solidity examples for deployment.

You can follow along by referencing the [Solidity folder](https://github.com/dominant-strategies/hardhat-example/tree/main/Solidity) in the hardhat-example repo.

### Install Dependencies

In order to build and deploy our smart contract we’ll need a few more dependencies.

First we’ll install `@openzeppelin/contracts` which provides helper functions for building standard ERC721 (NFT) smart contracts.

```bash theme={null}
npm i @openzeppelin/contracts
```

Next we’ll install `dotenv` which will allow us to configure our app via environment variables.

```bash theme={null}
npm i dotenv
```

Additionally, we’ll leverage hardhat for compiling and deploying our smart contracts.

```bash theme={null}
npm i hardhat
npm i --save-dev @nomicfoundation/hardhat-toolbox
npm i @quai/hardhat-deploy-metadata
```

Lastly we’ll install quais.js which is the ethers-like SDK for building on Quai Network.

```bash theme={null}
npm i quais
```

### Initialize & Setup Hardhat

To initialize our new hardhat project we will run the following, selecting defaults when asked.

```bash theme={null}
npx hardhat init
```

![npxhardhat](https://raw.githubusercontent.com/dominant-strategies/quai-nft-dapp/refs/heads/main/github-artifacts/walkthrough-images/npxhardhat.png)

This command creates a basic folder structure for hardhat and a few examples for us.

We will need to configure hardhat to deploy our smart contract using `.env.local` environment variables.

<Note>
  Be sure to save your changes along the way throughout this walkthrough.
</Note>

In the root folder find `hardhat.config.js` and replace it with the following:

```bash hardhat.config.js theme={null}
/**
 * @type import('hardhat/config').HardhatUserConfig
 */

require('@nomicfoundation/hardhat-toolbox')
require("@quai/hardhat-deploy-metadata")
const dotenv = require('dotenv')
dotenv.config({ path: './.env' })

module.exports = {
  defaultNetwork: 'cyprus1',
  networks: {
	cyprus1: {
  	url: process.env.RPC_URL,
  	accounts: [process.env.CYPRUS1_PK],
  	chainId: Number(process.env.CHAIN_ID),
	},
  },

  solidity: {
	version: '0.8.20',
	settings: {
  	optimizer: {
    	enabled: true,
    	runs: 1000,
  	},
  	evmVersion: 'london',
	},
  },

  paths: {
	sources: './contracts',
	cache: './cache',
	artifacts: './artifacts',
  },
  mocha: {
	timeout: 20000,
  },
}
```

This will inform hardhat what it needs to know about Quai network in order to deploy our contract later. It depends on some environment variables which we will setup next.

In the root of our folder structure in VSCode create a `.env.local` file and populate it with the correct information.

```bash .env.local theme={null}
## Sample environment file - change all values as needed

# Unique privkey for each deployment address
CYPRUS1_PK="0x0000000000000000000000000000000000000000000000000000000000000000"
INITIAL_OWNER="0x0000000000000000000000000"

# Chain ID (local: 1337, testnet: 9000, devnet: 12000)
CHAIN_ID="9000"

# RPC endpoint
RPC_URL="https://rpc.quai.network"
```

Replace the values for `CYPRUS1_PK` and `INITIAL_OWNER` with your Quai wallet’s private key and public key respectively. If you’re using Pelagus you can copy your public key and replace `INITIAL_OWNER`. You’ll have to export your private key and replace `CYPRUS1_PK` with it.

![pelaguspriv](https://raw.githubusercontent.com/dominant-strategies/quai-nft-dapp/refs/heads/main/github-artifacts/walkthrough-images/quaiprivkey.png)

Next we’ll need to create the script for deploying our contract.

<Note>This is the script we’ll call later to deploy our smart contract.</Note>

Create folder in the root directory called `scripts` and make a file inside it called `deployERC721.js`. Populate `deployERC721.js` with the following.

```bash scripts/deployERC721.js theme={null}
const quais = require('quais')
const TestNFT = require('../artifacts/contracts/ERC721.sol/TestERC721.json')
const { deployMetadata } = require("hardhat")
require('dotenv').config()

// Pull contract arguments from .env
const tokenArgs = [process.env.INITIAL_OWNER]

async function deployERC721() {

	// Get IPFS Hash
  const ipfsHash = await deployMetadata.pushMetadataToIPFS("TestERC721")

  // Config provider, wallet, and contract factory
  const provider = new quais.JsonRpcProvider(hre.network.config.url, undefined, { usePathing: true })
  const wallet = new quais.Wallet(hre.network.config.accounts[0], provider)
  const ERC721 = new quais.ContractFactory(TestNFT.abi, TestNFT.bytecode, wallet, ipfsHash)

  // Broadcast deploy transaction
  const erc721 = await ERC721.deploy(...tokenArgs)
  console.log('Transaction broadcasted: ', erc721.deploymentTransaction().hash)

  // Wait for contract to be deployed
  await erc721.waitForDeployment()
  console.log('Contract deployed to: ', await erc721.getAddress())
}

deployERC721()
  .then(() => process.exit(0))
  .catch((error) => {
	console.error(error)
	process.exit(1)
  })
```

While we’re here, let’s delete the `Lock.sol` file under the `contracts/` folder to prevent hardhat from bringing it in when we want to compile.

```bash theme={null}
rm contracts/Lock.sol
```

### Write the smart contract

In the `contracts` folder we’re going to create an `ERC721.sol` file and populate it with the following:

```bash contracts/ERC721.sol theme={null}
// Quai NFT Example //
/////////////////////
// Anyone can mint.
// Max supply and mint price are public, modifiable by the owner.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";

contract TestERC721 is ERC721URIStorage, Ownable {
	uint256 public tokenIds = 0;
	uint256 public mintPrice = (5 ether);
	uint256 public supply = 10000;

	constructor(address initialOwner) Ownable(initialOwner) ERC721("TestERC721", "TNFT") { }

	// Mint NFT
	function mint(address _recipient, string memory _tokenURI)
    	public
    	payable
    	returns (uint256)
	{
    	require(msg.value == mintPrice, "5 QUAI to Mint");
    	uint256 tokenId = tokenIds;
    	require(tokenId < supply, "No more NFTs");
    	_mint(_recipient, tokenId);
    	_setTokenURI(tokenId, _tokenURI);
    	tokenIds += 1;
    	return tokenId;
	}

	// Burn NFT
	function burn(uint256 tokenId) external {
    	require(ownerOf(tokenId) == msg.sender, "Only the owner of the NFT can burn it.");
    	_burn(tokenId);
	}


	// Update token supply
	function updateSupply(uint256 _supply)
    	public
    	onlyOwner()
    	returns (uint256)
	{
    	require(_supply > tokenIds, "New supply must be greater than current minted supply.");
    	supply = _supply;
    	return supply;
	}

	// Update Mint Price
	function updateMintPrice(uint256 _price)
    	public
    	onlyOwner()
    	returns (uint256)
	{
    	mintPrice = _price;
    	return mintPrice;
	}

	// Withdraw QUAI to Owner
	function withdraw()
    	public
    	payable
    	onlyOwner()
    	returns (bool)
	{
    	require(msg.sender == owner(), "Unauthorized");
    	(bool success, ) = owner().call{value:address(this).balance}("");
    	require(success, "Withdraw failed.");
    	return true;
	}

}
```

This contract has 3 public variables; tokenIds, mintPrice, and supply, which will be modifiable by the contract owner or `INITIAL_OWNER` once the contract is deployed. The initial tokenId is 0, mintPrice is 5 Quai, and total supply is 10,000.

The name and symbol of the NFT contract is hardcoded into the Solidity code as `TestERC721` and `TNFT`.

There are functions only available to the contract owner which allows them to update mintPrice and supply. Additionally, as NFTs are minted, the balance of the contract grows. We provide the `withdraw` function for the owner to withdraw these funds from the contract as well.

### Compile and Deploy the Smart Contract

Once this is all complete we can go ahead and compile our smart contract.

```bash theme={null}
npx hardhat compile
```

![hardhatcompile](https://raw.githubusercontent.com/dominant-strategies/quai-nft-dapp/refs/heads/main/github-artifacts/walkthrough-images/hardhatcompile.png)

If everything was configured correctly we can run our `deployERC721.js` script to launch our smart contract on Quai:

```bash theme={null}
npx hardhat run scripts/deployERC721.js
```

![hardhatdeploy](https://raw.githubusercontent.com/dominant-strategies/quai-nft-dapp/refs/heads/main/github-artifacts/walkthrough-images/hardhatdeploy.png)

The first thing this script does is broadcast a transaction on the Quai network. We will have to wait for the transaction to be mined to receive a result, but we can monitor the transaction hash on [orchard.quaiscan.io](https://orchard.quaiscan.io).

Just search the hash presented on Quaiscan. Once it’s successful the script will return our contract address.

![deployfinished](https://raw.githubusercontent.com/dominant-strategies/quai-nft-dapp/refs/heads/main/github-artifacts/walkthrough-images/hardhatdeployfinished.png)

Take note of this contract address. We will need it later to build the app to interact with it. Save it in `.env.local` as `NEXT_PUBLIC_DEPLOYED_CONTRACT`

![contractenv](https://raw.githubusercontent.com/dominant-strategies/quai-nft-dapp/refs/heads/main/github-artifacts/walkthrough-images/deployedenv.png)

You can also inspect the details of this contract by searching the address on [orchard.quaiscan.io](https://orchard.quaiscan.io).

### Building the dApp

Now that we have an NFT contract on the Quai blockchain we’ll want to build a web interface that can interact with it.

First, let’s install another dependency to help our user interface look decent and allow for some tasty toast notifications when the user interacts with the smart contract. The second command will ask you if you want to install the chakra cli. Press enter to go ahead and proceed.

```bash theme={null}
npm i @chakra-ui/react
npx @chakra-ui/cli snippet add toaster
```

We will be building this app in the `src` folder in our project. Create the following files with the following code in order to get started.

In `src/app/` we’ll need a `providers.tsx` file and a `store.tsx` file. We’ll be using these to manage the wallet state across the app.

```bash src/app/store.tsx theme={null}
/* eslint-disable  @typescript-eslint/no-explicit-any */

'use client';

import React, { FC, createContext, useReducer, ReactNode } from 'react';

interface StateData {
  account: account;
  web3Provider: any | undefined;
  rpcProvider: any | undefined;
  activeButton: string;
}

const typeStateMap = {
  SET_ACCOUNT: 'account',
  SET_WEB3_PROVIDER: 'web3Provider',
  SET_RPC_PROVIDER: 'rpcProvider',
  SET_ACTIVE_BUTTON: 'activeButton',
};

const initialState: StateData = {
  account: undefined,
  web3Provider: undefined,
  rpcProvider: undefined,
  activeButton: 'Home',
};

const reducer = (state: StateData, action: { type: keyof typeof typeStateMap; payload: any }) => {
  const stateName = typeStateMap[action.type];
  if (!stateName) {
	console.warn(`Unknown action type: ${action.type}`);
	return state;
  }
  return { ...state, [stateName]: action.payload };
};

const StateContext = createContext(initialState);
const DispatchContext = createContext<any>(null);

const StateProvider: FC<{ children?: ReactNode }> = ({ children }) => {
  const [state, dispatch] = useReducer(reducer, initialState);
  return (
	<DispatchContext.Provider value={dispatch}>
  	<StateContext.Provider value={state}>{children}</StateContext.Provider>
	</DispatchContext.Provider>
  );
};

export { typeStateMap, StateContext, DispatchContext, StateProvider };
```

```bash src/app/providers.tsx theme={null}
'use client';
import { StateProvider } from '@/app/store';
import { ChakraProvider, defaultSystem } from '@chakra-ui/react';

export function Providers({ children }: { children: React.ReactNode }) {
  return (
	<>
  	<ChakraProvider value={defaultSystem}>
    	<StateProvider>
        	{children}
    	</StateProvider>
  	</ChakraProvider>
	</>
  );
}
```

To help our app, which uses Typescript, understand a few more details we’ll add some additional types in `src/app/additional.d.ts`

```bash src/app/additional.d.ts theme={null}
/* eslint-disable  @typescript-eslint/no-explicit-any */

import { AbstractProvider, Eip1193Provider } from 'quais';

declare global {
  interface Window {
	pelagus?: Eip1193Provider & AbstractProvider;
  }

  // ---- data types ---- //
  type provider = { web3: any | undefined; rpc: any | undefined };
  type account = { addr: string; shard: string } | undefined;
  type ShardNames = {
	[key: string]: { name: string; rpcName: string };
  };
  type CodingLanguage = {
	[key: string]: { icon: any; color: string };
  };


}
```

We define some utilities for the app to interact with the user's wallet in the following files. You might need to create a few folders along the way.

```bash src/components/utils.ts theme={null}
/* eslint-disable  @typescript-eslint/no-explicit-any */

import { quais } from 'quais';

// ---- formatting ---- //
export const shortenAddress = (address: string) => {
  if (address === '') return '';
  return address.slice(0, 5) + '...' + address.slice(-4);
};

export const sortedQuaiShardNames: ShardNames = {
  '0x00': { name: 'Cyprus-1', rpcName: 'cyprus1' },
};

// ---- explorer url builders ---- //
export const buildRpcUrl = () => {
  return `https://orchard.rpc.quai.network`;
};

export const buildExplorerUrl = () => {
  return `https://orchard.quaiscan.io`;
};

export const buildAddressUrl = (address: string) => {
  return `https://orchard.quaiscan.io/address/${address}`;
};

export const buildTransactionUrl = (txHash: string) => {
  return `https://orchard.quaiscan.io/tx/${txHash}`;
};

// ---- dispatchers ---- //
export const dispatchAccount = (accounts: Array<string> | undefined, dispatch: any) => {
  if (accounts?.length !== 0 && accounts !== undefined) {
	const shard = quais.getZoneForAddress(accounts[0]);
	if (shard === null) {
  	dispatch({ type: 'SET_RPC_PROVIDER', payload: undefined });
  	dispatch({ type: 'SET_ACCOUNT', payload: undefined });
  	return;
	}
	const account = {
  	addr: accounts[0],
  	shard: shard,
	};
	const rpcProvider = new quais.JsonRpcProvider(buildRpcUrl());
	dispatch({ type: 'SET_RPC_PROVIDER', payload: rpcProvider });
	dispatch({ type: 'SET_ACCOUNT', payload: account });
  } else {
	dispatch({ type: 'SET_RPC_PROVIDER', payload: undefined });
	dispatch({ type: 'SET_ACCOUNT', payload: undefined });
  }
};

// ---- data validation ---- //

export const validateAddress = (address: string) => {
  if (address === '') return false;
  return quais.isAddress(address);
};
```

```bash src/components/wallet/requestAccounts.ts theme={null}
/* eslint-disable  @typescript-eslint/no-explicit-any */

import { dispatchAccount } from '@/components/utils';

// ---- request accounts ---- //
// only called on user action, prompts user to connect their wallet
// gets user accounts and provider if user connects their wallet

const requestAccounts = async (dispatch: any, web3provider: any) => {
  if (!web3provider) {
	console.log('No pelagus provider found.');
	return;
  }
  await web3provider
	.send('quai_requestAccounts')
	.then((accounts: Array<string>) => {
  	console.log('Accounts returned: ', accounts);
  	dispatchAccount(accounts, dispatch);
	})
	.catch((err: Error) => {
  	console.log('Error getting accounts.', err);
	});
};

export default requestAccounts;
```

```bash src/components/wallet/useGetAccounts.ts theme={null}
/* eslint-disable  @typescript-eslint/no-unused-vars */
/* eslint-disable  @typescript-eslint/no-explicit-any */

'use client';

import { useEffect, useContext } from 'react';
import { quais } from 'quais';

import { DispatchContext } from '@/app/store';
import { dispatchAccount } from '@/components/utils';

// ---- get accounts ---- //
// called in background on page load, gets user accounts and provider if pelagus is connected
// sets up accountsChanged listener to handle account changes

const useGetAccounts = () => {
  const dispatch = useContext(DispatchContext);
  useEffect(() => {
	const getAccounts = async (provider: any, accounts?: Array<string> | undefined) => {
  	let account;
  	await provider
    	.send('quai_accounts')
    	.then((accounts: Array<string>) => {
      	account = dispatchAccount(accounts, dispatch);
    	})
    	.catch((err: Error) => {
      	console.log('Error getting accounts.', err);
    	});
  	return account;
	};

	if (!window.pelagus) {
  	dispatch({ type: 'SET_WEB3_PROVIDER', payload: undefined });
  	return;
	} else {
  	const web3provider = new quais.BrowserProvider(window.pelagus);
  	dispatch({ type: 'SET_WEB3_PROVIDER', payload: web3provider });
  	getAccounts(web3provider);
  	window.pelagus.on('accountsChanged', (accounts: Array<string> | undefined) =>
    	dispatchAccount(accounts, dispatch)
  	);
	}
	// eslint-disable-next-line react-hooks/exhaustive-deps
  }, []);
};

export default useGetAccounts;
```

```bash src/components/wallet/index.ts theme={null}
export { default as requestAccounts } from './requestAccounts';
export { default as useGetAccounts } from './useGetAccounts';
```

Finally we can start building out our app's main page.

```bash src/app/layout.tsx theme={null}
import type { Metadata } from "next";
import { Geist, Geist_Mono } from "next/font/google";
import "./globals.css";
import { Providers } from "@/app/providers";

const geistSans = Geist({
  variable: "--font-geist-sans",
  subsets: ["latin"],
});

const geistMono = Geist_Mono({
  variable: "--font-geist-mono",
  subsets: ["latin"],
});

export const metadata: Metadata = {
  title: "Quai NFT dApp",
  description: "An example NFT dApp on Quai",
};


export default function RootLayout({
  children,
}: Readonly<{
  children: React.ReactNode;
}>) {
  return (
	<html lang="en">
  	<body
    	className={`${geistSans.variable} ${geistMono.variable} antialiased`}
  	>
    	<Providers>
      	{children}
    	</Providers>

  	</body>
	</html>
  );
}
```

```bash src/app/connectButton.tsx theme={null}
'use client';

import { useContext } from 'react';
import { StateContext, DispatchContext } from '@/app/store';
import { requestAccounts } from '@/components/wallet';

const ConnectButton = () => {
  const { web3Provider } = useContext(StateContext);
  const dispatch = useContext(DispatchContext);
  const connectHandler = () => {
	requestAccounts(dispatch, web3Provider);
  };

  if (!web3Provider) {
	return (
  	<a
    	className="w-full relative inline-flex items-center justify-center p-0.5 mb-2 me-2 overflow-hidden font-bold text-gray-900 rounded-lg group bg-gradient-to-br from-red-200 via-red-300 to-red-700 group-hover:from-red-200 group-hover:via-red-300 group-hover:to-red-700 dark:text-white dark:hover:text-gray-900 focus:ring-4 focus:outline-none focus:ring-red-100 dark:focus:ring-red-400"
    	href="https://chromewebstore.google.com/detail/pelagus/nhccebmfjcbhghphpclcfdkkekheegop"
    	target="_blank"
  	>
    	<span className="w-full relative px-5 py-2.5 transition-all ease-in duration-75 bg-white dark:bg-gray-900 rounded-md group-hover:bg-opacity-0">
      	Install Pelagus Wallet
    	</span>
  	</a>
	);
  } else {
	return (
    	<button
      	className="w-full relative inline-flex items-center justify-center p-0.5 mb-2 me-2 overflow-hidden font-bold text-gray-900 rounded-lg group bg-gradient-to-br from-red-200 via-red-300 to-red-700 group-hover:from-red-200 group-hover:via-red-300 group-hover:to-red-700 dark:text-white dark:hover:text-gray-900 focus:ring-4 focus:outline-none focus:ring-red-100 dark:focus:ring-red-400"
      	onClick={connectHandler}>
        	<span className="w-full relative px-5 py-2.5 transition-all ease-in duration-75 bg-white dark:bg-gray-900 rounded-md group-hover:bg-opacity-0">
          	Connect Wallet
        	</span>
    	</button>
	);
  }
};

export default ConnectButton;
```

```bash src/app/page.tsx theme={null}
/* eslint-disable  @typescript-eslint/no-explicit-any */

'use client'
import {useState,useEffect} from 'react'
import { useContext } from 'react';
import { Toaster, toaster } from "@/components/ui/toaster"
import { buildTransactionUrl, shortenAddress, sortedQuaiShardNames } from '@/components/utils';
import { quais } from 'quais';
import TestNFT from '../../artifacts/contracts/ERC721.sol/TestERC721.json';
import { StateContext } from '@/app/store';
import ConnectButton from './connectButton';
import { useGetAccounts } from '@/components/wallet';

export default function Mint() {
  useGetAccounts();
  const [nftName, setNFTName] = useState('NFT Name');
  const [symbol, setSymbol] = useState('NFT Symbol');
  const [isOwner, setIsOwner] = useState(false);
  const [tokenId, setTokenId] = useState(null);
  const [newSupply, setNewSupply] = useState(0);
  const [newPrice, setNewPrice] = useState(0);
  const [nftBalance, setNFTBalance] = useState(0);
  const [mintPrice, setMintPrice] = useState(BigInt(0));
  const [tokenSupply, setTokenSupply] = useState(null);
  const [remainingSupply, setRemainingSupply] = useState(0);
  const [contractBalance, setContractBalance] = useState(0);
  const { web3Provider, account } = useContext(StateContext);
  const contractAddress = process.env.NEXT_PUBLIC_DEPLOYED_CONTRACT as string; // Change this to your contract address
  const tokenuri = "https://example.com";

  const getContractBalance = async () => {
	const resp = await fetch('https://orchard.quaiscan.io/api/v2/addresses/'+contractAddress);
	const ret = await resp.json();
	if(ret.coin_balance){
  	setContractBalance(Number(ret.coin_balance)/Number(1000000000000000000));
  	console.log("Contract Balance: "+contractBalance);
	}
  }

  const callContract = async (type: string) => {
	if(type == 'balanceOf') {
  	const ERC721contract = new quais.Contract(contractAddress, TestNFT.abi, await web3Provider.getSigner());
  	const balance = await ERC721contract.balanceOf(account?.addr);
  	if(balance){
    	console.log("Balance: "+balance);
    	setNFTBalance(balance);
  	}
  	return balance;
	}
	else if(type == 'symbol'){
  	const ERC721contract = new quais.Contract(contractAddress, TestNFT.abi, await web3Provider.getSigner());
  	const contractSymbol = await ERC721contract.symbol();
  	if(contractSymbol){
    	setSymbol(contractSymbol);
  	}
  	return contractSymbol;
	}
	else if(type == 'name'){
  	const ERC721contract = new quais.Contract(contractAddress, TestNFT.abi, await web3Provider.getSigner());
  	const contractName = await ERC721contract.name();
  	if(contractName){
    	setNFTName(contractName);
  	}
  	return contractName;
	}
	else if(type == 'owner'){
  	const ERC721contract = new quais.Contract(contractAddress, TestNFT.abi, await web3Provider.getSigner());
  	const contractOwner = await ERC721contract.owner();
  	if(account?.addr == contractOwner){
    	setIsOwner(true);
  	}
  	return contractOwner;
	}
	else if(type == 'mintPrice'){
  	const ERC721contract = new quais.Contract(contractAddress, TestNFT.abi, await web3Provider.getSigner());
  	const price = await ERC721contract.mintPrice();
  	if(price){
    	console.log('mintPrice: '+(price/BigInt(1000000000000000000)));
    	setMintPrice(price/BigInt(1000000000000000000));
  	}
  	return price;
	}
	else if(type == 'tokenid'){
  	const ERC721contract = new quais.Contract(contractAddress, TestNFT.abi, await web3Provider.getSigner());
  	const tokenid = await ERC721contract.tokenIds();
  	if(tokenid >= 0){
    	console.log("tokenid: "+tokenid);
    	setTokenId(tokenid);
  	}
	}
	else if(type == 'supply'){
  	const ERC721contract = new quais.Contract(contractAddress, TestNFT.abi, await web3Provider.getSigner());
  	const supply = await ERC721contract.supply();
  	if(supply){
    	console.log("supply: "+supply);
    	setTokenSupply(supply);
  	}
  	return supply;
	}
	else if(type == 'mint'){
  	try {
    	const ERC721contract = new quais.Contract(contractAddress, TestNFT.abi, await web3Provider.getSigner());
    	const price = await ERC721contract.mintPrice();
    	const contractTransaction = await ERC721contract.mint(account?.addr,tokenuri,{value: price});
    	const txReceipt = await contractTransaction.wait();
    	return Promise.resolve({ result: txReceipt, method: "Mint" });
  	} catch (err) {
    	return Promise.reject(err);
  	}
	}
	else if(type == 'withdraw'){
  	try {
    	const ERC721contract = new quais.Contract(contractAddress, TestNFT.abi, await web3Provider.getSigner());
    	const contractTransaction = await ERC721contract.withdraw();
    	const txReceipt = await contractTransaction.wait();
    	console.log(txReceipt);
    	return Promise.resolve({ result: txReceipt, method: "Withdraw" });
  	} catch (err) {
    	return Promise.reject(err);
  	}
	}
	else if(type=='updateSupply'){
  	try {
    	const ERC721contract = new quais.Contract(contractAddress, TestNFT.abi, await web3Provider.getSigner());
    	if(newSupply > 0){
      	console.log("New Supply Value: "+newSupply);
      	const contractTransaction = await ERC721contract.updateSupply(newSupply);
      	const txReceipt = await contractTransaction.wait();
      	console.log(txReceipt);
      	return Promise.resolve({ result: txReceipt, method: "updateSupply" });
    	}
  	} catch (err) {
    	return Promise.reject(err);
  	}
	}
	else if(type=='updatePrice'){
  	try {
    	const ERC721contract = new quais.Contract(contractAddress, TestNFT.abi, await web3Provider.getSigner());
    	if(newPrice > 0){
      	const priceQuai = quais.parseQuai(String(newPrice));
      	console.log("New Price Value: "+priceQuai);
      	const contractTransaction = await ERC721contract.updateMintPrice(priceQuai);
      	const txReceipt = await contractTransaction.wait();
      	console.log(txReceipt);
      	return Promise.resolve({ result: txReceipt, method: "updateMintPrice" });
    	}
  	} catch (err) {
    	return Promise.reject(err);
  	}
	}
  };

  // HANDLE UPDATE PRICE
  const handleUpdatePrice = async () =>{
	toaster.promise(
  	callContract('updatePrice'),
  	{
    	loading: {
      	title: 'Broadcasting Transaction',
      	description: '',
    	},
    	success: ({result, method}) =>(
      	{
      	title: 'Transaction Successful',
      	description: (
        	<>
          	{result.hash ? (
            	<a
              	className="underline"
              	href={buildTransactionUrl(result.hash)}
              	target="_blank"
            	>
              	View In Explorer
            	</a>
          	) : (
            	<p>
              	{method} : {result}
            	</p>
          	)}
        	</>
      	),
      	duration: 10000,
    	}),
    	error: (error: any) => ({
      	title: 'Error',
      	description: error.reason || error.message || 'An unknown error occurred',
      	duration: 10000,
    	}),
  	}
	);
  }

  // HANDLE UPDATE SUPPLY
  const handleUpdateSupply = async () =>{
	toaster.promise(
  	callContract('updateSupply'),
  	{
    	loading: {
      	title: 'Broadcasting Transaction',
      	description: '',
    	},
    	success: ({result, method}) => (
      	{
      	title: 'Transaction Successful',
      	description: (
        	<>
          	{result.hash ? (
            	<a
              	className="underline"
              	href={buildTransactionUrl(result.hash)}
              	target="_blank"
            	>
              	View In Explorer
            	</a>
          	) : (
            	<p>
              	{method} : {result}
            	</p>
          	)}
        	</>
      	),
      	duration: 10000,
    	}),
    	error: (error: any) => ({
      	title: 'Error',
      	description: error.reason || error.message || 'An unknown error occurred',
      	duration: 10000,
    	}),
  	}
	);
  }

  // HANDLE WITHDRAW
  const handleWithdraw = async () =>{
	toaster.promise(
  	callContract('withdraw'),
  	{
    	loading: {
      	title: 'Broadcasting Transaction',
      	description: '',
    	},
    	success: ({result, method}) => (
      	{
      	title: 'Transaction Successful',
      	description: (
        	<>
          	{result.hash ? (
            	<a
              	className="underline"
              	href={buildTransactionUrl(result.hash)}
              	target="_blank"
            	>
              	View In Explorer
            	</a>
          	) : (
            	<p>
              	{method} : {result}
            	</p>
          	)}
        	</>
      	),
      	duration: 10000,
    	}),
    	error: (error: any) => ({
      	title: 'Error',
      	description: error.reason || error.message || 'An unknown error occurred',
      	duration: 10000,
    	}),
  	}
	);
  }

  // HANDLE MINT
  const handleMint = async () => {
	toaster.promise(
  	callContract('mint'),
  	{
    	loading: {
      	title: 'Broadcasting Transaction',
      	description: '',
    	},
    	success: ({result, method}) => (
      	{
      	title: 'Transaction Successful',
      	description: (
        	<>
          	{result.hash ? (
            	<a
              	className="underline"
              	href={buildTransactionUrl(result.hash)}
              	target="_blank"
            	>
              	View In Explorer
            	</a>
          	) : (
            	<p>
              	{method} : {result}
            	</p>
          	)}
        	</>
      	),
      	duration: 10000,
    	}),
    	error: (error: any) => ({
      	title: 'Error',
      	description: error.reason || error.message || 'An unknown error occurred',
      	duration: 10000,
    	}),
  	}
	);
  };


  useEffect(()=>{
	if(account){
  	callContract('owner');
  	callContract('tokenid');
  	callContract('supply');
  	callContract('mintPrice');
  	callContract('balanceOf');
  	callContract('symbol');
  	callContract('name');
  	getContractBalance();
	}
	if((Number(tokenId) >= 0) && (Number(tokenSupply) >= 0)){
  	if(tokenId == 0){
    	setRemainingSupply(Number(tokenSupply));
  	} else {
    	setRemainingSupply(Number(tokenSupply) - Number(tokenId));
  	}
  	console.log("Remaining Supply: "+remainingSupply);
	}
  }, [account, tokenId, tokenSupply, callContract, getContractBalance, remainingSupply]);

  return (
	<>
  	<div className="font-serif container mx-auto p-6 max-w-lg">
    	<div className="rounded-lg p-8">

      	<h1 className="text-3xl text-slate-200 font-bold text-center mb-6">QUAI NFT dApp</h1>
      	<p className="font-serif text-slate-200 mb-10">An example dApp that mints NFTs and provides additional functionality to the contract owner.</p>

      	<div className="mb-6">
        	{ (Number(tokenSupply) > 0) ?
          	<p className="text-center text-slate-200 mb-4">{Number(tokenSupply).toLocaleString()} NFTs available. </p> : <></>
        	}

        	<div className="hover:border-blue-900 shadow-lg border-2 border-stone-800 bg-gradient-to-br via-blue-900 from-slate-500 to-slate-700 font-serif p-6 rounded-lg shadow-md">
            	<h3 className="text-3xl font-semibold text-slate-300 ">{nftName ? nftName : <></>}</h3>
            	<h3 className="text-2xl font-semibold text-slate-300 underline"><a href={'https://orchard.quaiscan.io/token/'+contractAddress} target="_blank">{symbol ? symbol : <></>}</a></h3>
            	{mintPrice ?
              	<p className="text-slate-300 mt-4">Mint Price: <span className="font-bold">{mintPrice.toLocaleString()} QUAI</span></p>
              	: <></>
            	}
            	<p className="text-slate-300 mt-4">Contract Balance: <span className="font-bold">{contractBalance.toLocaleString()} QUAI</span></p>

        	</div>
      	</div>

      	<div className="mb-4">
        	{account ?
          	<label className="block text-sm font-medium text-slate-200 mb01">Connected: <span className="text-blue-400 font-bold">{sortedQuaiShardNames[account.shard].name} {shortenAddress(account.addr)}</span></label>
          	: <></>}
      	</div>

      	{((remainingSupply > 0) && account) ?
        	<p className="text-center text-slate-200 mb-4">{remainingSupply.toLocaleString()} remaining</p>
        	: account ? <><p className="text-center text-slate-200 mb-4">No More NFTs Available</p></>
        	: <></>
      	}
      	{nftBalance > 0 ?
        	<p className="text-center text-slate-200 mb-4">{nftBalance.toLocaleString()} owned</p>
        	: account ? <><p className="text-center text-slate-200 mb-4">No NFTs Owned.</p></>
        	: <></>
      	}

      	<div className="text-center">
        	{(remainingSupply > 0) && account ?
          	<button
            	className="w-full relative inline-flex items-center justify-center p-0.5 mb-2 me-2 overflow-hidden font-bold text-gray-900 rounded-lg group bg-gradient-to-br from-blue-200 via-blue-300 to-blue-700 group-hover:from-red-200 group-hover:via-red-300 group-hover:to-red-700 dark:text-white dark:hover:text-gray-900 focus:ring-4 focus:outline-none focus:ring-red-100 dark:focus:ring-red-400"
            	onClick={()=>handleMint()}>
              	<span className="w-full relative px-5 py-2.5 transition-all ease-in duration-75 bg-white dark:bg-gray-900 rounded-md group-hover:bg-opacity-0">
                	Mint
              	</span>
          	</button> : <></>
        	}
        	{!account ? <ConnectButton/> : <></>}


        	{isOwner && account ?
          	<>
          	<button
            	className="w-full relative inline-flex items-center justify-center p-0.5 mb-2 me-2 overflow-hidden font-bold text-gray-900 rounded-lg group bg-gradient-to-br from-blue-200 via-blue-300 to-blue-700 group-hover:from-red-200 group-hover:via-red-300 group-hover:to-red-700 dark:text-white dark:hover:text-gray-900 focus:ring-4 focus:outline-none focus:ring-red-100 dark:focus:ring-red-400"
            	onClick={()=>handleWithdraw()}>
              	<span className="w-full relative px-5 py-2.5 transition-all ease-in duration-75 bg-white dark:bg-gray-900 rounded-md group-hover:bg-opacity-0">
                	Withdraw
              	</span>
          	</button>
          	<div className="flex items-center space-x-2 mb-2">
            	<input onChange={e => setNewSupply(parseInt(e.target.value))} type="number" className="text-black px-4 py-2 border rounded-md focus:outline-none focus:ring-2 focus:ring-blue-400" placeholder="0"/>
            	<button className="w-full relative inline-flex items-center justify-center p-0.5 mb-2 me-2 overflow-hidden font-bold text-gray-900 rounded-lg group bg-gradient-to-br from-blue-200 via-blue-300 to-blue-700 group-hover:from-red-200 group-hover:via-red-300 group-hover:to-red-700 dark:text-white dark:hover:text-gray-900 focus:ring-4 focus:outline-none focus:ring-red-100 dark:focus:ring-red-400"
              	onClick={()=>handleUpdateSupply()}
              	>
              	Update Supply
            	</button>
          	</div>
          	<div className="flex items-center space-x-2">
            	<input onChange={e => setNewPrice(parseInt(e.target.value))} type="number" className="text-black px-4 py-2 border rounded-md focus:outline-none focus:ring-2 focus:ring-blue-400" placeholder="0"/>
            	<button className="w-full relative inline-flex items-center justify-center p-0.5 mb-2 me-2 overflow-hidden font-bold text-gray-900 rounded-lg group bg-gradient-to-br from-blue-200 via-blue-300 to-blue-700 group-hover:from-red-200 group-hover:via-red-300 group-hover:to-red-700 dark:text-white dark:hover:text-gray-900 focus:ring-4 focus:outline-none focus:ring-red-100 dark:focus:ring-red-400"
              	onClick={()=>handleUpdatePrice()}
              	>
              	Update Mint Price
            	</button>
          	</div>

          	</> : <></>
        	}

      	</div>

    	</div>
  	</div>
  	<Toaster/>

	</>
  )

}
```

### Running the App

Once all your changes are saved you can run `npm run dev` in the terminal and point your browser to `https://localhost:3000` to view your app!

![runningapp](https://raw.githubusercontent.com/dominant-strategies/quai-nft-dapp/refs/heads/main/github-artifacts/walkthrough-images/runningapp.png)

When you connect with the wallet you used to deploy the app you will see the options to withdraw funds, and update supply or mint price. All other wallets will only be allowed to mint an NFT. The app won’t show this additional functionality to other wallets and the smart contract is written to only allow the owner to perform these functions.

### Wrapping Up!

Congrats! You’ve just built your first NFT app on Quai!

If you would like to view the complete repo for this project browse over to the tutorial's [repo](https://github.com/dominant-strategies/quai-nft-dapp).

## Next Steps

If you’d like to continue to build and add more functionality here are some ideas to take this project further.

* **Create some art for your NFT.**
  * Once the metadata is set, you can produce and publish some art for your NFT viewable in NFT marketplaces or on Quaiscan
* **Generate some metadata for your NFT.**
  * By default the app uses `https://example.com` as the tokenuri for every minted NFT. This is set on line 29 on `page.tsx`. You can modify this behavior to point to a JSON file you’re hosting either on your own site or IPFS.
* **Launch your NFT on QuaiMark!**
  * QuaiMark is an NFT marketplace on Quai Network where people come to see what NFTs are available to buy, sell, and trade. Once you feel your project is ready, head over to Quaimark.com to check it out!


# Deploy with Solidity
Source: https://docs.qu.ai/guides/development/solidity

A guide to deploying a simple single-chain smart contract on Quai Network.

## Introduction

This article shows how to deploy a Solidity smart contract using Hardhat on any of Quai Network's chains.

## Prerequisites

To deploy single chain smart contracts on Quai, we'll need a few tool-kits and dependencies. Here's an overview of all of the dependencies we'll be using:

|                                                                                                  |                                                                                                  |
| ------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------ |
| [**NodeJS**](https://nodejs.org/en/download/)                                                    | Javascript runtime environment. Use the LTS version.                                             |
| [**hardhat-example**](https://github.com/dominant-strategies/hardhat-example)                    | A Hardhat project with sample contracts and deploy scripts for Quai Network.                     |
| [**Quais.js**](https://www.npmjs.com/package/quais)                                              | A JavaScript library for interacting with Quai Network.                                          |
| [**@quai/hardhat-deploy-metadata**](https://www.npmjs.com/package/@quai/hardhat-deploy-metadata) | A Hardhat plugin that pushes contract metadata to IPFS so contracts can be verified on Quaiscan. |
| [**@openzeppelin/contracts**](https://www.npmjs.com/package/@openzeppelin/contracts)             | Smart contract library used by the sample ERC20 and ERC721 contracts.                            |

## Environment Setup

### Install Example Repository

Start by cloning the `hardhat-example` repository, navigating to the `Solidity` directory we'll be using for this tutorial, and installing the dependencies via `npm`.

```bash theme={null}
git clone https://github.com/dominant-strategies/hardhat-example.git
cd hardhat-example/Solidity
npm install
```

### Smart Contracts

The `Solidity/` directory comes with 2 sample contracts: `ERC20.sol` and `ERC721.sol` inside of the `contracts/` directory. Both contracts are implementations derived from the [Open Zeppelin library](https://www.openzeppelin.com/contracts).

We'll be using the `ERC20.sol` sample contract for this tutorial, but you can also add your own contracts or use contracts from other libraries.

<Warning>
  The Quai Network EVM supports Solidity versions up to 0.8.20. Using a newer
  version of Solidity may result in errors when deploying smart contracts.
</Warning>

### Environment Variables

We've included a sample environment file, `.env.dist`, file at the root of the `hardhat-example` repo to manage token details, private keys, and your RPC URL in a secure fashion.

<Note>
  The `.env.dist` file is a template file and should not be used as is. You should copy the `.env.dist` file to a new `.env` file.

  This file lives at the root of the `hardhat-example` repository and serves as the config file for the `Solidity/` directory.
</Note>

Copy the `.env.dist` file in the root to a new `.env` file in the repository root using the following command:

```bash theme={null}
cp ../.env.dist ../.env
```

Open the `.env` file and add your private key, RPC URL, and token args for the contract you'd like to deploy. The `.env` file should look like this:

```bash .env theme={null}
## Sample environment file - change all values as needed

# Unique privkey for the deployment address
CYPRUS1_PK="0x0000000000000000000000000000000000000000000000000000000000000000" # pubkey starting with 0x00

# Chain ID (local: 1337, Orchard testnet: 15000, mainnet: 9)
CHAIN_ID="15000"

# RPC endpoint
RPC_URL="https://orchard.rpc.quai.network"

# ERC20 Arguments
ERC20_NAME="TestERC20"
ERC20_SYMBOL="TE20"
ERC20_INITIALSUPPLY=1000000

# ERC721 Arguments
ERC721_NAME="TestERC721"
ERC721_SYMBOL="TE721"
ERC721_BASE_URI="ipfs://METADATA_CID/"
ERC721_MAX_TOKENS=1000
```

<Note>
  The sample `.env.dist` targets **Orchard testnet** so you can deploy without
  spending real QUAI. To deploy to mainnet, change `CHAIN_ID` to `9` and
  `RPC_URL` to `https://rpc.quai.network`.
</Note>

Further information on RPC endpoints can be found on the [Networks](/build/networks) page.

The `hardhat-example` repository uses the [Quais SDK](/sdk/introduction) to configure network connections using only a single RPC URL. To learn more about how the SDK configures network providers, visit the [SDK provider examples](/sdk/static/provider) section.

After filling in your private key and RPC URL, we're now ready to securely consume them inside of `hardhat.config.js`.

### Hardhat Configuration

Hardhat uses a `hardhat.config.js` file to configure smart contract deployments. The config file allows you to define deployment networks, tasks, compilers, etc.

`hardhat-example` contains a prebuilt `hardhat.config.js` file with configuration for deploying and verifying smart contracts on Cyprus-1.

<Accordion title="Sample hardhat configuration file" icon="file">
  This sample configuration file is provided as part of the `hardhat-example` repository.

  ```javascript hardhat.config.js theme={null}
  /**
   * @type import('hardhat/config').HardhatUserConfig
   */

  require('@nomicfoundation/hardhat-toolbox')
  require('@quai/quais-upgrades')
  require('@quai/hardhat-deploy-metadata')

  const dotenv = require('dotenv')
  dotenv.config({ path: '../.env' })

  module.exports = {
    defaultNetwork: 'cyprus1',
    networks: {
      cyprus1: {
        url: process.env.RPC_URL,
        accounts: [process.env.CYPRUS1_PK],
        chainId: Number(process.env.CHAIN_ID),
      },
    },

    solidity: {
      compilers: [
        {
          version: '0.8.17',
          settings: {
            optimizer: { enabled: true, runs: 1000 },
            metadata: {
              bytecodeHash: 'ipfs',
              useLiteralContent: true,
            },
            evmVersion: 'london',
          },
        },
        {
          version: '0.8.20',
          settings: {
            optimizer: { enabled: true, runs: 1000 },
            metadata: {
              bytecodeHash: 'ipfs',
              useLiteralContent: true,
            },
            evmVersion: 'london',
          },
        },
      ],
    },

    paths: {
      sources: './contracts',
      cache: './cache',
      artifacts: './artifacts',
    },
    mocha: {
      timeout: 20000,
    },
  }
  ```

  <Info>
    Cyprus-1 is currently the only active zone on Quai Network, so the sample
    config defines a single `cyprus1` network. See [Networks](/build/networks)
    for the full list of zone endpoints.
  </Info>

  <Warning>
    The `metadata.bytecodeHash: 'ipfs'` and `useLiteralContent: true` compiler
    settings are required for `@quai/hardhat-deploy-metadata` to produce
    verifiable output. Removing them will break Quaiscan verification.
  </Warning>
</Accordion>

When deploying a contract, `hardhat.config.js` pulls your private key and RPC URL from the `.env` file. You can also specify the Solidity version and compiler settings in the `solidity` object.

## Deploy and Interact

<Steps>
  <Step title="Compile with Hardhat">
    Smart contract compilation with Hardhat is simple and can be done using `npx` in the CLI.

    Compile all of the contracts inside the `contracts/` directory with:

    ```bash theme={null}
    npx hardhat compile
    ```

    Which should output:

    ```bash theme={null}
    Downloading compiler 0.8.20

    Compiled 2 Solidity files successfully
    ```
  </Step>

  <Step title="Configure deployment scripts">
    Inside the `scripts/` directory, you'll find a deploy script for both the ERC20 and ERC721 contracts: `deployERC20.js` and `deployERC721.js`. For this tutorial, we'll be deploying an ERC20 contract.

    The `deployERC20.js` script pulls your network configuration from `hardhat.config.js` and your token arguments from the `.env` file at the root of the repository and uses them to deploy your contract.

    Token arguments are consumed via the `tokenArgs` array:

    ```js theme={null}
    const tokenArgs = [process.env.ERC20_NAME, process.env.ERC20_SYMBOL, quais.parseUnits(process.env.ERC20_INITIALSUPPLY)]
    ```

    Before the contract is deployed, the script uses the `@quai/hardhat-deploy-metadata` plugin to push the compiled contract's metadata to IPFS and returns the resulting CID:

    ```js theme={null}
    const { deployMetadata } = require("hardhat")
    // ...
    const ipfsHash = await deployMetadata.pushMetadataToIPFS("ERC20")
    ```

    The CID is then passed as the fourth argument to `ContractFactory`, which embeds it in the deployed bytecode. Quaiscan reads that CID later to fetch your source for verification — without it, the contract can be deployed but not verified.

    ```js theme={null}
    const provider = new quais.JsonRpcProvider(hre.network.config.url, undefined, { usePathing: true })
    const wallet = new quais.Wallet(hre.network.config.accounts[0], provider)
    const ERC20 = new quais.ContractFactory(ERC20Json.abi, ERC20Json.bytecode, wallet, ipfsHash)
    ```

    We'll use these ideas to properly modify the token args and network specification to deploy our contract in the next step.

    <Tip>
      The `deployERC721.js` script follows the same structure with different
      contract arguments and a different ABI/bytecode. You can replicate this
      configuration for any contract you'd like to deploy.
    </Tip>
  </Step>

  <Step title="Deploy your contract">
    The deploy script takes in a `--network` flag to specify the network you'd like to deploy to. The sample config only defines `cyprus1`, which we'll use here.

    ```bash theme={null}
    npx hardhat run scripts/deployERC20.js --network cyprus1
    ```

    Which should output:

    ```bash theme={null}
    File added with CID: QmPCoBa1bCFmRoTD7GuexJqBAy7pqg8J4b8B48q5DgxUEV
    Original IPFS hash found in bytecode: QmPCoBa1bCFmRoTD7GuexJqBAy7pqg8J4b8B48q5DgxUEV
    Metadata JSON for ERC20 saved to /.../hardhat-example/Solidity/metadata/ERC20_metadata.json
    Transaction broadcasted: 0x235fdeb85db5b6cee8da9780e2246907e8342751849f5ce3514847a5dffd916f
    Contract deployed to:  0x00735E9B2c731Fd3eCC8129a3653ACb99dF969cC
    ```

    The `CID` printed in the first line is the IPFS hash you'll need to verify the contract on Quaiscan — save it.

    Congratulations, you've now deployed an ERC20 token to Quai Network!

    <Warning>
      The `ERC20.sol` and `ERC721.sol` sample contracts are basic implementations of each token for example purposes. It is highly recommended
      to modify these contracts to fit your specific use case before deploying them for any production use.
    </Warning>
  </Step>

  <Step title="Interact with the contract">
    Hardhat console does not currently offer support for interaction with smart contracts on Quai Network.

    To interact with the contract, you can configure a simple script using the [Quais SDK](/sdk/static/contract). The script below configures a [Contract](/sdk/content/classes/Contract) instance for the ERC20 token we deployed to `0x00735E9B2c731Fd3eCC8129a3653ACb99dF969cC` to get the name, symbol, and total supply of the token.

    ```javascript getContractDetails.js theme={null}
    const quais = require('quais')
    const ERC20Json = require('../artifacts/contracts/ERC20.sol/ERC20.json')

    async function getContractDetails() {
      // Config provider, wallet, and contract factory
      const provider = new quais.JsonRpcProvider(hre.network.config.url, undefined, { usePathing: true })
      const wallet = new quais.Wallet(hre.network.config.accounts[0], provider)
      const ERC20 = new quais.Contract("0x00735E9B2c731Fd3eCC8129a3653ACb99dF969cC", ERC20Json.abi, wallet)

      const tokenName = await ERC20.name()
      const tokenSymbol = await ERC20.symbol()
      const tokenDecimals = await ERC20.decimals()
      const tokenTotalSupply = await ERC20.totalSupply()
    }

    getContractDetails()
      .then(() => process.exit(0))
      .catch((error) => {
        console.error(error)
        process.exit(1)
      })
    ```
  </Step>
</Steps>

## Summary

Now you have all the tools you need to create a simple Hardhat project, deploy, and interact with your own smart contracts.

Because the deploy script pushed your contract's metadata to IPFS, you can now verify it on Quaiscan — see [Verifying Contract on Quaiscan](/guides/development/verifycontract) for the next step.


# Verifying Contract on Quaiscan
Source: https://docs.qu.ai/guides/development/verifycontract

A guide to verifying your smart contracts on Quaiscan.

## Introduction

This article shows how to verify a smart contract on Quai Network's block explorer [Quaiscan](https://quaiscan.io/).

## Prerequisites

To deploy contracts and verify them on Quaiscan we'll need a few dependencies. Here's an overview of all the main dependencies we'll be using.

|                                                                                               |                                                                              |
| --------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------- |
| [**NodeJS**](https://nodejs.org/en/download/)                                                 | Javascript runtime environment. Use the LTS version.                         |
| [**hardhat-example**](https://github.com/dominant-strategies/hardhat-example)                 | A Hardhat project with sample contracts and deploy scripts for Quai Network. |
| [**hardhat-deploy-metadata**](https://github.com/dominant-strategies/hardhat-deploy-metadata) | A plugin for hardhat that uploads contract metadata to IPFS                  |
| [**Quais.js**](https://www.npmjs.com/package/quais)                                           | A JavaScript library for interacting with Quai Network.                      |

## Walkthrough

Today we’re going to be verifying a smart contract on Quaiscan, Quai Network's block explorer.

This guide follows the [Deploy with Solidity](https://docs.qu.ai/guides/development/solidity) guide, so make sure you're familiar with that and the [hardhat-example](https://github.com/dominant-strategies/hardhat-example) repo before beginning.

### Deploy a Smart Contract

Following the [Deploy with Solidity](https://docs.qu.ai/guides/development/solidity) guide, deploy a smart contract complete with IPFS metadata.

When using the [hardhat-example](https://github.com/dominant-strategies/hardhat-example) repo the command should be `npx hardhat run scripts/deployERC20.js` which produces output similar to the following:

```
File added with CID: QmPCoBa1bCFmRoTD7GuexJqBAy7pqg8J4b8B48q5DgxUEV
Original IPFS hash found in bytecode: QmPCoBa1bCFmRoTD7GuexJqBAy7pqg8J4b8B48q5DgxUEV
Metadata JSON for ERC20 saved to /../hardhat-example/Solidity/metadata/ERC20_metadata.json
Transaction broadcasted:  0x0032004cc6a910b8733ad9502caa315beb74f3409bee2b481116bddfb9c8880d
Contract deployed to:  0x0015dFe3280783CD9b126D8E0ccc728B6490b2b2
```

In the above output you'll see that the contract's metadata was uploaded to `ipfs.qu.ai` with the following hash: `QmPCoBa1bCFmRoTD7GuexJqBAy7pqg8J4b8B48q5DgxUEV`

Your hash **will be different**. Make sure you capture it as we'll need it in the next step.

### Download the IPFS metadata

When using the [hardhat-deploy-metadata](https://github.com/dominant-strategies/hardhat-deploy-metadata) plugin, the IPFS metadata is stored in the project under the `metadata` folder, but isn't formatted properly for Quaiscan.

We'll need to download the proper format from IPFS to upload into Quaiscan and verify our contract.

Run the following command using **your IPFS hash** when you deployed your contract to download the metadata and save it as `ipfsMeta.json`.

```
curl https://ipfs.qu.ai/ipfs/[YOUR IPFS METADATA HASH] > ipfsMeta.json
```

### Verify Smart Contract on Quaiscan

Now that we have a deployed smart contract and the IPFS metadata in proper JSON formatting, we can verify our smart contract on Quaiscan.

Open your browser and visit the [Verify Contract](https://quaiscan.io/contract-verification?shard=) page on Quaiscan.

<Frame>
  <img />
</Frame>

Using this page fill in all the details of your contract exactly as it's been written.

You'll need the correct contract address and license indicated by the `SPX-License-Identifier` in your contract's code.

Select **Solidity (Standard JSON input)** as the Verification Method and the correct version of the Solidity Compiler used to compile your contract.

Finally upload `ipfsMeta.json` and click **Verify & Publish** to verify your smart contract.

<Frame>
  <img />
</Frame>

Once successful you can visit your contract's page on Quaiscan to interact with it directly and see it's verification status.

<Frame>
  <img />
</Frame>

Congratulations! You have just verified your smart contract on Quaiscan!


# Clore.AI Installation
Source: https://docs.qu.ai/guides/miner/clore-ai

Install and run a Quai Network GPU miner using Clore.AI cloud GPUs.

## Introduction

Here, we'll be running an instance of [quai-gpu-miner](https://github.com/dominant-strategies/quai-gpu-miner), the implementation of a Quai Network ProgPOW miner, on [Clore.AI](https://clore.ai/).

Clore.AI is a cloud compute marketplace that provides access to a distributed network of GPU computining nodes from anywhere in the world.

### Requirements

In order to run the quai-gpu-miner on Clore.AI and mine valid blocks, you'll need the following:

<CardGroup>
  <Card title="Synced go-quai node" href="/guides/client/node" icon="computer" />

  <Card title="Configured Stratum proxy" href="/guides/client/stratum" icon="router" />

  <Card title="Clore.AI Rental" href="https://clore.ai/" icon="disc-drive" />
</CardGroup>

## Environment Setup

### Clore Account

Start by [creating](https://clore.ai/register) or [logging into](https://clore.ai/login) your Clore account.

<Frame>
  <img />
</Frame>

After logging into your account, head to the `Marketplace` tab. Here, you'll be able to see all of the available compute options available for rental.

<Frame>
  <img />
</Frame>

Select a compute option and click on `Rental`. You'll be taken to a configuration page where you'll be able to configure your compute with quai-gpu-miner.

### Configure Clore Instance

On the configuration page, head to the `Select Image` section and fill in the `Custom Image` section with the following:

```bash theme={null}
quainetwork/quai-gpu-miner-run
```

<Frame>
  <img />
</Frame>

Scroll down to the `Configure Order` section. We'll be filling in the environment variables for the `quai-gpu-miner-run` image. You'll need to add the following variables:

* `PLATFORM`
  * For NVIDIA cards, set this value to `U`.
  * For AMD cards, set this value to `G`.
* `STRATUM_IP` The IP address of your Stratum proxy.
* `STRATUM_PORT` The port of your Stratum proxy. The default stratum port is `3333`.

<Frame>
  <img />
</Frame>

<Note>You will need to port forward the stratum port `3333` if you are not also running a stratum proxy on the same machine.</Note>

After filling out the environment variables section, you can click the `Create` button to create your Clore instance of quai-gpu-miner. This will start the mining process and charge your account for compute.

### Managing Your Instance

Once your miner is running, you can use the [My orders](https://clore.ai/marketplace) tab to manage your Clore instance.

You can verify that your instance is running by checking the miner logs through Clore or via your [stratum logs](/guides/client/stratum#run).


# Docker Installation
Source: https://docs.qu.ai/guides/miner/docker

Install and run a Quai Network GPU miner using the provided Docker image(s).

## Introduction

Here, we'll be running an instance of [quai-gpu-miner](https://github.com/dominant-strategies/quai-gpu-miner), the implementation of a Quai Network ProgPOW miner, via Docker.

Docker is a platform for creating, managing, and running containers. Containers are beneficial because they can package all the dependencies needed to run an application.

## Requirements

In order to run the quai-gpu-miner with Docker and mine valid blocks, you'll need the following:

<CardGroup>
  <Card title="Synced go-quai node" href="/guides/client/node" icon="computer" />

  <Card title="Configured Stratum proxy" href="/guides/client/stratum" icon="router" />

  <Card title="NVIDIA or AMD GPU" icon="microchip" />

  <Card title="4GB+ of RAM" icon="usb-drive" />
</CardGroup>

## Environment Setup

You'll need to have docker installed. You can learn more about how to do that on [Docker's installation instructions](https://docs.docker.com/engine/install/).

## Creating the miner binary

This section will explain how to build the miner binary yourself using Docker. You can skip to the next section if you are only interested in running with our provided binary.

```bash theme={null}
docker run --rm -v $(pwd)/output:/output quainetwork/quai-gpu-miner-build
```

<Note>
  You may need to run the command with `sudo` depending on how docker is configured on your system.
</Note>

This command will produce 4 artifacts in a new `output` folder:

* A binary and hive package for Nvidia GPUs.
* A binary and hive package for AMD GPUs.

Now that you have the binaries created, you can proceed to run it directly starting from the [dependencies and drivers](https://docs.qu.ai/guides/miner/ubuntu#dependencies-and-drivers) section of our Ubuntu instructions.

## Running the miner

You will need to run the following steps in order to give Docker access to your GPU.

1. `sudo apt install ubuntu-drivers-common && ubuntu-drivers autoinstall`
2. `sudo reboot`
3. `curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg && \
    curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
    sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
    sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list && \
    sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit`
4. `sudo nvidia-ctk runtime configure --runtime=docker`
5. `sudo systemctl restart docker`

To launch the miner, run the following command:

```bash theme={null}
docker run --rm --gpus all \
    --log-opt max-size=10m --log-opt max-file=1 \
    -e PLATFORM=U -e STRATUM_IP=YOUR_IP -e STRATUM_PORT=YOUR_STRATUM_PORT \
    quainetwork/quai-gpu-miner-run
```

<Note>
  You may need to run the command with `sudo` depending on how docker is configured on your system.
</Note>

<Note>
  This command also modifies the logging behavior of docker so that prints to stdout/stderr don't use an unlimited amount of storage on the host machine.
</Note>


# KawPoW Mining with HiveOS
Source: https://docs.qu.ai/guides/miner/hiveos-flight-sheet

Install and run a GPU miner on HiveOS using a Flight Sheet.

## Introduction

Here, we'll be installing and running [SRBMiner-Multi](https://github.com/doktor83/SRBMiner-Multi) on [HiveOS](https://hiveon.com/os/) using a [Flight Sheet](https://hiveon.com/knowledge-base/guides/fs/). HiveOS also provides a web based dashboard for streamlined management and maintenance of your Quai Network GPU miner.

### Requirements

In order to run the quai-gpu-miner on HiveOS and mine valid blocks, you'll need the following:

<CardGroup>
  <Card title="Synced go-quai node" href="/guides/client/node" icon="computer" />

  <Card title="Configured Stratum proxy" href="/guides/client/stratum" icon="router" />

  <Card title="HiveOS machine" icon="hive" />

  <Card title="NVIDIA or AMD GPU" icon="microchip" />

  <Card title="4GB+ of RAM" icon="usb-drive" />
</CardGroup>

## Environment Setup

### HiveOS

For this tutorial, you'll need a HiveOS machine. Instructions for how to install HiveOS on your rig and configure it can be found on the [HiveOS installation documentation](https://hiveon.com/install/).

### Dashboard

Once you've installed HiveOS, configure your GPU workers into a Farm. Once configured, you'll be able to manage workers from a [HiveOS dashboard](https://hiveon.com/knowledge-base/getting_started/start_dashboard_setup/) and utilize Flight Sheets.

## Installation

To start the Flight Sheet installation, open up your [HiveOS Farm Dashboard](https://the.hiveos.farm/).

<Steps>
  <Step title="Add Wallet">
    In the **farm menu**, click the *wallets* tab.

    <Frame>
      <img />
    </Frame>

    On the right side of the page, click the *add wallet* button.

    <Frame>
      <img />
    </Frame>

    Fill in the wallet information:

    * For the **Coin** field, type `Quai` then click on the *Create Quai* option in the drop-down menu.
    * In the **Address** field, copy/paste your Quai wallet address. (This address is not used by the miner, so you can put any address here.)
    * For **Name** field, choose a name for your wallet.

    To finish creating the wallet, click "Create" in the bottom right corner.

    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Add Flight Sheet">
    In the **farm menu**, click the flight sheets tab.

    <Frame>
      <img />
    </Frame>

    Click "add flight sheet". Fill out the flight sheet information:

    * For the Coin select `Quai`.
    * For the wallet select the wallet you configured above.
    * For pool select `Configure in miner`.
    * For the **Miner name**, select `SRBMiner-MULTI`.

    Next click `Setup Miner Config` right above where you selected `SRBMiner-MULTI`.

    <Frame>
      <img />
    </Frame>

    Configure your SRBMiner.

    * Set the Hash algorithm to `kawpow`.
    * for the Wallet type `%WAL%.%WORKER_NAME%`.
    * For the **Pool URL**, type `stratum://EXTERNALIPADDRESS:PORT`. Replace EXTERNALIPADDRESS and PORT with your stratum ip address and port.

    <Frame>
      <img />
    </Frame>

    On bottom right corner, click "Apply Changes".

    Once the miner is configured you should give your Flight Sheet a name and click `Create Flight Sheet`.

    <Frame>
      <img />
    </Frame>
  </Step>
</Steps>

## Launch The Flight Sheet

The steps to begin mining are:

* simply visit your worker's page on HiveOS.
* Navigate to the Flight Sheet tab.
* Launch the Flight Sheet you just created.

<Frame>
  <img />
</Frame>

It will take a few seconds for HiveOS to install and run the flightsheet on your worker machine. Once running, SRB Miner will run through an auto-tune process before it settles in and begins mining at optimal performance.

If you're logged into your HiveOS Worker you should see output similar to the following. If not, simply run the command `hive-console` to open the proper view.

<Frame>
  <img />
</Frame>

You are now mining Quai with your GPUs on the KawPoW algorithm using HiveOS and SRB Miner!


# Mining Pools & Software
Source: https://docs.qu.ai/guides/miner/pools-software

Available mining pools and software for Quai Network miners.

> **Disclaimer**: Quai Network does not endorse any specific mining pools or software. Users should conduct their own research and use third-party services at their own risk.

## KawPoW Mining Software

| Software Name  | Repository                                                                                                 |
| -------------- | ---------------------------------------------------------------------------------------------------------- |
| SRBMiner-Multi | [https://github.com/doktor83/SRBMiner-Multi](https://github.com/doktor83/SRBMiner-Multi)                   |
| Rigel          | [https://github.com/rigelminer/rigel](https://github.com/rigelminer/rigel)                                 |
| WildRig Multi  | [https://github.com/andru-kun/wildrig-multi/releases](https://github.com/andru-kun/wildrig-multi/releases) |

## Available Mining Pools

| Pool Name    | Website                                                                  |
| ------------ | ------------------------------------------------------------------------ |
| StratumX     | [https://www.stratumx.org/](https://www.stratumx.org/)                   |
| AlphaPool    | [https://alphapool.tech](https://alphapool.tech)                         |
| HeroMiners   | [https://quai.herominers.com](https://quai.herominers.com)               |
| K1Pool       | [https://k1pool.com/pool/quaikawpow](https://k1pool.com/pool/quaikawpow) |
| Kryptex      | [https://pool.kryptex.com/quai](https://pool.kryptex.com/quai)           |
| Hash-Hut     | [https://hash-hut.net/](https://hash-hut.net/)                           |
| PowerPool    | [https://powerpool.io/](https://powerpool.io/)                           |
| Mining Dutch | [https://www.mining-dutch.nl/](https://www.mining-dutch.nl/)             |
| HIMPOOL      | [https://himpool.com/](https://himpool.com/)                             |
| 2Miners      | \[[https://2miners.com](https://2miners.com)]                            |

Want to add your pool or software to this list? Submit a PR to our [documentation repository](https://github.com/dominant-strategies/quai-docs).


# SHA & Scrypt Mining
Source: https://docs.qu.ai/guides/miner/sha-scrypt-mining

Mine Quai Network with SHA and Scrypt ASICs using the SOAP upgrade.

With the Subsidized Open-market Acquisition Protocol (SOAP) upgrade, Quai Network is now mineable by SHA and Scrypt ASICs. Project SOAP takes Quai from being solely GPU mined with ProgPoW to multi-algo mined with SHA, Scrypt, and KawPoW.

## Why Mine Quai?

### More Profitable

With the new addition of SHA and Scrypt, mining Quai will be more profitable than mining Bitcoin, Bitcoin Cash, Litecoin+DOGE, or Ravencoin.

Not only will Quai Network be more profitable, Quai Network will be more sustainable long term for miners given the unique buyback mechanism from the SOAP upgrade.

### Low Switching Costs

Switching to mine Quai Network with SHA or Scrypt hashrate is as simple as generating a Quai Network address and pointing your hardware to a Quai Network mining pool.

### Less Miner Competition

In traditional mining, where increased hashrate due to competition has a negative impact on value due to more miners selling rewards to cover costs, SOAP mining introduces a buy-back mechanism to neutralize that sell pressure. This creates a net-neutral impact to token value in a worst case scenario, and positive pressure in all other cases. The more hashrate that enters the network, the more buy-backs occur via Project SOAP.

## How to SOAP Mine Quai in Two Steps

### 1. Generate a Quai Network Address

You can generate a Quai address by visiting the Google Chrome store to download the Pelagus wallet or generate a Quai address in Tangem.

### 2. Point your SHA or Scrypt ASIC at a Quai Network mining pool

A variety of pools for both SHA256 and SCRYPT miners are available, as well as GPU miners who are interested in KawPow.

### Mining Pools

#### KawPoW

* **StratumX**
  [https://www.stratumx.org/mine/connect?algo=kawpow](https://www.stratumx.org/mine/connect?algo=kawpow)
* **Kryptex**\
  [https://pool.kryptex.com/quai-kawpow](https://pool.kryptex.com/quai-kawpow)
* **Herominers**\
  [https://quai.herominers.com/](https://quai.herominers.com/)
* **K1Pool**\
  [https://k1pool.com/pool/quaikawpow](https://k1pool.com/pool/quaikawpow)
* **AlphaMine**\
  [https://quai.alphapool.tech/](https://quai.alphapool.tech/)
* **2Miners**
  [https://2miners.com/quaikawpow-mining-pool](https://2miners.com/quaikawpow-mining-pool)

#### SHA256

* **StratumX**
  [https://www.stratumx.org/mine/connect?algo=sha](https://www.stratumx.org/mine/connect?algo=sha)
* **Kryptex**\
  [https://pool.kryptex.com/quai-sha256](https://pool.kryptex.com/quai-sha256)
* **AlphaMine**\
  [https://quai.alphapool.tech/](https://quai.alphapool.tech/)
* **Hash-Hut**
  [https://hash-hut.net/](https://hash-hut.net/)
* **PowerPool**
  [https://powerpool.io/](https://powerpool.io/)
* **Mining Dutch**
  [https://www.mining-dutch.nl/pools/quai.php?page=dashboard](https://www.mining-dutch.nl/pools/quai.php?page=dashboard)
* **HIMPOOL**
  [https://himpool.com/pools/quai-sha256](https://himpool.com/pools/quai-sha256)
* **2Miners**
  [https://2miners.com/quaisha-mining-pool](https://2miners.com/quaisha-mining-pool)

#### Scrypt

* **StratumX**
  [https://www.stratumx.org/mine/connect?algo=scrypt](https://www.stratumx.org/mine/connect?algo=scrypt)
* **Kryptex**\
  [https://pool.kryptex.com/quai-scrypt](https://pool.kryptex.com/quai-scrypt)
* **AlphaMine**\
  [https://quai.alphapool.tech/](https://quai.alphapool.tech/)
* **Hash-Hut**
  [https://hash-hut.net/](https://hash-hut.net/)
* **PowerPool**
  [https://powerpool.io/](https://powerpool.io/)
* **Mining Dutch**
  [https://www.mining-dutch.nl/pools/quai\_scrypt.php?page=dashboard](https://www.mining-dutch.nl/pools/quai_scrypt.php?page=dashboard)
* **HIMPOOL**
  [https://himpool.com/pools/quai-scrypt](https://himpool.com/pools/quai-scrypt)


# Ubuntu Installation
Source: https://docs.qu.ai/guides/miner/ubuntu

Install and run a Quai Network GPU miner on Ubuntu.

<Warning>
  Running a GPU miner on an Ubuntu based Virtual Machine may not work properly. This includes most VMs that run on top of Windows or WSL2.
</Warning>

## Introduction

Here, we'll be installing [quai-gpu-miner](https://github.com/dominant-strategies/quai-gpu-miner), the implementation of a Quai Network ProgPOW miner. This tutorial will focus on installing and running quai-gpu-miner on [Ubuntu](https://ubuntu.com/), an enterprise and open source Linux distribution.

### Requirements

In order to run the quai-gpu-miner on Ubuntu and mine valid blocks, you'll need the following:

<CardGroup>
  <Card title="Synced go-quai node" href="/guides/client/node" icon="computer" />

  <Card title="Configured Stratum proxy" href="/guides/client/stratum" icon="router" />

  <Card title="Ubuntu machine" icon="ubuntu" />

  <Card title="AMD or NVIDIA GPU" icon="microchip" />

  <Card title="4GB+ of RAM" icon="usb-drive" />
</CardGroup>

## Environment Setup

### Ubuntu

For this tutorial, you'll need an Ubuntu machine. Instructions on how to download and install Ubuntu on your machine can be found on the [Ubuntu installation instructions](https://ubuntu.com/tutorials/install-ubuntu-desktop#1-overview).

<Note>
  The quai-gpu-miner is default configured to be compiled on Ubuntu v20.04. If you're using other versions of Ubuntu, you may need to change
  the CUDA toolkit version in the installation script.
</Note>

### Miner Installation

The [quai-gpu-miner](https://github.com/dominant-strategies/quai-gpu-miner) repository contains a [automated script](https://github.com/dominant-strategies/quai-gpu-miner/blob/main/deploy_miner.sh) that can be used to compile and build the miner. The `deploy_miner.sh` script will install the following build dependencies and build the latest version of the miner:

* git
* cmake
* build-essential
* mesa-common-dev
* [Nvidia CUDA Toolkit v12.6](https://developer.nvidia.com/cuda-12-6-0-download-archive)

To download the script, run the following command:

```bash theme={null}
wget https://raw.githubusercontent.com/dominant-strategies/quai-gpu-miner/refs/heads/main/deploy_miner.sh
```

Once the download is complete, make the `deploy_miner.sh` file executable:

```bash theme={null}
sudo chmod +x deploy_miner.sh
```

<Tip>
  This script installs the CUDA keyring version for Ubuntu v20.04. If you're using other versions of Ubuntu, you may need to edit the CUDA
  keyring version downloaded in the script. This can be done by changing the `/ubuntu2004/` to the version of Ubuntu you're using in the
  keyring download link.
</Tip>

Run the script with the following command:

```bash theme={null}
sudo ./deploy_miner.sh
```

<Warning>
  Running this command will compiling and build the miner. This process may take a while to complete, and requires around 10gb of RAM.
</Warning>

This will create an `output` directory with two built binaries in it: `quai-gpu-miner-amd` and `quai-gpu-miner-nvidia`. For the card type you have, run the following command to make the binary executable:

<Tabs>
  <Tab title="NVIDIA">
    ```bash theme={null}
    chmod +x output/quai-gpu-miner-nvidia
    ```
  </Tab>

  <Tab title="AMD">
    ```bash theme={null}
    chmod +x output/quai-gpu-miner-amd
    ```
  </Tab>
</Tabs>

### Dependencies and Drivers

Now that we've installed and built the miner, we need to make sure our system and drivers are up to date.

```bash theme={null}
sudo apt update && sudo apt upgrade -y
```

Then, install NVIDIA drivers:

```bash theme={null}
sudo apt install cuda-drivers
```

To apply the NVIDIA driver updates, restart your machine with:

```bash theme={null}
sudo reboot
```

## Configure And Run

To run the miner, you'll need a Stratum proxy to connect to. Visit the [quai-stratum-proxy](/guides/client/stratum) docs for information on how to install and configure it. The proxy configuration will determine which shard your gpu-miner is running on and the address payouts are awarded to.

First, you'll need to obtain the IP Address and port your proxy is running on from the Stratum proxy logs. The default port is `3333`.

<Note>
  If your miner and proxy are on the same machine, the `PROXYIPADDRESS` will be `localhost`. If your miner and proxy are not on the same
  machine, you may need to port forward the proxy port.
</Note>

Once you've obtained the IP Address and port, run the miner with the following command, making sure to replace `PROXYIPADDRESS` with the IP Address and `STRATUMPORT` with the port your proxy is running on:

<Tabs>
  <Tab title="NVIDIA">
    ```bash theme={null}
    ./output/quai-gpu-miner-nvidia -U -P stratum://PROXYIPADDRESS:STRATUMPORT
    ```
  </Tab>

  <Tab title="AMD">
    ```bash theme={null}
    ./output/quai-gpu-miner-amd -G -P stratum://PROXYIPADDRESS:STRATUMPORT
    ```
  </Tab>
</Tabs>

The quai-gpu-miner should now be running and outputting logs to the terminal.

<Warning>
  Do not start the miner before confirming your node has fully synced. Mining while your node is not synced will result in the mining of
  **invalid blocks** and **wasted hash**.
</Warning>

### Stop

To stop the miner, simple use **CTRL+C** to kill the terminal process. Once logs are no longer being outputted to the terminal, the miner has stopped.


# QUAI ↔ QI Conversions in Pelagus
Source: https://docs.qu.ai/guides/wallet/conversions

Learn how to convert between QUAI and QI using the Market Make feature in the Pelagus Wallet.

# How QUAI ↔ QI Conversions Work in the Pelagus Wallet (Market Make)

Starting **April 16, 2025**, you’ll be able to convert between **QUAI** and **QI** directly inside the [Pelagus](https://pelaguswallet.io) wallet through an advanced feature called **Market Make**.

Whether you're mining QI and want to swap to QUAI, or holding QUAI and want to convert into QI, this guide walks you through how Market Make works — including how **slippage**, **prime blocks**, and **token lockups** come into play.

***

## What is Market Make?

**Market Make** is Pelagus' advanced on-chain conversion feature that lets you exchange **QUAI ↔ QI**.

When you initiate a Market Make, you're submitting a special transaction to the Quai blockchain. It will execute during the **next prime block**—**if** your conditions are met.

***

## Step-by-Step: How Market Make Works

### 1. Start a Market Make Conversion

In the Pelagus wallet:

* Open the **Market Make** feature
* Choose your conversion direction (**QUAI → QI** or **QI → QUAI**)
* Enter the **amount**
* View the **current estimated slip**
* Set a **maximum slippage threshold** (e.g., `1.5%`)

***

### 2. Transaction Goes to Conversion Pool

Your Market Make transaction is submitted to the **Quai chain** and enters the **conversion pool**, where it waits for the **next prime block**.

***

### 3. Slippage May Change Before Finalization

> ⚠️  *Every conversion transaction will incur a 20 basis point slip*

During this waiting period:

* Other users may submit conversions
* **Total conversion pool volume increases**
* Result: **Slippage may increase dynamically**, especially during spikes in demand

***

### 4. What Happens at the Prime Block?

* **If final slippage ≤ your slippage threshold**:
  * Your conversion **succeeds**
  * You receive the **target asset (Qi or Quai)**
  * The output is **locked for 2 weeks**

* **If final slippage > your slippage threshold**:
  * Your conversion **fails**
  * But:
    * The transaction still executes on-chain
    * If converting **Qi → Quai**, your funds may be **aggregated**
    * After 2 weeks, you receive the **original asset** back

***

## What Is Slippage?

**Slippage** is the difference between the **expected** and **actual** conversion rate, driven by conversion volume changes in the conversion pool.

* Displayed at submission time
* **Not locked in** until the prime block
* Users set their **max slippage tolerance**
* **Higher conversion pool volume** = greater chance of slippage increasing

***

## 2-Week Lockup Applies to All Completed Transactions

Whether your transaction **succeeds or fails**:

* The output (QI or QUAI) is **locked for 2 weeks**
* This maintains system stability and prevents liquidity disruptions

***

## Key Things to Know

| Concept           | Details                                                                |
| ----------------- | ---------------------------------------------------------------------- |
| Timing            | Conversions settle at the **next prime block**, not instantly          |
| Slippage          | You define your **maximum acceptable slippage** at submission          |
| Slippage Behavior | Slip increases with **rising conversion pool volume**                  |
| Success Criteria  | Final slippage must be **≤ your threshold**                            |
| Failed Converts   | Receive **original asset**, locked 2 weeks, may be **aggregated** (QI) |
| Lockup Period     | All output tokens are **locked for 2 weeks**                           |

***

## Example: Market Make in Action

You want to convert **5,000 QUAI into QI**.

* You submit the Market Make with a **1.5% slippage threshold**
* At submission, current slippage is **0.7%**
* Other users then submit **100,000 Quai** in conversions before the next prime block
* Final slippage = **2.1%**

### Result:

* Your transaction **fails**
* You receive your **original 5,000 QUAI back**

> **💡 Pro Tip**\
> To increase your chance of success:
>
> * Choose a **reasonable slippage threshold** based on recent volume trends
> * **Submit your transaction shortly after a prime block**, when the conversion pool volume has reset
>
> For more information on the relationship between QUAI and QI see our [blog post](https://qu.ai/blog/maximizing-mining-strategy-in-quai-network-choosing-between-quai-and-qi-tokens/) on the topic.

***

Need help or want to dive deeper? [Visit the Pelagus documentation](https://pelaguswallet.io/docs/) or join the Quai Discord to chat with the community.


# Quai Wallet MetaMask Snap
Source: https://docs.qu.ai/guides/wallet/metamask-snap

Learn how to send and receive Quai in your MetaMask wallet with the Quai Wallet snap.

## Overview

The Quai Wallet snap allows MetaMask users to send and receive QUAI tokens on Quai mainnet. It also enables Quai dApps to interact with MetaMask users who have the snap installed. This integration provides a seamless way for MetaMask users to access the Quai Network ecosystem without needing a separate wallet.

## Features

<CardGroup>
  <Card title="QUAI Token Support" icon="coins">
    Send and receive QUAI tokens on Quai mainnet directly through MetaMask
  </Card>

  <Card title="dApp Integration" icon="puzzle-piece">
    Interact with Quai dApps when support is added, using your existing MetaMask interface
  </Card>

  <Card title="Deterministic Address" icon="key">
    Your Quai address is generated from your MetaMask keys, ensuring consistency across installations
  </Card>

  <Card title="No Seed Phrase Required" icon="shield-check">
    No additional seed phrase needed - your Quai wallet is derived from your existing MetaMask keys
  </Card>
</CardGroup>

## Installation

### Step 1: Install from MetaMask Snaps Directory

1. Visit the [MetaMask Snaps Directory](https://snaps.metamask.io)
2. Search for "Quai Wallet" or navigate to the Quai Wallet snap
3. Click "Add to MetaMask" to install the snap
4. Follow the MetaMask prompts to approve the installation

### Step 2: Access Your Quai Wallet

Once installed, you can access your Quai wallet through MetaMask:

1. Open the MetaMask extension
2. Click the three dashed lines (⋮⋮⋮) at the top right of the MetaMask window
3. Click on "Snaps" in the dropdown list
4. Click on "Quai Wallet" in the list
5. Wait for the snap to generate your Quai wallet (this will take a few seconds)

<Warning>
  If you do not see "Quai Wallet" in the Snaps list, ensure you have successfully installed the snap from the Snaps Directory first.
</Warning>

## Wallet Generation

The Quai Wallet snap generates your wallet address deterministically from your MetaMask keys. This means:

* **No seed phrase required**: Your Quai address is derived from your existing MetaMask account
* **Consistent addresses**: As long as you have your MetaMask keys, you will always generate the same Quai address
* **Secure**: Your Quai wallet inherits the security of your MetaMask setup

## Usage

### Sending QUAI Tokens

1. Access your Quai Wallet through the MetaMask Snaps interface
2. Click "Send" or "Transfer"
3. Enter the recipient's Quai address
4. Specify the amount of QUAI to send
5. Review the transaction details
6. Confirm the transaction through MetaMask

### Receiving QUAI Tokens

1. Access your Quai Wallet through the MetaMask Snaps interface
2. Copy your Quai address from the wallet interface
3. Share this address with others to receive QUAI tokens
4. Incoming transactions will appear in your transaction history

## Security Considerations

* Your Quai wallet is as secure as your MetaMask wallet
* Always verify transaction details before confirming
* Keep your MetaMask seed phrase safe - it controls both your Ethereum and Quai wallets
* Be cautious of phishing attempts and only install snaps from official sources

<Frame>
  <img alt="MetaMask Snap UI screenshot" />
</Frame>

## Troubleshooting

### Snap Not Appearing

* Ensure you've successfully installed the snap from the MetaMask Snaps Directory
* Try refreshing MetaMask or restarting your browser
* Check that you're using a supported version of MetaMask

### Wallet Generation Issues

* Wait a few seconds for the wallet to generate
* If issues persist, try removing and reinstalling the snap
* Ensure your MetaMask is properly set up and unlocked

### Transaction Issues

* Verify you have sufficient QUAI balance for the transaction
* Ensure the recipient address is a valid Quai address

## Support

For issues with the Quai Wallet snap:

* Check the [MetaMask Snaps documentation](https://docs.metamask.io/guide/snaps.html)
* Visit the [Quai Network community channels](https://discord.gg/quai)
* Review the [Quai Network documentation](/learn/introduction)

## Frequently Asked Questions

<AccordionGroup>
  <Accordion title="What is a MetaMask Snap?">
    MetaMask Snaps are programs that extend the functionality of MetaMask. They allow developers to add new features and capabilities to the MetaMask wallet, such as supporting new blockchains like Quai Network.
  </Accordion>

  <Accordion title="Do I need a separate wallet for Quai Network?">
    Not necessarily. The Quai Wallet snap allows you to interact with Quai Network directly through your existing MetaMask wallet. You don't need to install or manage a separate wallet application. However, for users who want the best experience with dApps, we recommend installing [Pelagus Wallet](https://pelaguswallet.io)
  </Accordion>

  <Accordion title="Is the Quai Wallet snap safe to use?">
    Yes, the Quai Wallet snap was audited by Hacken and is designed with security in mind. It generates your Quai address deterministically from your existing MetaMask keys, so it inherits the security of your MetaMask setup.
  </Accordion>

  <Accordion title="Can I store other tokens in the Quai Wallet snap?">
    Not yet. You can receive QRC20 tokens to your address, but you currently cannot send them. This will be fixed in the next update.
  </Accordion>

  <Accordion title="Can I interact with Quai dApps with the Quai Wallet snap?">
    Not yet. Quai dApps have to add support specifically for the Quai Wallet snap. It is a different process than integrating MetaMask directly. We will update here when dApps have added support for Quai Wallet snap. If you are interested in interacting with Quai dApps, we recommend you install [Pelagus Wallet](https://pelaguswallet.io)
  </Accordion>

  <Accordion title="Can I create a new address within the Quai Wallet snap?">
    No, the Quai Wallet snap was designed with the basics in mind. Your Quai address is generated from your MetaMask keys and currently only one address is generated from each MetaMask seed phrase. If you wish to generate multiple Quai addresses, we recommend you install [Pelagus Wallet](https://pelaguswallet.io)
  </Accordion>

  <Accordion title="I can't find the Quai Wallet snap in the Snaps Directory. What should I do?">
    Make sure you're visiting the official MetaMask Snaps Directory at [https://snaps.metamask.io](https://snaps.metamask.io). If you still can't find it, the snap might be temporarily unavailable or you may need to update your MetaMask version.
  </Accordion>

  <Accordion title="Why does it take a few seconds to generate my Quai wallet?">
    The snap needs to derive your Quai address from your MetaMask keys using cryptographic functions. This process takes a few seconds but only happens once per session.
  </Accordion>

  <Accordion title="Will I get the same Quai address every time I install the snap with the same MetaMask account?">
    Yes! Since your Quai address is generated deterministically from your MetaMask keys, you will always get the same address as long as you use the same MetaMask account.
  </Accordion>

  <Accordion title="Can I send QUAI tokens to any Ethereum address?">
    No, you can only send QUAI tokens to valid Quai addresses. Quai addresses look like Ethereum addresses but start with 0x00.
  </Accordion>

  <Accordion title="How do I know if a transaction was successful?">
    You can check the transaction status in your Quai Wallet interface within MetaMask, or on [Quaiscan](https://quaiscan.io).
  </Accordion>

  <Accordion title="What happens if I send QUAI to an invalid address?">
    If you send QUAI to an invalid address, the transaction will fail and your tokens should be returned. Always double-check addresses before sending.
  </Accordion>

  <Accordion title="Can I use the Quai Wallet snap with existing Ethereum dApps?">
    The Quai Wallet snap is specifically designed for Quai interactions. For Ethereum dApps, you'll continue to use your regular MetaMask wallet.
  </Accordion>

  <Accordion title="I'm getting an error when trying to send QUAI. What could be wrong?">
    Common issues include insufficient QUAI balance, invalid recipient address, or network connectivity problems. Check your balance and verify the recipient address format.
  </Accordion>

  <Accordion title="Can I export my Quai private keys?">
    Not yet. The Quai Wallet snap currently doesn't provide direct access to private keys. Your Quai wallet is derived from your MetaMask keys, so as long as you have access to your MetaMask account, you have access to your Quai wallet. This will be updated in a future version.
  </Accordion>
</AccordionGroup>

<Info>
  The Quai Wallet snap is designed to provide a seamless bridge between MetaMask users and the Quai Network ecosystem. As the ecosystem continues to grow, expect more features and dApp integrations to become available.
</Info>


# LangEn
Source: https://docs.qu.ai/sdk/content/classes/LangEn



The [English wordlist](https://github.com/bitcoin/bips/blob/master/bip-0039/english.txt) for [mnemonic
phrases](https://en.bitcoin.it/wiki/BIP_0039).

## Extends

* [`WordlistOwl`](/sdk/content/classes/WordlistOwl)

## Methods

### \_decodeWords()

```ts theme={null}
_decodeWords(): string[]
```

Decode all the words for the wordlist.

#### Returns

`string`\[]

#### Inherited from

[`WordlistOwl`](/sdk/content/classes/WordlistOwl).[`_decodeWords`](/sdk/content/classes/WordlistOwl#_decodewords)

#### Source

[wordlists/wordlist-owl.ts:47](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wordlists/wordlist-owl.ts#L47)

***

### join()

```ts theme={null}
join(words): string
```

Sub-classes may override this to provider a language-specific method for joining `words` into a phrase.

By default, `words` are joined by a single space.

#### Parameters

| Parameter | Type        | Description        |
| :-------- | :---------- | :----------------- |
| `words`   | `string`\[] | The words to join. |

#### Returns

`string`

The joined phrase.

#### Inherited from

[`WordlistOwl`](/sdk/content/classes/WordlistOwl).[`join`](/sdk/content/classes/WordlistOwl#join)

#### Source

[wordlists/wordlist.ts:45](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wordlists/wordlist.ts#L45)

***

### split()

```ts theme={null}
split(phrase): string[]
```

Sub-classes may override this to provide a language-specific method for spliting `phrase` into individual words.

By default, `phrase` is split using any sequences of white-space as defined by regular expressions (i.e.
`/\s+/`).

#### Parameters

| Parameter | Type     | Description          |
| :-------- | :------- | :------------------- |
| `phrase`  | `string` | The phrase to split. |

#### Returns

`string`\[]

The split words in the phrase.

#### Inherited from

[`WordlistOwl`](/sdk/content/classes/WordlistOwl).[`split`](/sdk/content/classes/WordlistOwl#split)

#### Source

[wordlists/wordlist.ts:33](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wordlists/wordlist.ts#L33)

***

### wordlist()

```ts theme={null}
static wordlist(): LangEn
```

Returns a singleton instance of a `LangEn`, creating it if this is the first time being called.

#### Returns

[`LangEn`](/sdk/content/classes/LangEn)

#### Source

[wordlists/lang-en.ts:30](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wordlists/lang-en.ts#L30)


# LangEs
Source: https://docs.qu.ai/sdk/content/classes/LangEs



The [Spanish wordlist](https://github.com/bitcoin/bips/blob/master/bip-0039/spanish.txt) for [mnemonic
phrases](https://en.bitcoin.it/wiki/BIP_0039).

## Extends

* [`WordlistOwlA`](/sdk/content/classes/WordlistOwlA)

## Methods

### join()

```ts theme={null}
join(words): string
```

Sub-classes may override this to provider a language-specific method for joining `words` into a phrase.

By default, `words` are joined by a single space.

#### Parameters

| Parameter | Type        | Description        |
| :-------- | :---------- | :----------------- |
| `words`   | `string`\[] | The words to join. |

#### Returns

`string`

The joined phrase.

#### Inherited from

[`WordlistOwlA`](/sdk/content/classes/WordlistOwlA).[`join`](/sdk/content/classes/WordlistOwlA#join)

#### Source

[wordlists/wordlist.ts:45](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wordlists/wordlist.ts#L45)

***

### split()

```ts theme={null}
split(phrase): string[]
```

Sub-classes may override this to provide a language-specific method for spliting `phrase` into individual words.

By default, `phrase` is split using any sequences of white-space as defined by regular expressions (i.e.
`/\s+/`).

#### Parameters

| Parameter | Type     | Description          |
| :-------- | :------- | :------------------- |
| `phrase`  | `string` | The phrase to split. |

#### Returns

`string`\[]

The split words in the phrase.

#### Inherited from

[`WordlistOwlA`](/sdk/content/classes/WordlistOwlA).[`split`](/sdk/content/classes/WordlistOwlA#split)

#### Source

[wordlists/wordlist.ts:33](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wordlists/wordlist.ts#L33)

***

### wordlist()

```ts theme={null}
static wordlist(): LangEs
```

Returns a singleton instance of a `LangEs`, creating it if this is the first time being called.

#### Returns

[`LangEs`](/sdk/content/classes/LangEs)

#### Source

[wordlists/lang-es.ts:32](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wordlists/lang-es.ts#L32)


# Mnemonic
Source: https://docs.qu.ai/sdk/content/classes/Mnemonic



A **Mnemonic** wraps all properties required to compute [BIP-39](https://en.bitcoin.it/wiki/BIP_0039) seeds and
convert between phrases and entropy.

## Constructors

### new Mnemonic()

```ts theme={null}
new Mnemonic(
   guard, 
   entropy, 
   phrase, 
   password?, 
   wordlist?): Mnemonic
```

#### Parameters

| Parameter   | Type                                                  | Description                    |
| :---------- | :---------------------------------------------------- | :----------------------------- |
| `guard`     | `any`                                                 | The guard object.              |
| `entropy`   | `string`                                              | The entropy.                   |
| `phrase`    | `string`                                              | The mnemonic phrase.           |
| `password`? | `null` \| `string`                                    | The password for the mnemonic. |
| `wordlist`? | `null` \| [`Wordlist`](/sdk/content/classes/Wordlist) | The wordlist for the mnemonic. |

#### Returns

[`Mnemonic`](/sdk/content/classes/Mnemonic)

#### Source

[wallet/mnemonic.ts:175](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/mnemonic.ts#L175)

## Properties

| Property   | Modifier   | Type                                        | Description                                                                                                                                                     |
| :--------- | :--------- | :------------------------------------------ | :-------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `entropy`  | `readonly` | `string`                                    | The underlying entropy which the mnemonic encodes.                                                                                                              |
| `password` | `readonly` | `string`                                    | The password used for this mnemonic. If no password is used this is the empty string (i.e. `""`) as per the<br />specification.                                 |
| `phrase`   | `readonly` | `string`                                    | The mnemonic phrase of 12, 15, 18, 21 or 24 words.<br /><br />Use the [**wordlist**](/sdk/content/classes/Mnemonic) `split` method to get the individual words. |
| `wordlist` | `readonly` | [`Wordlist`](/sdk/content/classes/Wordlist) | The wordlist for this mnemonic.                                                                                                                                 |

## Methods

### computeSeed()

```ts theme={null}
computeSeed(): string
```

Returns the seed for the mnemonic.

#### Returns

`string`

The seed.

#### Source

[wallet/mnemonic.ts:191](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/mnemonic.ts#L191)

***

### entropyToPhrase()

```ts theme={null}
static entropyToPhrase(_entropy, wordlist?): string
```

Returns the phrase for `mnemonic`.

#### Parameters

| Parameter   | Type                                                  | Description                    |
| :---------- | :---------------------------------------------------- | :----------------------------- |
| `_entropy`  | [`BytesLike`](/sdk/content/type-aliases/BytesLike)    | The entropy for the mnemonic.  |
| `wordlist`? | `null` \| [`Wordlist`](/sdk/content/classes/Wordlist) | The wordlist for the mnemonic. |

#### Returns

`string`

The mnemonic phrase.

#### Source

[wallet/mnemonic.ts:248](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/mnemonic.ts#L248)

***

### fromEntropy()

```ts theme={null}
static fromEntropy(
   _entropy, 
   password?, 
   wordlist?): Mnemonic
```

Create a new **Mnemonic** from the `entropy`.

The default `password` is the empty string and the default wordlist is the \[[**English wordlist**](/sdk/content/classes/LangEn).

#### Parameters

| Parameter   | Type                                                  | Description                    |
| :---------- | :---------------------------------------------------- | :----------------------------- |
| `_entropy`  | [`BytesLike`](/sdk/content/type-aliases/BytesLike)    | The entropy for the mnemonic.  |
| `password`? | `null` \| `string`                                    | The password for the mnemonic. |
| `wordlist`? | `null` \| [`Wordlist`](/sdk/content/classes/Wordlist) | The wordlist for the mnemonic. |

#### Returns

[`Mnemonic`](/sdk/content/classes/Mnemonic)

The new Mnemonic object.

#### Source

[wallet/mnemonic.ts:229](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/mnemonic.ts#L229)

***

### fromPhrase()

```ts theme={null}
static fromPhrase(
   phrase, 
   password?, 
   wordlist?): Mnemonic
```

Creates a new Mnemonic for the `phrase`.

The default `password` is the empty string and the default wordlist is the [**English wordlist**](/sdk/content/classes/LangEn).

#### Parameters

| Parameter   | Type                                                  | Description                    |
| :---------- | :---------------------------------------------------- | :----------------------------- |
| `phrase`    | `string`                                              | The mnemonic phrase.           |
| `password`? | `null` \| `string`                                    | The password for the mnemonic. |
| `wordlist`? | `null` \| [`Wordlist`](/sdk/content/classes/Wordlist) | The wordlist for the mnemonic. |

#### Returns

[`Mnemonic`](/sdk/content/classes/Mnemonic)

The new Mnemonic object.

#### Source

[wallet/mnemonic.ts:206](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/mnemonic.ts#L206)

***

### isValidMnemonic()

```ts theme={null}
static isValidMnemonic(phrase, wordlist?): boolean
```

Returns true if `phrase` is a valid [BIP-39](https://en.bitcoin.it/wiki/BIP_0039) phrase.

This checks all the provided words belong to the `wordlist`, that the length is valid and the checksum is
correct.

#### Parameters

| Parameter   | Type                                                  | Description                    |
| :---------- | :---------------------------------------------------- | :----------------------------- |
| `phrase`    | `string`                                              | The mnemonic phrase.           |
| `wordlist`? | `null` \| [`Wordlist`](/sdk/content/classes/Wordlist) | The wordlist for the mnemonic. |

#### Returns

`boolean`

True if the phrase is valid.

#### Throws

If the phrase is invalid.

#### Source

[wallet/mnemonic.ts:275](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/mnemonic.ts#L275)

***

### phraseToEntropy()

```ts theme={null}
static phraseToEntropy(phrase, wordlist?): string
```

Returns the entropy for `phrase`.

#### Parameters

| Parameter   | Type                                                  | Description                    |
| :---------- | :---------------------------------------------------- | :----------------------------- |
| `phrase`    | `string`                                              | The mnemonic phrase.           |
| `wordlist`? | `null` \| [`Wordlist`](/sdk/content/classes/Wordlist) | The wordlist for the mnemonic. |

#### Returns

`string`

The entropy.

#### Source

[wallet/mnemonic.ts:260](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/mnemonic.ts#L260)


# QiHDWallet
Source: https://docs.qu.ai/sdk/content/classes/QiHDWallet



The Qi HD wallet is a BIP44-compliant hierarchical deterministic wallet used for managing a set of addresses in the
Qi ledger. This is wallet implementation is the primary way to interact with the Qi UTXO ledger on the Quai network.

The Qi HD wallet supports:

* Adding accounts to the wallet heierchy
* Generating addresses for a specific account in any [Zone](/sdk/content/enumerations/Zone)
* Signing and sending transactions for any address in the wallet
* Serializing the wallet to JSON and deserializing it back to a wallet instance.

## Example

```ts theme={null}
import { QiHDWallet, Zone } from 'quais';
import { Outpoint } from '../../lib/commonjs/transaction/utxo';

const wallet = new QiHDWallet();
const cyrpus1Address = await wallet.getNextAddress(0, Zone.Cyrpus1); // get the first address in the Cyrpus1 zone
await wallet.sendTransaction({ txInputs: [...], txOutputs: [...] }); // send a transaction
const serializedWallet = wallet.serialize(); // serialize current (account/address) state of the wallet
.
.
.
const deserializedWallet = QiHDWallet.deserialize(serializedWallet); // create a new wallet instance from the serialized data
```

## Extends

* `AbstractHDWallet`\<[`QiAddressInfo`](/sdk/content/interfaces/QiAddressInfo)>

## Properties

| Property              | Modifier  | Type                               | Default value  | Description                                                                                                                                         |
| :-------------------- | :-------- | :--------------------------------- | :------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------- |
| `bip47HDNode`         | `private` | `HDNodeWallet`                     | `undefined`    | The BIP47 HDNode instance used for deriving payment code addresses. This follows the BIP47 derivation path<br />m/47'/969'/account'/0/index         |
| `changeBip44`         | `private` | `Bip44QiWallet`                    | `undefined`    | The BIP44 wallet instance used for deriving change (sending) addresses. This follows the BIP44 derivation path<br />m/44'/969'/account'/0/index     |
| `externalBip44`       | `private` | `Bip44QiWallet`                    | `undefined`    | The BIP44 wallet instance used for deriving external (receiving) addresses. This follows the BIP44 derivation<br />path m/44'/969'/account'/0/index |
| `paymentChannels`     | `private` | `Map`\<`string`, `PaymentChannel`> | `...`          | Map of payment channels indexed by counterparty payment code                                                                                        |
| `privatekeyWallet`    | `private` | `PrivatekeyQiWallet`               | `undefined`    | The private key wallet instance used for deriving addresses from private keys.                                                                      |
| `bip47derivationPath` | `private` | `string`                           | `"m/47'/969'"` | The BIP47 derivation path m/47'/969'                                                                                                                |

## Accessors

### openChannels

```ts theme={null}
get openChannels(): string[]
```

Gets the payment codes for all open channels.

#### Returns

`string`\[]

The payment codes for all open channels.

#### Source

[wallet/qi-hdwallet.ts:279](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L279)

## Methods

### addAddress()

```ts theme={null}
addAddress(account, addressIndex): QiAddressInfo
```

Adds a new address to the wallet.

#### Parameters

| Parameter      | Type     | Description         |
| :------------- | :------- | :------------------ |
| `account`      | `number` | The account number. |
| `addressIndex` | `number` | The address index.  |

#### Returns

[`QiAddressInfo`](/sdk/content/interfaces/QiAddressInfo)

The address info for the new address.

#### Overrides

`AbstractHDWallet.addAddress`

#### Source

[wallet/qi-hdwallet.ts:1542](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L1542)

***

### addChangeAddress()

```ts theme={null}
addChangeAddress(account, addressIndex): QiAddressInfo
```

Adds a new change address to the wallet.

#### Parameters

| Parameter      | Type     | Description         |
| :------------- | :------- | :------------------ |
| `account`      | `number` | The account number. |
| `addressIndex` | `number` | The address index.  |

#### Returns

[`QiAddressInfo`](/sdk/content/interfaces/QiAddressInfo)

The address info for the new address.

#### Source

[wallet/qi-hdwallet.ts:1556](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L1556)

***

### aggregate()

```ts theme={null}
aggregate(zone, options?): Promise<TransactionResponse>
```

Aggregates all the available UTXOs for the specified zone and account. This method creates a new transaction with
all the available UTXOs as inputs and as fewest outputs as possible.

#### Parameters

| Parameter  | Type                                     | Description                            |
| :--------- | :--------------------------------------- | :------------------------------------- |
| `zone`     | [`Zone`](/sdk/content/enumerations/Zone) | The zone to aggregate the balance for. |
| `options`? | `QiTransactionOptions`                   | Optional transaction configuration.    |

#### Returns

`Promise`\<[`TransactionResponse`](/sdk/content/type-aliases/TransactionResponse)>

The transaction response.

#### Source

[wallet/qi-hdwallet.ts:568](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L568)

***

### checkAddressUse()

```ts theme={null}
private checkAddressUse(address): Promise<{
  "isUsed": boolean;
  "outpoints": Outpoint[];
}>
```

Checks if the specified address is used by querying the network node for the outpoints of the address. If the
address is used, the outpoints are imported into the wallet.

#### Parameters

| Parameter | Type     | Description           |
| :-------- | :------- | :-------------------- |
| `address` | `string` | The address to check. |

#### Returns

`Promise`\<\{
`"isUsed"`: `boolean`;
`"outpoints"`: `Outpoint`\[];
}>

A promise that resolves to an object containing a
boolean indicating whether the address is used and an array of outpoints.

##### isUsed

```ts theme={null}
isUsed: boolean;
```

##### outpoints

```ts theme={null}
outpoints: Outpoint[];
```

#### Throws

If the query fails.

#### Source

[wallet/qi-hdwallet.ts:1086](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L1086)

***

### connect()

```ts theme={null}
connect(provider): void
```

Connects the wallet to a provider and propagates the connection to all subwallets.

#### Parameters

| Parameter  | Type                                           | Description   |
| :--------- | :--------------------------------------------- | :------------ |
| `provider` | [`Provider`](/sdk/content/interfaces/Provider) | The provider. |

#### Returns

`void`

#### Overrides

`AbstractHDWallet.connect`

#### Source

[wallet/qi-hdwallet.ts:259](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L259)

***

### convertToQuai()

```ts theme={null}
convertToQuai(
   destinationAddress, 
   amount, 
options?): Promise<TransactionResponse>
```

Converts an amount of Qi to Quai and sends it to a specified Quai address.

#### Parameters

| Parameter            | Type                   | Description                                     |
| :------------------- | :--------------------- | :---------------------------------------------- |
| `destinationAddress` | `string`               | The Quai address to send the converted Quai to. |
| `amount`             | `bigint`               | The amount of Qi to convert to Quai.            |
| `options`?           | `QiTransactionOptions` | Optional transaction configuration.             |

#### Returns

`Promise`\<[`TransactionResponse`](/sdk/content/type-aliases/TransactionResponse)>

A promise that resolves to the transaction response.

#### Throws

If the destination address is invalid, the amount is zero, or the conversion fails.

#### Source

[wallet/qi-hdwallet.ts:481](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L481)

***

### getAddressInfo()

```ts theme={null}
getAddressInfo(address): null | QiAddressInfo
```

Locates the address information for the given address, searching through standard addresses, change addresses,
and payment channel addresses.

#### Parameters

| Parameter | Type     | Description            |
| :-------- | :------- | :--------------------- |
| `address` | `string` | The address to locate. |

#### Returns

`null` | [`QiAddressInfo`](/sdk/content/interfaces/QiAddressInfo)

The address info or null if not found.

#### Overrides

`AbstractHDWallet.getAddressInfo`

#### Source

[wallet/qi-hdwallet.ts:426](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L426)

***

### getAddressesForAccount()

```ts theme={null}
getAddressesForAccount(account): QiAddressInfo[]
```

Gets the addresses for a given account.

#### Parameters

| Parameter | Type     | Description         |
| :-------- | :------- | :------------------ |
| `account` | `number` | The account number. |

#### Returns

[`QiAddressInfo`](/sdk/content/interfaces/QiAddressInfo)\[]

The addresses for the account.

#### Overrides

`AbstractHDWallet.getAddressesForAccount`

#### Source

[wallet/qi-hdwallet.ts:1569](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L1569)

***

### getAddressesForZone()

```ts theme={null}
getAddressesForZone(zone): QiAddressInfo[]
```

Gets the addresses for the specified zone.

#### Parameters

| Parameter | Type                                     | Description |
| :-------- | :--------------------------------------- | :---------- |
| `zone`    | [`Zone`](/sdk/content/enumerations/Zone) | The zone.   |

#### Returns

[`QiAddressInfo`](/sdk/content/interfaces/QiAddressInfo)\[]

The addresses for the zone.

#### Overrides

`AbstractHDWallet.getAddressesForZone`

#### Source

[wallet/qi-hdwallet.ts:1109](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L1109)

***

### getBalanceForZone()

```ts theme={null}
getBalanceForZone(zone): Promise<bigint>
```

Gets the total balance for a specific zone by summing balances from all address types:

* BIP44 external addresses
* BIP44 change addresses
* BIP47 payment channel addresses
* Imported private key addresses

#### Parameters

| Parameter | Type                                     | Description                     |
| :-------- | :--------------------------------------- | :------------------------------ |
| `zone`    | [`Zone`](/sdk/content/enumerations/Zone) | The zone to get the balance for |

#### Returns

`Promise`\<`bigint`>

The total balance in the zone as a bigint

#### Source

[wallet/qi-hdwallet.ts:1591](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L1591)

***

### getChangeAddressesForOutputs()

```ts theme={null}
private getChangeAddressesForOutputs(
   count, 
   zone, 
account?): Promise<string[]>
```

Gets a set of unused change addresses for transaction outputs and updates their status in the wallet. This method
retrieves unused BIP44 change addresses, marks them as attempted use, and maintains the wallet's address mapping
state.

#### Parameters

| Parameter  | Type                                     | Default value | Description                                              |
| :--------- | :--------------------------------------- | :------------ | :------------------------------------------------------- |
| `count`    | `number`                                 | `undefined`   | The number of change addresses needed                    |
| `zone`     | [`Zone`](/sdk/content/enumerations/Zone) | `undefined`   | The zone to get change addresses from                    |
| `account`? | `number`                                 | `0`           | The account index to use (defaults to 0). Default is `0` |

#### Returns

`Promise`\<`string`\[]>

A promise that resolves to an array of change addresses

#### Source

[wallet/qi-hdwallet.ts:853](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L853)

***

### getChangeAddressesForZone()

```ts theme={null}
getChangeAddressesForZone(zone): QiAddressInfo[]
```

Gets the change addresses for the specified zone.

#### Parameters

| Parameter | Type                                     | Description |
| :-------- | :--------------------------------------- | :---------- |
| `zone`    | [`Zone`](/sdk/content/enumerations/Zone) | The zone.   |

#### Returns

[`QiAddressInfo`](/sdk/content/interfaces/QiAddressInfo)\[]

The change addresses for the zone.

#### Source

[wallet/qi-hdwallet.ts:1120](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L1120)

***

### getGapAddressesForZone()

```ts theme={null}
getGapAddressesForZone(zone): QiAddressInfo[]
```

Gets the gap addresses for the specified zone.

#### Parameters

| Parameter | Type                                     | Description |
| :-------- | :--------------------------------------- | :---------- |
| `zone`    | [`Zone`](/sdk/content/enumerations/Zone) | The zone.   |

#### Returns

[`QiAddressInfo`](/sdk/content/interfaces/QiAddressInfo)\[]

The gap addresses for the zone.

#### Source

[wallet/qi-hdwallet.ts:1131](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L1131)

***

### getGapChangeAddressesForZone()

```ts theme={null}
getGapChangeAddressesForZone(zone): QiAddressInfo[]
```

Gets the gap change addresses for the specified zone.

#### Parameters

| Parameter | Type                                     | Description |
| :-------- | :--------------------------------------- | :---------- |
| `zone`    | [`Zone`](/sdk/content/enumerations/Zone) | The zone.   |

#### Returns

[`QiAddressInfo`](/sdk/content/interfaces/QiAddressInfo)\[]

The gap change addresses for the zone.

#### Source

[wallet/qi-hdwallet.ts:1143](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L1143)

***

### getGapPaymentChannelAddressesForZone()

```ts theme={null}
getGapPaymentChannelAddressesForZone(paymentCode, zone): QiAddressInfo[]
```

Gets the gap payment channel addresses for the specified payment code.

#### Parameters

| Parameter     | Type                                     | Description       |
| :------------ | :--------------------------------------- | :---------------- |
| `paymentCode` | `string`                                 | The payment code. |
| `zone`        | [`Zone`](/sdk/content/enumerations/Zone) | -                 |

#### Returns

[`QiAddressInfo`](/sdk/content/interfaces/QiAddressInfo)\[]

The gap payment channel addresses for the payment code.

#### Source

[wallet/qi-hdwallet.ts:1166](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L1166)

***

### getImportedAddresses()

```ts theme={null}
getImportedAddresses(zone?): QiAddressInfo[]
```

Gets all addresses that were imported via private keys.

#### Parameters

| Parameter | Type                                     | Description                          |
| :-------- | :--------------------------------------- | :----------------------------------- |
| `zone`?   | [`Zone`](/sdk/content/enumerations/Zone) | Optional zone to filter addresses by |

#### Returns

[`QiAddressInfo`](/sdk/content/interfaces/QiAddressInfo)\[]

Array of address info objects for imported addresses

#### Source

[wallet/qi-hdwallet.ts:1531](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L1531)

***

### getNextAddress()

```ts theme={null}
getNextAddress(account, zone): Promise<QiAddressInfo>
```

Promise that resolves to the next address for the specified account and zone.

#### Parameters

| Parameter | Type                                     | Description         |
| :-------- | :--------------------------------------- | :------------------ |
| `account` | `number`                                 | The account number. |
| `zone`    | [`Zone`](/sdk/content/enumerations/Zone) | The zone.           |

#### Returns

`Promise`\<[`QiAddressInfo`](/sdk/content/interfaces/QiAddressInfo)>

The next Qi address information.

#### Overrides

`AbstractHDWallet.getNextAddress`

#### Source

[wallet/qi-hdwallet.ts:301](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L301)

***

### getNextAddressSync()

```ts theme={null}
getNextAddressSync(account, zone): QiAddressInfo
```

Synchronously retrieves the next address for the specified account and zone.

#### Parameters

| Parameter | Type                                     | Description         |
| :-------- | :--------------------------------------- | :------------------ |
| `account` | `number`                                 | The account number. |
| `zone`    | [`Zone`](/sdk/content/enumerations/Zone) | The zone.           |

#### Returns

[`QiAddressInfo`](/sdk/content/interfaces/QiAddressInfo)

The next Qi address information.

#### Overrides

`AbstractHDWallet.getNextAddressSync`

#### Source

[wallet/qi-hdwallet.ts:312](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L312)

***

### getNextChangeAddress()

```ts theme={null}
getNextChangeAddress(account, zone): Promise<QiAddressInfo>
```

Promise that resolves to the next change address for the specified account and zone.

#### Parameters

| Parameter | Type                                     | Description                                                             |
| :-------- | :--------------------------------------- | :---------------------------------------------------------------------- |
| `account` | `number`                                 | The index of the account for which to retrieve the next change address. |
| `zone`    | [`Zone`](/sdk/content/enumerations/Zone) | The zone in which to retrieve the next change address.                  |

#### Returns

`Promise`\<[`QiAddressInfo`](/sdk/content/interfaces/QiAddressInfo)>

The next change neutered address information.

#### Source

[wallet/qi-hdwallet.ts:323](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L323)

***

### getNextChangeAddressSync()

```ts theme={null}
getNextChangeAddressSync(account, zone): QiAddressInfo
```

Synchronously retrieves the next change address for the specified account and zone.

#### Parameters

| Parameter | Type                                     | Description                                                             |
| :-------- | :--------------------------------------- | :---------------------------------------------------------------------- |
| `account` | `number`                                 | The index of the account for which to retrieve the next change address. |
| `zone`    | [`Zone`](/sdk/content/enumerations/Zone) | The zone in which to retrieve the next change address.                  |

#### Returns

[`QiAddressInfo`](/sdk/content/interfaces/QiAddressInfo)

The next change neutered address information.

#### Source

[wallet/qi-hdwallet.ts:334](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L334)

***

### getNextReceiveAddress()

```ts theme={null}
getNextReceiveAddress(
   senderPaymentCode, 
   zone, 
   account): QiAddressInfo
```

Generates a payment address for receiving funds from the specified sender's BIP47 payment code. Uses
Diffie-Hellman key exchange to derive the address from the sender's public key and receiver's private key.

#### Parameters

| Parameter           | Type                                     | Default value | Description                                          |
| :------------------ | :--------------------------------------- | :------------ | :--------------------------------------------------- |
| `senderPaymentCode` | `string`                                 | `undefined`   | The Base58-encoded BIP47 payment code of the sender. |
| `zone`              | [`Zone`](/sdk/content/enumerations/Zone) | `undefined`   | -                                                    |
| `account`           | `number`                                 | `0`           | -                                                    |

#### Returns

[`QiAddressInfo`](/sdk/content/interfaces/QiAddressInfo)

A promise that resolves to the payment address for receiving funds.

#### Throws

Throws an error if the payment code version is invalid.

#### Source

[wallet/qi-hdwallet.ts:1473](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L1473)

***

### getNextSendAddress()

```ts theme={null}
getNextSendAddress(
   receiverPaymentCode, 
   zone, 
   account): QiAddressInfo
```

Generates a payment address for sending funds to the specified receiver's BIP47 payment code. Uses Diffie-Hellman
key exchange to derive the address from the receiver's public key and sender's private key.

#### Parameters

| Parameter             | Type                                     | Default value | Description                                            |
| :-------------------- | :--------------------------------------- | :------------ | :----------------------------------------------------- |
| `receiverPaymentCode` | `string`                                 | `undefined`   | The Base58-encoded BIP47 payment code of the receiver. |
| `zone`                | [`Zone`](/sdk/content/enumerations/Zone) | `undefined`   | -                                                      |
| `account`             | `number`                                 | `0`           | -                                                      |

#### Returns

[`QiAddressInfo`](/sdk/content/interfaces/QiAddressInfo)

A promise that resolves to the payment address for sending funds.

#### Throws

Throws an error if the payment code version is invalid.

#### Source

[wallet/qi-hdwallet.ts:1457](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L1457)

***

### getOutpoints()

```ts theme={null}
getOutpoints(zone): OutpointInfo[]
```

Gets the outpoints for the specified zone.

#### Parameters

| Parameter | Type                                     | Description |
| :-------- | :--------------------------------------- | :---------- |
| `zone`    | [`Zone`](/sdk/content/enumerations/Zone) | The zone.   |

#### Returns

[`OutpointInfo`](/sdk/content/interfaces/OutpointInfo)\[]

The outpoints for the zone.

#### Source

[wallet/qi-hdwallet.ts:388](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L388)

***

### getPaymentChannelAddressesForZone()

```ts theme={null}
getPaymentChannelAddressesForZone(paymentCode, zone): QiAddressInfo[]
```

Gets the payment channel addresses for the specified zone.

#### Parameters

| Parameter     | Type                                     | Description       |
| :------------ | :--------------------------------------- | :---------------- |
| `paymentCode` | `string`                                 | The payment code. |
| `zone`        | [`Zone`](/sdk/content/enumerations/Zone) | The zone.         |

#### Returns

[`QiAddressInfo`](/sdk/content/interfaces/QiAddressInfo)\[]

The payment channel addresses for the zone.

#### Source

[wallet/qi-hdwallet.ts:1156](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L1156)

***

### getPaymentCode()

```ts theme={null}
getPaymentCode(account): string
```

Creates a new BIP47 payment code for the specified account. The payment code is derived from the account's BIP32
root key.

#### Parameters

| Parameter | Type     | Default value | Description                                        |
| :-------- | :------- | :------------ | :------------------------------------------------- |
| `account` | `number` | `0`           | The account index to derive the payment code from. |

#### Returns

`string`

A promise that resolves to the Base58-encoded BIP47 payment code.

#### Source

[wallet/qi-hdwallet.ts:1444](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L1444)

***

### getPrivateKey()

```ts theme={null}
getPrivateKey(address): string
```

Returns the private key for a given address. This method should be used with caution as it exposes the private
key to the user.

#### Parameters

| Parameter | Type     | Description                                          |
| :-------- | :------- | :--------------------------------------------------- |
| `address` | `string` | The address associated with the desired private key. |

#### Returns

`string`

The private key.

#### Overrides

`AbstractHDWallet.getPrivateKey`

#### Source

[wallet/qi-hdwallet.ts:987](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L987)

***

### getPrivateKeyForTxInput()

```ts theme={null}
private getPrivateKeyForTxInput(input): string
```

Retrieves the private key for a given transaction input.

This method derives the private key for a transaction input by locating the address info and then deriving the
private key based on where the address info was found:

* For BIP44 addresses (standard or change), it uses the HD wallet to derive the private key.
* For payment channel addresses (BIP47), it uses PaymentCodePrivate to derive the private key.

#### Parameters

| Parameter | Type      | Description                                      |
| :-------- | :-------- | :----------------------------------------------- |
| `input`   | `TxInput` | The transaction input containing the public key. |

#### Returns

`string`

The private key corresponding to the transaction input.

#### Throws

If the input does not contain a public key or if the address information cannot be found.

#### Source

[wallet/qi-hdwallet.ts:974](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L974)

***

### getUnusedBIP44Addresses()

```ts theme={null}
private getUnusedBIP44Addresses(
   amount, 
   account, 
   path, 
   zone): QiAddressInfo[]
```

Gets a set of unused BIP44 addresses from the specified derivation path. It first checks if there are any unused
addresses available in the \_addressesMap and uses those if possible. If there are not enough unused addresses, it
will generate new ones.

#### Parameters

| Parameter | Type                                     | Description                                |
| :-------- | :--------------------------------------- | :----------------------------------------- |
| `amount`  | `number`                                 | The number of addresses to get.            |
| `account` | `number`                                 | -                                          |
| `path`    | `string`                                 | The derivation path to get addresses from. |
| `zone`    | [`Zone`](/sdk/content/enumerations/Zone) | The zone to get addresses from.            |

#### Returns

[`QiAddressInfo`](/sdk/content/interfaces/QiAddressInfo)\[]

An array of addresses.

#### Source

[wallet/qi-hdwallet.ts:883](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L883)

***

### importOutpoints()

```ts theme={null}
importOutpoints(outpoints): void
```

Imports an array of outpoints into their corresponding wallets based on their derivation paths.

#### Parameters

| Parameter   | Type                                                      | Description              |
| :---------- | :-------------------------------------------------------- | :----------------------- |
| `outpoints` | [`OutpointInfo`](/sdk/content/interfaces/OutpointInfo)\[] | The outpoints to import. |

#### Returns

`void`

#### Source

[wallet/qi-hdwallet.ts:343](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L343)

***

### importPrivateKey()

```ts theme={null}
importPrivateKey(privateKey): Promise<QiAddressInfo>
```

Imports a private key and adds it to the wallet.

#### Parameters

| Parameter    | Type     | Description                            |
| :----------- | :------- | :------------------------------------- |
| `privateKey` | `string` | The private key to import (hex string) |

#### Returns

`Promise`\<[`QiAddressInfo`](/sdk/content/interfaces/QiAddressInfo)>

The address information for the imported key

#### Throws

If the private key is invalid or the address is already in use

#### Source

[wallet/qi-hdwallet.ts:1510](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L1510)

***

### openChannel()

```ts theme={null}
openChannel(paymentCode): void
```

Receives a payment code and stores it in the wallet for future use. If the payment code is already in the wallet,
it will be ignored.

#### Parameters

| Parameter     | Type     | Description                |
| :------------ | :------- | :------------------------- |
| `paymentCode` | `string` | The payment code to store. |

#### Returns

`void`

#### Source

[wallet/qi-hdwallet.ts:1487](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L1487)

***

### outpointsToUTXOs()

```ts theme={null}
private outpointsToUTXOs(zone): UTXO[]
```

Converts outpoints for a specific zone to UTXO format.

#### Parameters

| Parameter | Type                                     | Description                       |
| :-------- | :--------------------------------------- | :-------------------------------- |
| `zone`    | [`Zone`](/sdk/content/enumerations/Zone) | The zone to filter outpoints for. |

#### Returns

[`UTXO`](/sdk/content/classes/UTXO)\[]

An array of UTXO objects.

#### Source

[wallet/qi-hdwallet.ts:460](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L460)

***

### prepareAndSendTransaction()

```ts theme={null}
private prepareAndSendTransaction(
   amount, 
   originZone, 
   getDestinationAddresses, 
   coinSelectorCreator, 
options): Promise<TransactionResponse>
```

Prepares and sends a transaction with the specified parameters.

#### Parameters

| Parameter                 | Type                                                                                                     | Description                                                                              |
| :------------------------ | :------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------- |
| `amount`                  | `bigint`                                                                                                 | The amount of Qi to send.                                                                |
| `originZone`              | [`Zone`](/sdk/content/enumerations/Zone)                                                                 | The zone where the transaction originates.                                               |
| `getDestinationAddresses` | (`count`) => `Promise`\<`string`\[]>                                                                     | A function that returns a promise resolving to an array of<br />  destination addresses. |
| `coinSelectorCreator`     | (`utxos`) => [`FewestCoinSelector`](/sdk/content/classes/FewestCoinSelector) \| `ConversionCoinSelector` | -                                                                                        |
| `options`                 | `QiTransactionOptions`                                                                                   | -                                                                                        |

#### Returns

`Promise`\<[`TransactionResponse`](/sdk/content/type-aliases/TransactionResponse)>

A promise that resolves to the transaction response.

#### Throws

If provider is not set, insufficient balance, no available UTXOs, or insufficient spendable
balance.

#### Source

[wallet/qi-hdwallet.ts:611](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L611)

***

### prepareFeeEstimationTransaction()

```ts theme={null}
private prepareFeeEstimationTransaction(
   selection, 
   inputPubKeys, 
   sendAddresses, 
   changeAddresses): QiPerformActionTransaction
```

Prepares a fee estimation transaction with the specified parameters.

#### Parameters

| Parameter         | Type                  | Description                    |
| :---------------- | :-------------------- | :----------------------------- |
| `selection`       | `SelectedCoinsResult` | The selected coins result.     |
| `inputPubKeys`    | `string`\[]           | The public keys of the inputs. |
| `sendAddresses`   | `string`\[]           | The addresses to send to.      |
| `changeAddresses` | `string`\[]           | The addresses to change to.    |

#### Returns

`QiPerformActionTransaction`

The prepared transaction.

#### Source

[wallet/qi-hdwallet.ts:807](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L807)

***

### prepareTransaction()

```ts theme={null}
private prepareTransaction(
   selection, 
   sendAddresses, 
   changeAddresses, 
   chainId, 
options): Promise<QiTransaction>
```

Prepares a transaction with the specified parameters.

#### Parameters

| Parameter         | Type                   | Description                 |
| :---------------- | :--------------------- | :-------------------------- |
| `selection`       | `SelectedCoinsResult`  | The selected coins result.  |
| `sendAddresses`   | `string`\[]            | The addresses to send to.   |
| `changeAddresses` | `string`\[]            | The addresses to change to. |
| `chainId`         | `number`               | The chain ID.               |
| `options`         | `QiTransactionOptions` | -                           |

#### Returns

`Promise`\<[`QiTransaction`](/sdk/content/classes/QiTransaction)>

A promise that resolves to the prepared transaction.

#### Source

[wallet/qi-hdwallet.ts:741](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L741)

***

### scan()

```ts theme={null}
scan(zone, account?): Promise<void>
```

Scans the specified zone for addresses with unspent outputs. Starting at index 0, it will generate new addresses
until the gap limit is reached for external and change BIP44 addresses and payment channel addresses.

#### Parameters

| Parameter  | Type                                     | Default value | Description                                      |
| :--------- | :--------------------------------------- | :------------ | :----------------------------------------------- |
| `zone`     | [`Zone`](/sdk/content/enumerations/Zone) | `undefined`   | The zone in which to scan for addresses.         |
| `account`? | `number`                                 | `0`           | The index of the account to scan. Default is `0` |

#### Returns

`Promise`\<`void`>

A promise that resolves when the scan is complete.

#### Throws

If the zone is invalid.

#### Source

[wallet/qi-hdwallet.ts:1025](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L1025)

***

### sendTransaction()

```ts theme={null}
sendTransaction(
   recipientPaymentCode, 
   amount, 
   originZone, 
   destinationZone, 
options?): Promise<TransactionResponse>
```

Sends a transaction to a specified recipient payment code in a specified zone.

#### Parameters

| Parameter              | Type                                     | Description                                |
| :--------------------- | :--------------------------------------- | :----------------------------------------- |
| `recipientPaymentCode` | `string`                                 | The payment code of the recipient.         |
| `amount`               | `bigint`                                 | The amount of Qi to send.                  |
| `originZone`           | [`Zone`](/sdk/content/enumerations/Zone) | The zone where the transaction originates. |
| `destinationZone`      | [`Zone`](/sdk/content/enumerations/Zone) | The zone where the transaction is sent.    |
| `options`?             | `QiTransactionOptions`                   | Optional transaction configuration.        |

#### Returns

`Promise`\<[`TransactionResponse`](/sdk/content/type-aliases/TransactionResponse)>

A promise that resolves to the transaction response.

#### Throws

If the payment code is invalid, the amount is zero, or the zones are invalid.

#### Source

[wallet/qi-hdwallet.ts:523](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L523)

***

### serialize()

```ts theme={null}
serialize(): SerializedQiHDWallet
```

Serializes the HD wallet state into a format suitable for storage or transmission.

#### Returns

[`SerializedQiHDWallet`](/sdk/content/interfaces/SerializedQiHDWallet)

An object representing the serialized state of the HD wallet, including
outpoints, change addresses, gap addresses, and other inherited properties.

#### Overrides

`AbstractHDWallet.serialize`

#### Source

[wallet/qi-hdwallet.ts:1197](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L1197)

***

### setAddressUseChecker()

```ts theme={null}
setAddressUseChecker(checker): void
```

Sets the address use checker. The provided callback function should accept an address as input and return a
boolean indicating whether the address is in use. If the callback returns true, the address is considered used
and if it returns false, the address is considered unused.

#### Parameters

| Parameter | Type                   | Description              |
| :-------- | :--------------------- | :----------------------- |
| `checker` | `AddressUsageCallback` | The address use checker. |

#### Returns

`void`

#### Source

[wallet/qi-hdwallet.ts:290](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L290)

***

### signMessage()

```ts theme={null}
signMessage(address, message): Promise<string>
```

Signs a message using the private key associated with the given address.

#### Parameters

| Parameter | Type                     | Description                                                 |
| :-------- | :----------------------- | :---------------------------------------------------------- |
| `address` | `string`                 | The address for which the message is to be signed.          |
| `message` | `string` \| `Uint8Array` | The message to be signed, either as a string or Uint8Array. |

#### Returns

`Promise`\<`string`>

A promise that resolves to the signature of the message in hexadecimal string format.

#### Overrides

`AbstractHDWallet.signMessage`

#### Throws

If the address does not correspond to a valid HD node or if signing fails.

#### Source

[wallet/qi-hdwallet.ts:1179](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L1179)

***

### signTransaction()

```ts theme={null}
signTransaction(tx): Promise<string>
```

Signs a Qi transaction and returns the serialized transaction.

#### Parameters

| Parameter | Type                   | Description              |
| :-------- | :--------------------- | :----------------------- |
| `tx`      | `QiTransactionRequest` | The transaction to sign. |

#### Returns

`Promise`\<`string`>

The serialized transaction.

#### Overrides

`AbstractHDWallet.signTransaction`

#### Throws

If the UTXO transaction is invalid.

#### Source

[wallet/qi-hdwallet.ts:402](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L402)

***

### sync()

```ts theme={null}
sync(
   zone, 
   account?, 
   onOutpointsCreated?, 
onOutpointsDeleted?): Promise<void>
```

Scans the specified zone for addresses with unspent outputs. Starting at the last address index, it will generate
new addresses until the gap limit is reached for external and change BIP44 addresses and payment channel
addresses.

#### Parameters

| Parameter             | Type                                     | Default value | Description                                      |
| :-------------------- | :--------------------------------------- | :------------ | :----------------------------------------------- |
| `zone`                | [`Zone`](/sdk/content/enumerations/Zone) | `undefined`   | The zone in which to sync addresses.             |
| `account`?            | `number`                                 | `0`           | The index of the account to sync. Default is `0` |
| `onOutpointsCreated`? | `OutpointsCallback`                      | `undefined`   | -                                                |
| `onOutpointsDeleted`? | `OutpointsCallback`                      | `undefined`   | -                                                |

#### Returns

`Promise`\<`void`>

A promise that resolves when the sync is complete.

#### Throws

If the zone is invalid.

#### Source

[wallet/qi-hdwallet.ts:1044](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L1044)

***

### validateDerivationPath()

```ts theme={null}
private validateDerivationPath(path, isChange): void
```

Validates that the derivation path is either a BIP44 path or a valid payment code.

#### Parameters

| Parameter  | Type      | Description                      |
| :--------- | :-------- | :------------------------------- |
| `path`     | `string`  | The derivation path to validate  |
| `isChange` | `boolean` | Whether this is a change address |

#### Returns

`void`

#### Throws

If the path is invalid

#### Source

[wallet/qi-hdwallet.ts:1363](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L1363)

***

### xPub()

```ts theme={null}
xPub(): string
```

Returns the extended public key of the root node of the BIP44 HD wallet.

#### Returns

`string`

The extended public key.

#### Source

[wallet/qi-hdwallet.ts:249](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L249)

***

### createRandom()

```ts theme={null}
static createRandom<T>(
   this, 
   password?, 
   wordlist?): T
```

Creates a random HD wallet.

#### Type parameters

| Type parameter                                                                                               |
| :----------------------------------------------------------------------------------------------------------- |
| `T` *extends* `AbstractHDWallet`\<[`NeuteredAddressInfo`](/sdk/content/interfaces/NeuteredAddressInfo), `T`> |

#### Parameters

| Parameter   | Type                                        | Description                       |
| :---------- | :------------------------------------------ | :-------------------------------- |
| `this`      | `Object`                                    | The constructor of the HD wallet. |
| `password`? | `string`                                    | The password.                     |
| `wordlist`? | [`Wordlist`](/sdk/content/classes/Wordlist) | The wordlist.                     |

#### Returns

`T`

The created instance.

#### Inherited from

`AbstractHDWallet.createRandom`

#### Source

[wallet/abstract-hdwallet.ts:195](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/abstract-hdwallet.ts#L195)

***

### deserialize()

```ts theme={null}
static deserialize(serialized): Promise<QiHDWallet>
```

Deserializes a serialized QiHDWallet object and reconstructs the wallet instance.

#### Parameters

| Parameter    | Type                                                                   | Description                                                   |
| :----------- | :--------------------------------------------------------------------- | :------------------------------------------------------------ |
| `serialized` | [`SerializedQiHDWallet`](/sdk/content/interfaces/SerializedQiHDWallet) | The serialized object representing the state of a QiHDWallet. |

#### Returns

`Promise`\<[`QiHDWallet`](/sdk/content/classes/QiHDWallet)>

A promise that resolves to a reconstructed QiHDWallet instance.

#### Overrides

`AbstractHDWallet.deserialize`

#### Throws

If the serialized data is invalid or if any addresses in the gap addresses or gap change
addresses do not exist in the wallet.

#### Source

[wallet/qi-hdwallet.ts:1240](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/qi-hdwallet.ts#L1240)

***

### fromMnemonic()

```ts theme={null}
static fromMnemonic<T>(this, mnemonic): T
```

Creates an HD wallet from a mnemonic.

#### Type parameters

| Type parameter                                                                                               |
| :----------------------------------------------------------------------------------------------------------- |
| `T` *extends* `AbstractHDWallet`\<[`NeuteredAddressInfo`](/sdk/content/interfaces/NeuteredAddressInfo), `T`> |

#### Parameters

| Parameter  | Type                                        | Description                       |
| :--------- | :------------------------------------------ | :-------------------------------- |
| `this`     | `Object`                                    | The constructor of the HD wallet. |
| `mnemonic` | [`Mnemonic`](/sdk/content/classes/Mnemonic) | The mnemonic.                     |

#### Returns

`T`

The created instance.

#### Inherited from

`AbstractHDWallet.fromMnemonic`

#### Source

[wallet/abstract-hdwallet.ts:180](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/abstract-hdwallet.ts#L180)

***

### fromPhrase()

```ts theme={null}
static fromPhrase<T>(
   this, 
   phrase, 
   password?, 
   wordlist?): T
```

Creates an HD wallet from a phrase.

#### Type parameters

| Type parameter                                                                                               |
| :----------------------------------------------------------------------------------------------------------- |
| `T` *extends* `AbstractHDWallet`\<[`NeuteredAddressInfo`](/sdk/content/interfaces/NeuteredAddressInfo), `T`> |

#### Parameters

| Parameter   | Type                                        | Description                       |
| :---------- | :------------------------------------------ | :-------------------------------- |
| `this`      | `Object`                                    | The constructor of the HD wallet. |
| `phrase`    | `string`                                    | The phrase.                       |
| `password`? | `string`                                    | The password.                     |
| `wordlist`? | [`Wordlist`](/sdk/content/classes/Wordlist) | The wordlist.                     |

#### Returns

`T`

The created instance.

#### Inherited from

`AbstractHDWallet.fromPhrase`

#### Source

[wallet/abstract-hdwallet.ts:219](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/abstract-hdwallet.ts#L219)


# QuaiHDWallet
Source: https://docs.qu.ai/sdk/content/classes/QuaiHDWallet



The Quai HD wallet is a BIP44-compliant hierarchical deterministic wallet used for managing a set of addresses in the
Quai ledger. This is the easiest way to manage the interaction of managing accounts and addresses on the Quai
network, however, if your use case requires a single address Quai address, you can use the [Wallet](/sdk/content/classes/Wallet) class.

The Quai HD wallet supports:

* Adding accounts to the wallet heierchy
* Generating addresses for a specific account in any [Zone](/sdk/content/enumerations/Zone)
* Signing and sending transactions for any address in the wallet
* Signing and verifying EIP1193 typed data for any address in the wallet.
* Serializing the wallet to JSON and deserializing it back to a wallet instance.

## Example

```ts theme={null}
import { QuaiHDWallet, Zone } from 'quais';

const wallet = new QuaiHDWallet();
const cyrpus1Address = await wallet.getNextAddress(0, Zone.Cyrpus1); // get the first address in the Cyrpus1 zone
await wallet.sendTransaction({ from: address, to: '0x...', value: 100 }); // send a transaction
const serializedWallet = wallet.serialize(); // serialize current (account/address) state of the wallet
.
.
.
const deserializedWallet = QuaiHDWallet.deserialize(serializedWallet); // create a new wallet instance from the serialized data
```

## Extends

* `AbstractHDWallet`\<[`NeuteredAddressInfo`](/sdk/content/interfaces/NeuteredAddressInfo)>

## Constructors

### new QuaiHDWallet()

```ts theme={null}
new QuaiHDWallet(
   guard, 
   root, 
   provider?): QuaiHDWallet
```

Create a QuaiHDWallet instance.

#### Parameters

| Parameter   | Type                                           | Description              |
| :---------- | :--------------------------------------------- | :----------------------- |
| `guard`     | `any`                                          | -                        |
| `root`      | `HDNodeWallet`                                 | The root HD node wallet. |
| `provider`? | [`Provider`](/sdk/content/interfaces/Provider) | The provider.            |

#### Returns

[`QuaiHDWallet`](/sdk/content/classes/QuaiHDWallet)

#### Overrides

`AbstractHDWallet<NeuteredAddressInfo>.constructor`

#### Source

[wallet/quai-hdwallet.ts:69](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/quai-hdwallet.ts#L69)

## Methods

### addAddress()

```ts theme={null}
addAddress(account, addressIndex): NeuteredAddressInfo
```

Adds an address to the wallet.

#### Parameters

| Parameter      | Type     | Description         |
| :------------- | :------- | :------------------ |
| `account`      | `number` | The account number. |
| `addressIndex` | `number` | The address index.  |

#### Returns

[`NeuteredAddressInfo`](/sdk/content/interfaces/NeuteredAddressInfo)

The added address info.

#### Overrides

`AbstractHDWallet.addAddress`

#### Source

[wallet/quai-hdwallet.ts:228](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/quai-hdwallet.ts#L228)

***

### connect()

```ts theme={null}
connect(provider): void
```

Connects the wallet to a provider.

#### Parameters

| Parameter  | Type                                           | Description   |
| :--------- | :--------------------------------------------- | :------------ |
| `provider` | [`Provider`](/sdk/content/interfaces/Provider) | The provider. |

#### Returns

`void`

#### Inherited from

`AbstractHDWallet.connect`

#### Source

[wallet/abstract-hdwallet.ts:240](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/abstract-hdwallet.ts#L240)

***

### getAddressInfo()

```ts theme={null}
getAddressInfo(address): null | NeuteredAddressInfo
```

Gets the address info for a given address.

#### Parameters

| Parameter | Type     | Description  |
| :-------- | :------- | :----------- |
| `address` | `string` | The address. |

#### Returns

`null` | [`NeuteredAddressInfo`](/sdk/content/interfaces/NeuteredAddressInfo)

The address info or null if not found.

#### Overrides

`AbstractHDWallet.getAddressInfo`

#### Source

[wallet/quai-hdwallet.ts:350](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/quai-hdwallet.ts#L350)

***

### getAddressesForAccount()

```ts theme={null}
getAddressesForAccount(account): NeuteredAddressInfo[]
```

Gets the addresses for a given account.

#### Parameters

| Parameter | Type     | Description         |
| :-------- | :------- | :------------------ |
| `account` | `number` | The account number. |

#### Returns

[`NeuteredAddressInfo`](/sdk/content/interfaces/NeuteredAddressInfo)\[]

The addresses for the account.

#### Overrides

`AbstractHDWallet.getAddressesForAccount`

#### Source

[wallet/quai-hdwallet.ts:409](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/quai-hdwallet.ts#L409)

***

### getAddressesForZone()

```ts theme={null}
getAddressesForZone(zone): NeuteredAddressInfo[]
```

Gets the addresses for a given zone.

#### Parameters

| Parameter | Type                                     | Description |
| :-------- | :--------------------------------------- | :---------- |
| `zone`    | [`Zone`](/sdk/content/enumerations/Zone) | The zone.   |

#### Returns

[`NeuteredAddressInfo`](/sdk/content/interfaces/NeuteredAddressInfo)\[]

The addresses for the zone.

#### Overrides

`AbstractHDWallet.getAddressesForZone`

#### Source

[wallet/quai-hdwallet.ts:397](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/quai-hdwallet.ts#L397)

***

### getNextAddress()

```ts theme={null}
getNextAddress(account, zone): Promise<NeuteredAddressInfo>
```

Promise that resolves to the next address for the specified account and zone.

#### Parameters

| Parameter | Type                                     | Description                                                      |
| :-------- | :--------------------------------------- | :--------------------------------------------------------------- |
| `account` | `number`                                 | The index of the account for which to retrieve the next address. |
| `zone`    | [`Zone`](/sdk/content/enumerations/Zone) | The zone in which to retrieve the next address.                  |

#### Returns

`Promise`\<[`NeuteredAddressInfo`](/sdk/content/interfaces/NeuteredAddressInfo)>

The next neutered address information.

#### Overrides

`AbstractHDWallet.getNextAddress`

#### Source

[wallet/quai-hdwallet.ts:273](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/quai-hdwallet.ts#L273)

***

### getNextAddressSync()

```ts theme={null}
getNextAddressSync(account, zone): NeuteredAddressInfo
```

Synchronously retrieves the next address for the specified account and zone.

#### Parameters

| Parameter | Type                                     | Description                                                      |
| :-------- | :--------------------------------------- | :--------------------------------------------------------------- |
| `account` | `number`                                 | The index of the account for which to retrieve the next address. |
| `zone`    | [`Zone`](/sdk/content/enumerations/Zone) | The zone in which to retrieve the next address.                  |

#### Returns

[`NeuteredAddressInfo`](/sdk/content/interfaces/NeuteredAddressInfo)

The next neutered address information.

#### Overrides

`AbstractHDWallet.getNextAddressSync`

#### Source

[wallet/quai-hdwallet.ts:284](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/quai-hdwallet.ts#L284)

***

### getPrivateKey()

```ts theme={null}
getPrivateKey(address): string
```

Returns the private key for a given address. This method should be used with caution as it exposes the private
key to the user.

#### Parameters

| Parameter | Type     | Description                                          |
| :-------- | :------- | :--------------------------------------------------- |
| `address` | `string` | The address associated with the desired private key. |

#### Returns

`string`

The private key.

#### Overrides

`AbstractHDWallet.getPrivateKey`

#### Source

[wallet/quai-hdwallet.ts:365](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/quai-hdwallet.ts#L365)

***

### sendTransaction()

```ts theme={null}
sendTransaction(tx): Promise<TransactionResponse>
```

Send a transaction.

#### Parameters

| Parameter | Type                     | Description              |
| :-------- | :----------------------- | :----------------------- |
| `tx`      | `QuaiTransactionRequest` | The transaction request. |

#### Returns

`Promise`\<[`TransactionResponse`](/sdk/content/type-aliases/TransactionResponse)>

A promise that resolves to the transaction response.

#### Throws

If the provider is not set.

#### Source

[wallet/quai-hdwallet.ts:103](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/quai-hdwallet.ts#L103)

***

### serialize()

```ts theme={null}
serialize(): SerializedQuaiHDWallet
```

Serializes the QuaiHDWallet state into a format suitable for storage or transmission.

This method extends the serialization from the parent class (AbstractHDWallet) and includes additional
QuaiHDWallet-specific data, such as the addresses.

#### Returns

`SerializedQuaiHDWallet`

An object representing the serialized state of the QuaiHDWallet, including
addresses and other inherited properties from the parent wallet.

#### Overrides

`AbstractHDWallet.serialize`

#### Example

```ts theme={null}
Const wallet = new QuaiHDWallet(); const serializedData = wallet.serialize(); // serializedData can now
be stored or transmitted
```

#### Source

[wallet/quai-hdwallet.ts:137](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/quai-hdwallet.ts#L137)

***

### signMessage()

```ts theme={null}
signMessage(address, message): Promise<string>
```

Sign a message.

#### Parameters

| Parameter | Type                     | Description          |
| :-------- | :----------------------- | :------------------- |
| `address` | `string`                 | The address.         |
| `message` | `string` \| `Uint8Array` | The message to sign. |

#### Returns

`Promise`\<`string`>

A promise that resolves to the signed message.

#### Overrides

`AbstractHDWallet.signMessage`

#### Source

[wallet/quai-hdwallet.ts:120](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/quai-hdwallet.ts#L120)

***

### signTransaction()

```ts theme={null}
signTransaction(tx): Promise<string>
```

Sign a transaction.

#### Parameters

| Parameter | Type                     | Description              |
| :-------- | :----------------------- | :----------------------- |
| `tx`      | `QuaiTransactionRequest` | The transaction request. |

#### Returns

`Promise`\<`string`>

A promise that resolves to the signed transaction.

#### Overrides

`AbstractHDWallet.signTransaction`

#### Source

[wallet/quai-hdwallet.ts:89](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/quai-hdwallet.ts#L89)

***

### signTypedData()

```ts theme={null}
signTypedData(
   address, 
   domain, 
   types, 
value): Promise<string>
```

Signs typed data using the private key associated with the given address.

#### Parameters

| Parameter | Type                                                                               | Description                                                                           |
| :-------- | :--------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------ |
| `address` | `string`                                                                           | The address for which the typed data is to be signed.                                 |
| `domain`  | [`TypedDataDomain`](/sdk/content/interfaces/TypedDataDomain)                       | The domain information of the typed data, defining the scope of the signature.        |
| `types`   | `Record`\<`string`, [`TypedDataField`](/sdk/content/interfaces/TypedDataField)\[]> | The types of the data to be signed, mapping each data type name<br />  to its fields. |
| `value`   | `Record`\<`string`, `unknown`>                                                     | The actual data to be signed.                                                         |

#### Returns

`Promise`\<`string`>

A promise that resolves to the signed data in string format.

#### Throws

If the address does not correspond to a valid HD node or if signing fails.

#### Source

[wallet/quai-hdwallet.ts:211](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/quai-hdwallet.ts#L211)

***

### xPub()

```ts theme={null}
xPub(): string
```

Returns the extended public key of the root node of the BIP44 HD wallet.

#### Returns

`string`

The extended public key.

#### Source

[wallet/quai-hdwallet.ts:79](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/quai-hdwallet.ts#L79)

***

### createRandom()

```ts theme={null}
static createRandom<T>(
   this, 
   password?, 
   wordlist?): T
```

Creates a random HD wallet.

#### Type parameters

| Type parameter                                                                                               |
| :----------------------------------------------------------------------------------------------------------- |
| `T` *extends* `AbstractHDWallet`\<[`NeuteredAddressInfo`](/sdk/content/interfaces/NeuteredAddressInfo), `T`> |

#### Parameters

| Parameter   | Type                                        | Description                       |
| :---------- | :------------------------------------------ | :-------------------------------- |
| `this`      | `Object`                                    | The constructor of the HD wallet. |
| `password`? | `string`                                    | The password.                     |
| `wordlist`? | [`Wordlist`](/sdk/content/classes/Wordlist) | The wordlist.                     |

#### Returns

`T`

The created instance.

#### Inherited from

`AbstractHDWallet.createRandom`

#### Source

[wallet/abstract-hdwallet.ts:195](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/abstract-hdwallet.ts#L195)

***

### deserialize()

```ts theme={null}
static deserialize(serialized): Promise<QuaiHDWallet>
```

Deserializes the given serialized HD wallet data into an instance of QuaiHDWallet.

#### Parameters

| Parameter    | Type                     | Description                                    |
| :----------- | :----------------------- | :--------------------------------------------- |
| `serialized` | `SerializedQuaiHDWallet` | The serialized wallet data to be deserialized. |

#### Returns

`Promise`\<[`QuaiHDWallet`](/sdk/content/classes/QuaiHDWallet)>

A promise that resolves to an instance of QuaiHDWallet.

#### Overrides

`AbstractHDWallet.deserialize`

#### Async

#### Throws

If validation of the serialized wallet data fails or if deserialization fails.

#### Static

#### Source

[wallet/quai-hdwallet.ts:181](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/quai-hdwallet.ts#L181)

***

### fromMnemonic()

```ts theme={null}
static fromMnemonic<T>(this, mnemonic): T
```

Creates an HD wallet from a mnemonic.

#### Type parameters

| Type parameter                                                                                               |
| :----------------------------------------------------------------------------------------------------------- |
| `T` *extends* `AbstractHDWallet`\<[`NeuteredAddressInfo`](/sdk/content/interfaces/NeuteredAddressInfo), `T`> |

#### Parameters

| Parameter  | Type                                        | Description                       |
| :--------- | :------------------------------------------ | :-------------------------------- |
| `this`     | `Object`                                    | The constructor of the HD wallet. |
| `mnemonic` | [`Mnemonic`](/sdk/content/classes/Mnemonic) | The mnemonic.                     |

#### Returns

`T`

The created instance.

#### Inherited from

`AbstractHDWallet.fromMnemonic`

#### Source

[wallet/abstract-hdwallet.ts:180](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/abstract-hdwallet.ts#L180)

***

### fromPhrase()

```ts theme={null}
static fromPhrase<T>(
   this, 
   phrase, 
   password?, 
   wordlist?): T
```

Creates an HD wallet from a phrase.

#### Type parameters

| Type parameter                                                                                               |
| :----------------------------------------------------------------------------------------------------------- |
| `T` *extends* `AbstractHDWallet`\<[`NeuteredAddressInfo`](/sdk/content/interfaces/NeuteredAddressInfo), `T`> |

#### Parameters

| Parameter   | Type                                        | Description                       |
| :---------- | :------------------------------------------ | :-------------------------------- |
| `this`      | `Object`                                    | The constructor of the HD wallet. |
| `phrase`    | `string`                                    | The phrase.                       |
| `password`? | `string`                                    | The password.                     |
| `wordlist`? | [`Wordlist`](/sdk/content/classes/Wordlist) | The wordlist.                     |

#### Returns

`T`

The created instance.

#### Inherited from

`AbstractHDWallet.fromPhrase`

#### Source

[wallet/abstract-hdwallet.ts:219](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/abstract-hdwallet.ts#L219)


# Wallet
Source: https://docs.qu.ai/sdk/content/classes/Wallet



A **Wallet** manages a single private key which is used to sign transactions, messages and other common payloads.

This class is generally the main entry point for developers that wish to use a private key directly, as it can create
instances from a large variety of common sources, including raw private key,
[BIP-39](https://en.bitcoin.it/wiki/BIP_0039) mnemonics and encrypted JSON wallets.

## Extends

* `BaseWallet`

## Constructors

### new Wallet()

```ts theme={null}
new Wallet(key, provider?): Wallet
```

Create a new wallet for the private `key`, optionally connected to `provider`.

#### Parameters

| Parameter   | Type                                                        | Description                 |
| :---------- | :---------------------------------------------------------- | :-------------------------- |
| `key`       | `string` \| [`SigningKey`](/sdk/content/classes/SigningKey) | The private key.            |
| `provider`? | `null` \| [`Provider`](/sdk/content/interfaces/Provider)    | The provider to connect to. |

#### Returns

[`Wallet`](/sdk/content/classes/Wallet)

#### Overrides

`BaseWallet.constructor`

#### Source

[wallet/wallet.ts:34](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/wallet.ts#L34)

## Properties

| Property      | Modifier   | Type                                                     | Description                                | Inherited from           |
| :------------ | :--------- | :------------------------------------------------------- | :----------------------------------------- | :----------------------- |
| `#address`    | `private`  | `string`                                                 | The wallet address.                        | `BaseWallet.#address`    |
| `#signingKey` | `private`  | [`SigningKey`](/sdk/content/classes/SigningKey)          | The signing key used for signing payloads. | `BaseWallet.#signingKey` |
| `provider`    | `readonly` | `null` \| [`Provider`](/sdk/content/interfaces/Provider) | The provider this signer is connected to.  | `BaseWallet.provider`    |

## Accessors

### address

```ts theme={null}
get address(): string
```

The address of this wallet.

#### Returns

`string`

#### Source

[wallet/base-wallet.ts:71](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/base-wallet.ts#L71)

***

### privateKey

```ts theme={null}
get privateKey(): string
```

The private key for this wallet.

#### Returns

`string`

#### Source

[wallet/base-wallet.ts:91](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/base-wallet.ts#L91)

***

### signingKey

```ts theme={null}
get signingKey(): SigningKey
```

The [**SigningKey**](/sdk/content/classes/SigningKey) used for signing payloads.

#### Returns

[`SigningKey`](/sdk/content/classes/SigningKey)

#### Source

[wallet/base-wallet.ts:81](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/base-wallet.ts#L81)

## Methods

### connect()

```ts theme={null}
connect(provider): Wallet
```

Connects the wallet to a provider.

#### Parameters

| Parameter  | Type                                                     | Description                 |
| :--------- | :------------------------------------------------------- | :-------------------------- |
| `provider` | `null` \| [`Provider`](/sdk/content/interfaces/Provider) | The provider to connect to. |

#### Returns

[`Wallet`](/sdk/content/classes/Wallet)

The connected wallet.

#### Overrides

`BaseWallet.connect`

#### Source

[wallet/wallet.ts:49](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/wallet.ts#L49)

***

### encrypt()

```ts theme={null}
encrypt(password, progressCallback?): Promise<string>
```

Resolves to a [JSON Keystore Wallet](json-wallets) encrypted with `password`.

If `progressCallback` is specified, it will receive periodic updates as the encryption process progresses.

#### Parameters

| Parameter           | Type                                                             | Description                                     |
| :------------------ | :--------------------------------------------------------------- | :---------------------------------------------- |
| `password`          | `string` \| `Uint8Array`                                         | The password to encrypt the wallet with.        |
| `progressCallback`? | [`ProgressCallback`](/sdk/content/type-aliases/ProgressCallback) | An optional callback to keep the user informed. |

#### Returns

`Promise`\<`string`>

The encrypted JSON wallet.

#### Source

[wallet/wallet.ts:62](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/wallet.ts#L62)

***

### encryptSync()

```ts theme={null}
encryptSync(password): string
```

Returns a [JSON Keystore Wallet](json-wallets) encrypted with `password`.

It is preferred to use the [async version](encrypt) instead, which allows a
[**ProgressCallback**](/sdk/content/type-aliases/ProgressCallback) to keep the user informed.

This method will block the event loop (freezing all UI) until it is complete, which may be a non-trivial
duration.

#### Parameters

| Parameter  | Type                     | Description                              |
| :--------- | :----------------------- | :--------------------------------------- |
| `password` | `string` \| `Uint8Array` | The password to encrypt the wallet with. |

#### Returns

`string`

The encrypted JSON wallet.

#### Source

[wallet/wallet.ts:79](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/wallet.ts#L79)

***

### getAddress()

```ts theme={null}
getAddress(_zone?): Promise<string>
```

Returns the address of this wallet.

#### Parameters

| Parameter | Type     | Description          |
| :-------- | :------- | :------------------- |
| `_zone`?  | `string` | The zone (optional). |

#### Returns

`Promise`\<`string`>

The wallet address.

#### Inherited from

`BaseWallet.getAddress`

#### Source

[wallet/base-wallet.ts:103](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/base-wallet.ts#L103)

***

### signMessage()

```ts theme={null}
signMessage(message): Promise<string>
```

Signs a message.

#### Parameters

| Parameter | Type                     | Description          |
| :-------- | :----------------------- | :------------------- |
| `message` | `string` \| `Uint8Array` | The message to sign. |

#### Returns

`Promise`\<`string`>

The signed message.

#### Inherited from

`BaseWallet.signMessage`

#### Async

#### Source

[wallet/base-wallet.ts:161](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/base-wallet.ts#L161)

***

### signMessageSync()

```ts theme={null}
signMessageSync(message): string
```

Returns the signature for `message` signed with this wallet.

#### Parameters

| Parameter | Type                     | Description          |
| :-------- | :----------------------- | :------------------- |
| `message` | `string` \| `Uint8Array` | The message to sign. |

#### Returns

`string`

The serialized signature.

#### Inherited from

`BaseWallet.signMessageSync`

#### Source

[wallet/base-wallet.ts:173](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/base-wallet.ts#L173)

***

### signTransaction()

```ts theme={null}
signTransaction(tx): Promise<string>
```

Signs a transaction.

#### Parameters

| Parameter | Type                     | Description              |
| :-------- | :----------------------- | :----------------------- |
| `tx`      | `QuaiTransactionRequest` | The transaction request. |

#### Returns

`Promise`\<`string`>

The signed transaction.

#### Inherited from

`BaseWallet.signTransaction`

#### Source

[wallet/base-wallet.ts:123](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/base-wallet.ts#L123)

***

### signTypedData()

```ts theme={null}
signTypedData(
   domain, 
   types, 
value): Promise<string>
```

Signs typed data.

#### Parameters

| Parameter | Type                                                                               | Description                   |
| :-------- | :--------------------------------------------------------------------------------- | :---------------------------- |
| `domain`  | [`TypedDataDomain`](/sdk/content/interfaces/TypedDataDomain)                       | The domain of the typed data. |
| `types`   | `Record`\<`string`, [`TypedDataField`](/sdk/content/interfaces/TypedDataField)\[]> | The types of the typed data.  |
| `value`   | `Record`\<`string`, `any`>                                                         | The value of the typed data.  |

#### Returns

`Promise`\<`string`>

The signed typed data.

#### Inherited from

`BaseWallet.signTypedData`

#### Async

#### Source

[wallet/base-wallet.ts:186](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/base-wallet.ts#L186)

***

### fromEncryptedJson()

```ts theme={null}
static fromEncryptedJson(
   json, 
   password, 
progress?): Promise<Wallet>
```

Creates (asynchronously) a **Wallet** by decrypting the `json` with `password`.

If `progress` is provided, it is called periodically during decryption so that any UI can be updated.

#### Parameters

| Parameter   | Type                                                             | Description                                     |
| :---------- | :--------------------------------------------------------------- | :---------------------------------------------- |
| `json`      | `string`                                                         | The JSON data to decrypt.                       |
| `password`  | `string` \| `Uint8Array`                                         | The password to decrypt the JSON data.          |
| `progress`? | [`ProgressCallback`](/sdk/content/type-aliases/ProgressCallback) | An optional callback to keep the user informed. |

#### Returns

`Promise`\<[`Wallet`](/sdk/content/classes/Wallet)>

The decrypted wallet.

#### Source

[wallet/wallet.ts:111](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/wallet.ts#L111)

***

### fromEncryptedJsonSync()

```ts theme={null}
static fromEncryptedJsonSync(json, password): QuaiHDWallet | Wallet
```

Creates a **Wallet** by decrypting the `json` with `password`.

The [**fromEncryptedJson**](/sdk/content/classes/Wallet#fromencryptedjson) method is preferred, as this method will lock up and
freeze the UI during decryption, which may take some time.

#### Parameters

| Parameter  | Type                     | Description                            |
| :--------- | :----------------------- | :------------------------------------- |
| `json`     | `string`                 | The JSON data to decrypt.              |
| `password` | `string` \| `Uint8Array` | The password to decrypt the JSON data. |

#### Returns

[`QuaiHDWallet`](/sdk/content/classes/QuaiHDWallet) | [`Wallet`](/sdk/content/classes/Wallet)

The decrypted wallet.

#### Source

[wallet/wallet.ts:134](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/wallet.ts#L134)


# Wordlist
Source: https://docs.qu.ai/sdk/content/classes/Wordlist



A Wordlist represents a collection of language-specific words used to encode and devoce
[BIP-39](https://en.bitcoin.it/wiki/BIP_0039) encoded data by mapping words to 11-bit values and vice versa.

## Extended by

* [`WordlistOwl`](/sdk/content/classes/WordlistOwl)

## Constructors

### new Wordlist()

```ts theme={null}
new Wordlist(locale): Wordlist
```

Creates a new Wordlist instance.

Sub-classes MUST call this if they provide their own constructor, passing in the locale string of the language.

Generally there is no need to create instances of a Wordlist, since each language-specific Wordlist creates an
instance and there is no state kept internally, so they are safe to share.

#### Parameters

| Parameter | Type     |
| :-------- | :------- |
| `locale`  | `string` |

#### Returns

[`Wordlist`](/sdk/content/classes/Wordlist)

#### Source

[wordlists/wordlist.ts:20](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wordlists/wordlist.ts#L20)

## Methods

### getWord()

```ts theme={null}
abstract getWord(index): string
```

Maps an 11-bit value into its coresponding word in the list.

Sub-classes MUST override this.

#### Parameters

| Parameter | Type     |
| :-------- | :------- |
| `index`   | `number` |

#### Returns

`string`

#### Source

[wordlists/wordlist.ts:54](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wordlists/wordlist.ts#L54)

***

### getWordIndex()

```ts theme={null}
abstract getWordIndex(word): number
```

Maps a word to its corresponding 11-bit value.

Sub-classes MUST override this.

#### Parameters

| Parameter | Type     |
| :-------- | :------- |
| `word`    | `string` |

#### Returns

`number`

#### Source

[wordlists/wordlist.ts:61](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wordlists/wordlist.ts#L61)

***

### join()

```ts theme={null}
join(words): string
```

Sub-classes may override this to provider a language-specific method for joining `words` into a phrase.

By default, `words` are joined by a single space.

#### Parameters

| Parameter | Type        | Description        |
| :-------- | :---------- | :----------------- |
| `words`   | `string`\[] | The words to join. |

#### Returns

`string`

The joined phrase.

#### Source

[wordlists/wordlist.ts:45](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wordlists/wordlist.ts#L45)

***

### split()

```ts theme={null}
split(phrase): string[]
```

Sub-classes may override this to provide a language-specific method for spliting `phrase` into individual words.

By default, `phrase` is split using any sequences of white-space as defined by regular expressions (i.e.
`/\s+/`).

#### Parameters

| Parameter | Type     | Description          |
| :-------- | :------- | :------------------- |
| `phrase`  | `string` | The phrase to split. |

#### Returns

`string`\[]

The split words in the phrase.

#### Source

[wordlists/wordlist.ts:33](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wordlists/wordlist.ts#L33)


# WordlistOwl
Source: https://docs.qu.ai/sdk/content/classes/WordlistOwl



An OWL format Wordlist is an encoding method that exploits the general locality of alphabetically sorted words to
achieve a simple but effective means of compression.

This class is generally not useful to most developers as it is used mainly internally to keep Wordlists for languages
based on ASCII-7 small.

If necessary, there are tools within the `generation/` folder to create the necessary data.

## Extends

* [`Wordlist`](/sdk/content/classes/Wordlist)

## Extended by

* [`LangEn`](/sdk/content/classes/LangEn)
* [`WordlistOwlA`](/sdk/content/classes/WordlistOwlA)

## Constructors

### new WordlistOwl()

```ts theme={null}
new WordlistOwl(
   locale, 
   data, 
   checksum): WordlistOwl
```

Creates a new Wordlist for `locale` using the OWL `data` and validated against the `checksum`.

#### Parameters

| Parameter  | Type     |
| :--------- | :------- |
| `locale`   | `string` |
| `data`     | `string` |
| `checksum` | `string` |

#### Returns

[`WordlistOwl`](/sdk/content/classes/WordlistOwl)

#### Overrides

[`Wordlist`](/sdk/content/classes/Wordlist).[`constructor`](/sdk/content/classes/Wordlist#constructors)

#### Source

[wordlists/wordlist-owl.ts:28](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wordlists/wordlist-owl.ts#L28)

## Methods

### \_decodeWords()

```ts theme={null}
_decodeWords(): string[]
```

Decode all the words for the wordlist.

#### Returns

`string`\[]

#### Source

[wordlists/wordlist-owl.ts:47](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wordlists/wordlist-owl.ts#L47)

***

### join()

```ts theme={null}
join(words): string
```

Sub-classes may override this to provider a language-specific method for joining `words` into a phrase.

By default, `words` are joined by a single space.

#### Parameters

| Parameter | Type        | Description        |
| :-------- | :---------- | :----------------- |
| `words`   | `string`\[] | The words to join. |

#### Returns

`string`

The joined phrase.

#### Inherited from

[`Wordlist`](/sdk/content/classes/Wordlist).[`join`](/sdk/content/classes/Wordlist#join)

#### Source

[wordlists/wordlist.ts:45](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wordlists/wordlist.ts#L45)

***

### split()

```ts theme={null}
split(phrase): string[]
```

Sub-classes may override this to provide a language-specific method for spliting `phrase` into individual words.

By default, `phrase` is split using any sequences of white-space as defined by regular expressions (i.e.
`/\s+/`).

#### Parameters

| Parameter | Type     | Description          |
| :-------- | :------- | :------------------- |
| `phrase`  | `string` | The phrase to split. |

#### Returns

`string`\[]

The split words in the phrase.

#### Inherited from

[`Wordlist`](/sdk/content/classes/Wordlist).[`split`](/sdk/content/classes/Wordlist#split)

#### Source

[wordlists/wordlist.ts:33](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wordlists/wordlist.ts#L33)


# WordlistOwlA
Source: https://docs.qu.ai/sdk/content/classes/WordlistOwlA



An OWL-A format Wordlist extends the OWL format to add an overlay onto an OWL format Wordlist to support diacritic
marks.

This class is generally not useful to most developers as it is used mainly internally to keep Wordlists for languages
based on latin-1 small.

If necessary, there are tools within the `generation/` folder to create the necessary data.

## Extends

* [`WordlistOwl`](/sdk/content/classes/WordlistOwl)

## Extended by

* [`LangEs`](/sdk/content/classes/LangEs)

## Constructors

### new WordlistOwlA()

```ts theme={null}
new WordlistOwlA(
   locale, 
   data, 
   accent, 
   checksum): WordlistOwlA
```

Creates a new Wordlist for `locale` using the OWLA `data` and `accent` data and validated against the `checksum`.

#### Parameters

| Parameter  | Type     |
| :--------- | :------- |
| `locale`   | `string` |
| `data`     | `string` |
| `accent`   | `string` |
| `checksum` | `string` |

#### Returns

[`WordlistOwlA`](/sdk/content/classes/WordlistOwlA)

#### Overrides

[`WordlistOwl`](/sdk/content/classes/WordlistOwl).[`constructor`](/sdk/content/classes/WordlistOwl#constructors)

#### Source

[wordlists/wordlist-owla.ts:21](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wordlists/wordlist-owla.ts#L21)

## Methods

### join()

```ts theme={null}
join(words): string
```

Sub-classes may override this to provider a language-specific method for joining `words` into a phrase.

By default, `words` are joined by a single space.

#### Parameters

| Parameter | Type        | Description        |
| :-------- | :---------- | :----------------- |
| `words`   | `string`\[] | The words to join. |

#### Returns

`string`

The joined phrase.

#### Inherited from

[`WordlistOwl`](/sdk/content/classes/WordlistOwl).[`join`](/sdk/content/classes/WordlistOwl#join)

#### Source

[wordlists/wordlist.ts:45](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wordlists/wordlist.ts#L45)

***

### split()

```ts theme={null}
split(phrase): string[]
```

Sub-classes may override this to provide a language-specific method for spliting `phrase` into individual words.

By default, `phrase` is split using any sequences of white-space as defined by regular expressions (i.e.
`/\s+/`).

#### Parameters

| Parameter | Type     | Description          |
| :-------- | :------- | :------------------- |
| `phrase`  | `string` | The phrase to split. |

#### Returns

`string`\[]

The split words in the phrase.

#### Inherited from

[`WordlistOwl`](/sdk/content/classes/WordlistOwl).[`split`](/sdk/content/classes/WordlistOwl#split)

#### Source

[wordlists/wordlist.ts:33](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wordlists/wordlist.ts#L33)


# concat
Source: https://docs.qu.ai/sdk/content/functions/concat



```ts theme={null}
function concat(datas): string
```

Returns a DataHexString | **DataHexString** by concatenating all values within `data`.

## Parameters

| Parameter | Type                                                           | Description              |
| :-------- | :------------------------------------------------------------- | :----------------------- |
| `datas`   | readonly [`BytesLike`](/sdk/content/type-aliases/BytesLike)\[] | The data to concatenate. |

## Returns

`string`

The concatenated data.

## Source

[utils/data.ts:152](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/data.ts#L152)


# dataLength
Source: https://docs.qu.ai/sdk/content/functions/dataLength



```ts theme={null}
function dataLength(data): number
```

Returns the length of `data`, in bytes.

## Parameters

| Parameter | Type                                               | Description                    |
| :-------- | :------------------------------------------------- | :----------------------------- |
| `data`    | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The data to get the length of. |

## Returns

`number`

The length of the data.

## Source

[utils/data.ts:163](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/data.ts#L163)


# dataSlice
Source: https://docs.qu.ai/sdk/content/functions/dataSlice



```ts theme={null}
function dataSlice(
   data, 
   start?, 
   end?): string
```

Returns a DataHexString | **DataHexString** by slicing `data` from the `start` offset to the `end` offset.

By default `start` is 0 and `end` is the length of `data`.

## Parameters

| Parameter | Type                                               | Description        |
| :-------- | :------------------------------------------------- | :----------------- |
| `data`    | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The data to slice. |
| `start`?  | `number`                                           | The start offset.  |
| `end`?    | `number`                                           | The end offset.    |

## Returns

`string`

The sliced data.

## Throws

If the end offset is beyond the data bounds.

## Source

[utils/data.ts:182](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/data.ts#L182)


# decryptKeystoreJson
Source: https://docs.qu.ai/sdk/content/functions/decryptKeystoreJson



```ts theme={null}
function decryptKeystoreJson(
   json, 
   _password, 
progress?): Promise<KeystoreAccount>
```

Resolves to the decrypted JSON Keystore Wallet `json` using the `password`.

If provided, `progress` will be called periodically during the decrpytion to provide feedback, and if the function
returns `false` will halt decryption.

The `progressCallback` will **always** receive `0` before decryption begins and `1` when complete.

## Parameters

| Parameter   | Type                                                             | Description                               |
| :---------- | :--------------------------------------------------------------- | :---------------------------------------- |
| `json`      | `string`                                                         | The JSON data to decrypt.                 |
| `_password` | `string` \| `Uint8Array`                                         | The password to decrypt the JSON data.    |
| `progress`? | [`ProgressCallback`](/sdk/content/type-aliases/ProgressCallback) | The callback to receive progress updates. |

## Returns

`Promise`\<[`KeystoreAccount`](/sdk/content/type-aliases/KeystoreAccount)>

The decrypted account.

## Source

[wallet/json-keystore.ts:272](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/json-keystore.ts#L272)


# decryptKeystoreJsonSync
Source: https://docs.qu.ai/sdk/content/functions/decryptKeystoreJsonSync



```ts theme={null}
function decryptKeystoreJsonSync(json, _password): KeystoreAccount
```

Returns the account details for the JSON Keystore Wallet `json` using `password`.

It is preferred to use the [**async version**](/sdk/content/functions/decryptKeystoreJson) instead, which allows a
[\*\*ProgressCallback](/sdk/content/type-aliases/ProgressCallback) to keep the user informed as to the decryption status.

This method will block the event loop (freezing all UI) until decryption is complete, which can take quite some time,
depending on the wallet paramters and platform.

## Parameters

| Parameter   | Type                     | Description                            |
| :---------- | :----------------------- | :------------------------------------- |
| `json`      | `string`                 | The JSON data to decrypt.              |
| `_password` | `string` \| `Uint8Array` | The password to decrypt the JSON data. |

## Returns

[`KeystoreAccount`](/sdk/content/type-aliases/KeystoreAccount)

The decrypted account.

## Source

[wallet/json-keystore.ts:225](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/json-keystore.ts#L225)


# encryptKeystoreJson
Source: https://docs.qu.ai/sdk/content/functions/encryptKeystoreJson



```ts theme={null}
function encryptKeystoreJson(
   account, 
   password, 
options?): Promise<string>
```

Resolved to the JSON Keystore Wallet for `account` encrypted with `password`.

The `options` can be used to tune the password-based key derivation function parameters, explicitly set the random
values used and provide a [**ProgressCallback**](/sdk/content/type-aliases/ProgressCallback) to receive periodic updates on the
completion status..

## Parameters

| Parameter  | Type                                                           | Description                                       |
| :--------- | :------------------------------------------------------------- | :------------------------------------------------ |
| `account`  | [`KeystoreAccount`](/sdk/content/type-aliases/KeystoreAccount) | The account to encrypt.                           |
| `password` | `string` \| `Uint8Array`                                       | The password to encrypt the JSON data.            |
| `options`? | [`EncryptOptions`](/sdk/content/type-aliases/EncryptOptions)   | The options to use when encrypting the JSON data. |

## Returns

`Promise`\<`string`>

The encrypted JSON data.

## Source

[wallet/json-keystore.ts:491](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/json-keystore.ts#L491)


# encryptKeystoreJsonSync
Source: https://docs.qu.ai/sdk/content/functions/encryptKeystoreJsonSync



```ts theme={null}
function encryptKeystoreJsonSync(
   account, 
   password, 
   options?): string
```

Return the JSON Keystore Wallet for `account` encrypted with `password`.

The `options` can be used to tune the password-based key derivation function parameters, explicitly set the random
values used. Any provided [**ProgressCallback**](/sdk/content/type-aliases/ProgressCallback) is ignored.

## Parameters

| Parameter  | Type                                                           | Description                                       |
| :--------- | :------------------------------------------------------------- | :------------------------------------------------ |
| `account`  | [`KeystoreAccount`](/sdk/content/type-aliases/KeystoreAccount) | The account to encrypt.                           |
| `password` | `string` \| `Uint8Array`                                       | The password to encrypt the JSON data.            |
| `options`? | [`EncryptOptions`](/sdk/content/type-aliases/EncryptOptions)   | The options to use when encrypting the JSON data. |

## Returns

`string`

The encrypted JSON data.

## Source

[wallet/json-keystore.ts:463](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/json-keystore.ts#L463)


# formatQi
Source: https://docs.qu.ai/sdk/content/functions/formatQi



```ts theme={null}
function formatQi(value): string
```

Converts `value` into a decimal string using 3 decimal places.

## Parameters

| Parameter | Type                                                     | Description           |
| :-------- | :------------------------------------------------------- | :-------------------- |
| `value`   | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert. |

## Returns

`string`

The converted value.

## Source

[utils/units.ts:90](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/units.ts#L90)


# formatQuai
Source: https://docs.qu.ai/sdk/content/functions/formatQuai



```ts theme={null}
function formatQuai(wei): string
```

Converts `value` into a decimal string sing 18 decimal places.

## Parameters

| Parameter | Type                                                     | Description           |
| :-------- | :------------------------------------------------------- | :-------------------- |
| `wei`     | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert. |

## Returns

`string`

The converted value.

## Source

[utils/units.ts:79](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/units.ts#L79)


# formatUnits
Source: https://docs.qu.ai/sdk/content/functions/formatUnits



```ts theme={null}
function formatUnits(value, unit?): string
```

Converts `value` into a decimal string, assuming `unit` decimal places. The `unit` may be the number of decimal
places or the name of a unit (e.g. `"gwei"` for 9 decimal places).

## Parameters

| Parameter | Type                                                       | Description                             |
| :-------- | :--------------------------------------------------------- | :-------------------------------------- |
| `value`   | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish)   | The value to convert.                   |
| `unit`?   | `string` \| [`Numeric`](/sdk/content/type-aliases/Numeric) | The unit to convert to. Default is `18` |

## Returns

`string`

The converted value.

## Throws

If the unit is invalid.

## Source

[utils/units.ts:33](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/units.ts#L33)


# fromTwos
Source: https://docs.qu.ai/sdk/content/functions/fromTwos



```ts theme={null}
function fromTwos(_value, _width): bigint
```

Convert `value` from a twos-compliment representation of `width` bits to its value.

If the highest bit is `1`, the result will be negative.

## Parameters

| Parameter | Type                                                     | Description                     |
| :-------- | :------------------------------------------------------- | :------------------------------ |
| `_value`  | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert.           |
| `_width`  | [`Numeric`](/sdk/content/type-aliases/Numeric)           | The width of the value in bits. |

## Returns

`bigint`

The value.

## Throws

If the value is too large for the width.

## Source

[utils/maths.ts:42](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/maths.ts#L42)


# getAddressDetails
Source: https://docs.qu.ai/sdk/content/functions/getAddressDetails



```ts theme={null}
function getAddressDetails(address): AddressDetails | null
```

Extracts both zone and UTXO information from a given blockchain address. This function first determines the address's
zone by its byte prefix, then checks the 9th bit of the address to ascertain if it's a UTXO or non-UTXO address.

## Parameters

| Parameter | Type     | Description                                                                                                           |
| :-------- | :------- | :-------------------------------------------------------------------------------------------------------------------- |
| `address` | `string` | The blockchain address to be analyzed, expected to start with "0x" followed by its<br />  hexadecimal representation. |

## Returns

`AddressDetails` | `null`

An object containing the zone and UTXO information, or null if no address is found.

## Source

[utils/shards.ts:37](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/shards.ts#L37)


# getBigInt
Source: https://docs.qu.ai/sdk/content/functions/getBigInt



```ts theme={null}
function getBigInt(value, name?): bigint
```

Gets a BigInt from `value`. If it is an invalid value for a BigInt, then an ArgumentError will be thrown for `name`.

## Parameters

| Parameter | Type                                                     | Description            |
| :-------- | :------------------------------------------------------- | :--------------------- |
| `value`   | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert.  |
| `name`?   | `string`                                                 | The name of the value. |

## Returns

`bigint`

The value.

## Source

[utils/maths.ts:120](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/maths.ts#L120)


# getBytes
Source: https://docs.qu.ai/sdk/content/functions/getBytes



```ts theme={null}
function getBytes(value, name?): Uint8Array
```

Get a typed Uint8Array for `value`. If already a Uint8Array the original `value` is returned; if a copy is required
use [**getBytesCopy**](/sdk/content/functions/getBytesCopy).

## Parameters

| Parameter | Type                                               | Description                              |
| :-------- | :------------------------------------------------- | :--------------------------------------- |
| `value`   | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a Uint8Array.    |
| `name`?   | `string`                                           | The name of the value for error context. |

## Returns

`Uint8Array`

The typed Uint8Array.

## Source

[utils/data.ts:70](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/data.ts#L70)


# getBytesCopy
Source: https://docs.qu.ai/sdk/content/functions/getBytesCopy



```ts theme={null}
function getBytesCopy(value, name?): Uint8Array
```

Get a typed Uint8Array for `value`, creating a copy if necessary to prevent any modifications of the returned value
from being reflected elsewhere.

## Parameters

| Parameter | Type                                               | Description                              |
| :-------- | :------------------------------------------------- | :--------------------------------------- |
| `value`   | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The value to convert to a Uint8Array.    |
| `name`?   | `string`                                           | The name of the value for error context. |

## Returns

`Uint8Array`

The typed Uint8Array.

## Source

[utils/data.ts:83](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/data.ts#L83)


# getNumber
Source: https://docs.qu.ai/sdk/content/functions/getNumber



```ts theme={null}
function getNumber(value, name?): number
```

Gets a number from `value`. If it is an invalid value for a number, then an ArgumentError will be thrown for `name`.

## Parameters

| Parameter | Type                                                     | Description            |
| :-------- | :------------------------------------------------------- | :--------------------- |
| `value`   | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert.  |
| `name`?   | `string`                                                 | The name of the value. |

## Returns

`number`

The value.

## Throws

If the value is invalid.

## Throws

If the value is too large.

## Source

[utils/maths.ts:212](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/maths.ts#L212)


# getTxType
Source: https://docs.qu.ai/sdk/content/functions/getTxType



```ts theme={null}
function getTxType(from, to): number
```

Determines the transaction type based on the sender and recipient addresses. The function checks if both addresses
are UTXO addresses, in which case it returns 2. If only the sender address is a UTXO address, it returns 1.
Otherwise, it returns 0.

## Parameters

| Parameter | Type               | Description                                             |
| :-------- | :----------------- | :------------------------------------------------------ |
| `from`    | `null` \| `string` | The sender address. If null, the function returns 0.    |
| `to`      | `null` \| `string` | The recipient address. If null, the function returns 0. |

## Returns

`number`

The transaction type based on the addresses.

## Source

[utils/shards.ts:53](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/shards.ts#L53)


# getUint
Source: https://docs.qu.ai/sdk/content/functions/getUint



```ts theme={null}
function getUint(value, name?): bigint
```

Returns `value` as a bigint, validating it is valid as a bigint value and that it is positive.

## Parameters

| Parameter | Type                                                     | Description            |
| :-------- | :------------------------------------------------------- | :--------------------- |
| `value`   | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert.  |
| `name`?   | `string`                                                 | The name of the value. |

## Returns

`bigint`

The value.

## Throws

If the value is negative.

## Source

[utils/maths.ts:170](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/maths.ts#L170)


# getZoneForAddress
Source: https://docs.qu.ai/sdk/content/functions/getZoneForAddress



```ts theme={null}
function getZoneForAddress(address): Zone | null
```

Retrieves the shard information for a given address based on its byte prefix. The function parses the address to
extract its byte prefix, then filters the ShardData to find a matching shard entry. If no matching shard is found, it
returns null.

## Parameters

| Parameter | Type     | Description                                                                                                                  |
| :-------- | :------- | :--------------------------------------------------------------------------------------------------------------------------- |
| `address` | `string` | The blockchain address to be analyzed. The address should start with "0x" followed by the<br />  hexadecimal representation. |

## Returns

[`Zone`](/sdk/content/enumerations/Zone) | `null`

An object containing the shard information, or null if no

## Source

[utils/shards.ts:15](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/shards.ts#L15)


# hexlify
Source: https://docs.qu.ai/sdk/content/functions/hexlify



```ts theme={null}
function hexlify(data): string
```

Returns a DataHexString | **DataHexString** representation of `data`.

## Parameters

| Parameter | Type                                               | Description                          |
| :-------- | :------------------------------------------------- | :----------------------------------- |
| `data`    | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The data to convert to a hex string. |

## Returns

`string`

The hex string.

## Source

[utils/data.ts:134](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/data.ts#L134)


# isBytesLike
Source: https://docs.qu.ai/sdk/content/functions/isBytesLike



```ts theme={null}
function isBytesLike(value): value is BytesLike
```

Returns true if `value` is a valid representation of arbitrary data (i.e. a valid
DataHexString | **DataHexString** or a Uint8Array).

## Parameters

| Parameter | Type  | Description         |
| :-------- | :---- | :------------------ |
| `value`   | `any` | The value to check. |

## Returns

`value is BytesLike`

True if the value is a valid DataHexString | **DataHexString**.

## Source

[utils/data.ts:121](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/data.ts#L121)


# isCallException
Source: https://docs.qu.ai/sdk/content/functions/isCallException



```ts theme={null}
function isCallException(error): error is CallExceptionError
```

Returns true if `error` is a [**CallExceptionError**](/sdk/content/interfaces/CallExceptionError).

## Parameters

| Parameter | Type  |
| :-------- | :---- |
| `error`   | `any` |

## Returns

`error is CallExceptionError`

## Source

[utils/errors.ts:673](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/errors.ts#L673)


# isError
Source: https://docs.qu.ai/sdk/content/functions/isError



```ts theme={null}
function isError<K, T>(error, code): error is T
```

Returns true if the `error` matches an error thrown by quais that matches the error `code`.

In TypeScript environments, this can be used to check that `error` matches an quaisError type, which means the
expected properties will be set.

## Type parameters

| Type parameter                                                                          |
| :-------------------------------------------------------------------------------------- |
| `K` *extends* [`ErrorCode`](/sdk/content/type-aliases/ErrorCode)                        |
| `T` *extends*                                                                           |
| \| [`UnknownError`](/sdk/content/interfaces/UnknownError)                               |
| \| [`InvalidArgumentError`](/sdk/content/interfaces/InvalidArgumentError)               |
| \| [`BadDataError`](/sdk/content/interfaces/BadDataError)                               |
| \| [`NotImplementedError`](/sdk/content/interfaces/NotImplementedError)                 |
| \| [`UnsupportedOperationError`](/sdk/content/interfaces/UnsupportedOperationError)     |
| \| [`NetworkError`](/sdk/content/interfaces/NetworkError)                               |
| \| [`ServerError`](/sdk/content/interfaces/ServerError)                                 |
| \| [`TimeoutError`](/sdk/content/interfaces/TimeoutError)                               |
| \| [`CancelledError`](/sdk/content/interfaces/CancelledError)                           |
| \| [`BufferOverrunError`](/sdk/content/interfaces/BufferOverrunError)                   |
| \| [`NumericFaultError`](/sdk/content/interfaces/NumericFaultError)                     |
| \| [`MissingArgumentError`](/sdk/content/interfaces/MissingArgumentError)               |
| \| [`UnexpectedArgumentError`](/sdk/content/interfaces/UnexpectedArgumentError)         |
| \| [`CallExceptionError`](/sdk/content/interfaces/CallExceptionError)                   |
| \| [`InsufficientFundsError`](/sdk/content/interfaces/InsufficientFundsError)           |
| \| [`NonceExpiredError`](/sdk/content/interfaces/NonceExpiredError)                     |
| \| [`ReplacementUnderpricedError`](/sdk/content/interfaces/ReplacementUnderpricedError) |
| \| [`TransactionReplacedError`](/sdk/content/interfaces/TransactionReplacedError)       |
| \| `TransactionNotFoundError`                                                           |
| \| `TransactionAlreadyKnown`                                                            |
| \| [`ActionRejectedError`](/sdk/content/interfaces/ActionRejectedError)                 |
| \| `ProviderFailedToInitializeError`                                                    |

## Parameters

| Parameter | Type  |
| :-------- | :---- |
| `error`   | `any` |
| `code`    | `K`   |

## Returns

`error is T`

## Example

```ts theme={null}
try {
    // code....
} catch (e) {
    if (isError(e, 'CALL_EXCEPTION')) {
        // The Type Guard has validated this object
        console.log(e.data);
    }
}
```

## See

[ErrorCodes](api:ErrorCode)

## Source

[utils/errors.ts:664](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/errors.ts#L664)


# isHexString
Source: https://docs.qu.ai/sdk/content/functions/isHexString



```ts theme={null}
function isHexString(value, length?): value is `0x${string}`
```

Returns true if `value` is a valid HexString | **HexString**.

If `length` is `true` or a number, it also checks that `value` is a valid DataHexString | **DataHexString** of
`length` (if a number) bytes of data (e.g. `0x1234` is 2 bytes).

## Parameters

| Parameter | Type                  | Description                      |
| :-------- | :-------------------- | :------------------------------- |
| `value`   | `any`                 | The value to check.              |
| `length`? | `number` \| `boolean` | The expected length of the data. |

## Returns

value is \`0x\$\{string}\`

True if the value is a valid HexString | **HexString**.

## Source

[utils/data.ts:98](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/data.ts#L98)


# isKeystoreJson
Source: https://docs.qu.ai/sdk/content/functions/isKeystoreJson



```ts theme={null}
function isKeystoreJson(json): boolean
```

Returns true if `json` is a valid JSON Keystore Wallet.

## Parameters

| Parameter | Type     | Description             |
| :-------- | :------- | :---------------------- |
| `json`    | `string` | The JSON data to check. |

## Returns

`boolean`

True if the JSON data is a valid Keystore Wallet.

## Source

[wallet/json-keystore.ts:64](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/json-keystore.ts#L64)


# makeError
Source: https://docs.qu.ai/sdk/content/functions/makeError



```ts theme={null}
function makeError<K, T>(
   message, 
   code, 
   info?): T
```

Returns a new Error configured to the format quais emits errors, with the `message`, [**ErrorCode**](/sdk/content/type-aliases/ErrorCode)
`code` and additional properties for the corresponding quaisError.

Each error in quais includes the version of quais, a machine-readable [**ErrorCode**](/sdk/content/type-aliases/ErrorCode), and depending
on `code`, additional required properties. The error message will also include the `message`, quais version, `code`
and all additional properties, serialized.

## Type parameters

| Type parameter                                                                          |
| :-------------------------------------------------------------------------------------- |
| `K` *extends* [`ErrorCode`](/sdk/content/type-aliases/ErrorCode)                        |
| `T` *extends*                                                                           |
| \| [`UnknownError`](/sdk/content/interfaces/UnknownError)                               |
| \| [`InvalidArgumentError`](/sdk/content/interfaces/InvalidArgumentError)               |
| \| [`BadDataError`](/sdk/content/interfaces/BadDataError)                               |
| \| [`NotImplementedError`](/sdk/content/interfaces/NotImplementedError)                 |
| \| [`UnsupportedOperationError`](/sdk/content/interfaces/UnsupportedOperationError)     |
| \| [`NetworkError`](/sdk/content/interfaces/NetworkError)                               |
| \| [`ServerError`](/sdk/content/interfaces/ServerError)                                 |
| \| [`TimeoutError`](/sdk/content/interfaces/TimeoutError)                               |
| \| [`CancelledError`](/sdk/content/interfaces/CancelledError)                           |
| \| [`BufferOverrunError`](/sdk/content/interfaces/BufferOverrunError)                   |
| \| [`NumericFaultError`](/sdk/content/interfaces/NumericFaultError)                     |
| \| [`MissingArgumentError`](/sdk/content/interfaces/MissingArgumentError)               |
| \| [`UnexpectedArgumentError`](/sdk/content/interfaces/UnexpectedArgumentError)         |
| \| [`CallExceptionError`](/sdk/content/interfaces/CallExceptionError)                   |
| \| [`InsufficientFundsError`](/sdk/content/interfaces/InsufficientFundsError)           |
| \| [`NonceExpiredError`](/sdk/content/interfaces/NonceExpiredError)                     |
| \| [`ReplacementUnderpricedError`](/sdk/content/interfaces/ReplacementUnderpricedError) |
| \| [`TransactionReplacedError`](/sdk/content/interfaces/TransactionReplacedError)       |
| \| `TransactionNotFoundError`                                                           |
| \| `TransactionAlreadyKnown`                                                            |
| \| [`ActionRejectedError`](/sdk/content/interfaces/ActionRejectedError)                 |
| \| `ProviderFailedToInitializeError`                                                    |

## Parameters

| Parameter | Type              | Description                          |
| :-------- | :---------------- | :----------------------------------- |
| `message` | `string`          | The error message.                   |
| `code`    | `K`               | The error code.                      |
| `info`?   | `ErrorInfo`\<`T`> | Additional properties for the error. |

## Returns

`T`

The new error.

## Source

[utils/errors.ts:691](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/errors.ts#L691)


# mask
Source: https://docs.qu.ai/sdk/content/functions/mask



```ts theme={null}
function mask(_value, _bits): bigint
```

Mask `value` with a bitmask of `bits` ones.

## Parameters

| Parameter | Type                                                     | Description                 |
| :-------- | :------------------------------------------------------- | :-------------------------- |
| `_value`  | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to mask.          |
| `_bits`   | [`Numeric`](/sdk/content/type-aliases/Numeric)           | The number of bits to mask. |

## Returns

`bigint`

The masked value.

## Source

[utils/maths.ts:106](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/maths.ts#L106)


# parseQi
Source: https://docs.qu.ai/sdk/content/functions/parseQi



```ts theme={null}
function parseQi(value): bigint
```

Converts `value` into a decimal string using 3 decimal places.

## Parameters

| Parameter | Type     | Description           |
| :-------- | :------- | :-------------------- |
| `value`   | `string` | The value to convert. |

## Returns

`bigint`

The converted value.

## Source

[utils/units.ts:112](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/units.ts#L112)


# parseQuai
Source: https://docs.qu.ai/sdk/content/functions/parseQuai



```ts theme={null}
function parseQuai(ether): bigint
```

Converts the decimal string `quai` to a BigInt, using 18 decimal places.

## Parameters

| Parameter | Type     | Description           |
| :-------- | :------- | :-------------------- |
| `ether`   | `string` | The value to convert. |

## Returns

`bigint`

The converted value.

## Source

[utils/units.ts:101](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/units.ts#L101)


# parseUnits
Source: https://docs.qu.ai/sdk/content/functions/parseUnits



```ts theme={null}
function parseUnits(value, unit?): bigint
```

Converts the decimal string `value` to a BigInt, assuming `unit` decimal places. The `unit` may the number of decimal
places or the name of a unit (e.g. `"gwei"` for 9 decimal places).

## Parameters

| Parameter | Type                                                       | Description                               |
| :-------- | :--------------------------------------------------------- | :---------------------------------------- |
| `value`   | `string`                                                   | The value to convert.                     |
| `unit`?   | `string` \| [`Numeric`](/sdk/content/type-aliases/Numeric) | The unit to convert from. Default is `18` |

## Returns

`bigint`

The converted value.

## Throws

If the unit is invalid.

## Throws

If the value is not a string.

## Source

[utils/units.ts:57](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/units.ts#L57)


# stripZerosLeft
Source: https://docs.qu.ai/sdk/content/functions/stripZerosLeft



```ts theme={null}
function stripZerosLeft(data): string
```

Return the DataHexString | **DataHexString** result by stripping all **leading** zero bytes from `data`.

## Parameters

| Parameter | Type                                               | Description        |
| :-------- | :------------------------------------------------- | :----------------- |
| `data`    | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The data to strip. |

## Returns

`string`

The stripped data.

## Source

[utils/data.ts:201](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/data.ts#L201)


# toBeArray
Source: https://docs.qu.ai/sdk/content/functions/toBeArray



```ts theme={null}
function toBeArray(_value): Uint8Array
```

Converts `value` to a Big Endian Uint8Array.

## Parameters

| Parameter | Type                                                     | Description           |
| :-------- | :------------------------------------------------------- | :-------------------- |
| `_value`  | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert. |

## Returns

`Uint8Array`

The value.

## Source

[utils/maths.ts:290](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/maths.ts#L290)


# toBeHex
Source: https://docs.qu.ai/sdk/content/functions/toBeHex



```ts theme={null}
function toBeHex(_value, _width?): string
```

Converts `value` to a Big Endian hexstring, optionally padded to `width` bytes.

## Parameters

| Parameter | Type                                                     | Description                      |
| :-------- | :------------------------------------------------------- | :------------------------------- |
| `_value`  | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert.            |
| `_width`? | [`Numeric`](/sdk/content/type-aliases/Numeric)           | The width of the value in bytes. |

## Returns

`string`

The hexstring.

## Throws

If the value exceeds the width.

## Source

[utils/maths.ts:256](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/maths.ts#L256)


# toBigInt
Source: https://docs.qu.ai/sdk/content/functions/toBigInt



```ts theme={null}
function toBigInt(value): bigint
```

Converts `value` to a BigInt. If `value` is a Uint8Array, it is treated as Big Endian data.

## Parameters

| Parameter | Type                                                                     | Description           |
| :-------- | :----------------------------------------------------------------------- | :-------------------- |
| `value`   | `Uint8Array` \| [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert. |

## Returns

`bigint`

The value.

## Source

[utils/maths.ts:189](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/maths.ts#L189)


# toNumber
Source: https://docs.qu.ai/sdk/content/functions/toNumber



```ts theme={null}
function toNumber(value): number
```

Converts `value` to a number. If `value` is a Uint8Array, it is treated as Big Endian data. Throws if the value is
not safe.

## Parameters

| Parameter | Type                                                                     | Description           |
| :-------- | :----------------------------------------------------------------------- | :-------------------- |
| `value`   | `Uint8Array` \| [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert. |

## Returns

`number`

The value.

## Throws

If the value is not safe to convert to a number.

## Source

[utils/maths.ts:243](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/maths.ts#L243)


# toQuantity
Source: https://docs.qu.ai/sdk/content/functions/toQuantity



```ts theme={null}
function toQuantity(value): string
```

Returns a `HexString` for `value` safe to use as a Quantity.

A Quantity does not have and leading 0 values unless the value is the literal value `0x0`. This is most commonly used
for JSSON-RPC numeric values.

## Parameters

| Parameter | Type                                             | Description           |
| :-------- | :----------------------------------------------- | :-------------------- |
| `value`   | `string` \| `number` \| `bigint` \| `Uint8Array` | The value to convert. |

## Returns

`string`

The quantity.

## Source

[utils/maths.ts:321](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/maths.ts#L321)


# toTwos
Source: https://docs.qu.ai/sdk/content/functions/toTwos



```ts theme={null}
function toTwos(_value, _width): bigint
```

Convert `value` to a twos-compliment representation of `width` bits.

The result will always be positive.

## Parameters

| Parameter | Type                                                     | Description                     |
| :-------- | :------------------------------------------------------- | :------------------------------ |
| `_value`  | [`BigNumberish`](/sdk/content/type-aliases/BigNumberish) | The value to convert.           |
| `_width`  | [`Numeric`](/sdk/content/type-aliases/Numeric)           | The width of the value in bits. |

## Returns

`bigint`

The value.

## Throws

If the value is too large for the width.

## Source

[utils/maths.ts:72](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/maths.ts#L72)


# uuidV4
Source: https://docs.qu.ai/sdk/content/functions/uuidV4



```ts theme={null}
function uuidV4(randomBytes): string
```

Returns the version 4 [UUID](https://www.ietf.org/rfc/rfc4122.txt) for the `randomBytes`.

## Parameters

| Parameter     | Type                                               | Description              |
| :------------ | :------------------------------------------------- | :----------------------- |
| `randomBytes` | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The random bytes to use. |

## Returns

`string`

The UUID.

## Source

[utils/uuid.ts:15](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/uuid.ts#L15)


# zeroPadBytes
Source: https://docs.qu.ai/sdk/content/functions/zeroPadBytes



```ts theme={null}
function zeroPadBytes(data, length): string
```

Return the DataHexString | **DataHexString** of `data` padded on the **right** to `length` bytes.

If `data` already exceeds %%length%%, a [BufferOverrunError](../interfaces/BufferOverrunError) is thrown.

This pads data the same as **bytes** are in Solidity (e.g. `bytes16`).

## Parameters

| Parameter | Type                                               | Description           |
| :-------- | :------------------------------------------------- | :-------------------- |
| `data`    | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The data to pad.      |
| `length`  | `number`                                           | The length to pad to. |

## Returns

`string`

The padded data.

## Source

[utils/data.ts:267](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/data.ts#L267)


# zeroPadValue
Source: https://docs.qu.ai/sdk/content/functions/zeroPadValue



```ts theme={null}
function zeroPadValue(data, length): string
```

Return the DataHexString | **DataHexString** of `data` padded on the **left** to `length` bytes.

If `data` already exceeds `length`, a [BufferOverrunError](../interfaces/BufferOverrunError) is thrown.

This pads data the same as **values** are in Solidity (e.g. `uint128`).

## Parameters

| Parameter | Type                                               | Description           |
| :-------- | :------------------------------------------------- | :-------------------- |
| `data`    | [`BytesLike`](/sdk/content/type-aliases/BytesLike) | The data to pad.      |
| `length`  | `number`                                           | The length to pad to. |

## Returns

`string`

The padded data.

## Source

[utils/data.ts:251](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/data.ts#L251)


# NotImplementedError
Source: https://docs.qu.ai/sdk/content/interfaces/NotImplementedError



This Error is mostly used as a stub for functionality that is intended for the future, but is currently not
implemented.

## Extends

* [`quaisError`](/sdk/content/interfaces/quaisError)\<`"NOT_IMPLEMENTED"`>

## Properties

| Property       | Type                                               | Description                                                                                                                    | Inherited from                                                    |
| :------------- | :------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------- |
| `code`         | [`ErrorCode`](/sdk/content/type-aliases/ErrorCode) | The string error code.                                                                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`code`         |
| `error?`       | `Error`                                            | Any related error.                                                                                                             | [`quaisError`](/sdk/content/interfaces/quaisError).`error`        |
| `info?`        | `Record`\<`string`, `any`>                         | Additional info regarding the error that may be useful.<br /><br />This is generally helpful mostly for human-based debugging. | [`quaisError`](/sdk/content/interfaces/quaisError).`info`         |
| `operation`    | `string`                                           | The attempted operation.                                                                                                       | -                                                                 |
| `shortMessage` | `string`                                           | A short message describing the error, with minimal additional details.                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`shortMessage` |


# NumericFaultError
Source: https://docs.qu.ai/sdk/content/interfaces/NumericFaultError



This Error indicates an operation which would result in incorrect arithmetic output has occurred.

For example, trying to divide by zero or using a `uint8` to store a negative value.

## Extends

* [`quaisError`](/sdk/content/interfaces/quaisError)\<`"NUMERIC_FAULT"`>

## Properties

| Property       | Type                                               | Description                                                                                                                    | Inherited from                                                    |
| :------------- | :------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------- |
| `code`         | [`ErrorCode`](/sdk/content/type-aliases/ErrorCode) | The string error code.                                                                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`code`         |
| `error?`       | `Error`                                            | Any related error.                                                                                                             | [`quaisError`](/sdk/content/interfaces/quaisError).`error`        |
| `fault`        | `string`                                           | The fault reported.                                                                                                            | -                                                                 |
| `info?`        | `Record`\<`string`, `any`>                         | Additional info regarding the error that may be useful.<br /><br />This is generally helpful mostly for human-based debugging. | [`quaisError`](/sdk/content/interfaces/quaisError).`info`         |
| `operation`    | `string`                                           | The attempted operation.                                                                                                       | -                                                                 |
| `shortMessage` | `string`                                           | A short message describing the error, with minimal additional details.                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`shortMessage` |
| `value`        | `any`                                              | The value the operation was attempted against.                                                                                 | -                                                                 |


# ReplacementUnderpricedError
Source: https://docs.qu.ai/sdk/content/interfaces/ReplacementUnderpricedError



An attempt was made to replace a transaction, but with an insufficient additional fee to afford evicting the old
transaction from the memory pool.

## Extends

* [`quaisError`](/sdk/content/interfaces/quaisError)\<`"REPLACEMENT_UNDERPRICED"`>

## Properties

| Property       | Type                                                                 | Description                                                                                                                    | Inherited from                                                    |
| :------------- | :------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------- |
| `code`         | [`ErrorCode`](/sdk/content/type-aliases/ErrorCode)                   | The string error code.                                                                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`code`         |
| `error?`       | `Error`                                                              | Any related error.                                                                                                             | [`quaisError`](/sdk/content/interfaces/quaisError).`error`        |
| `info?`        | `Record`\<`string`, `any`>                                           | Additional info regarding the error that may be useful.<br /><br />This is generally helpful mostly for human-based debugging. | [`quaisError`](/sdk/content/interfaces/quaisError).`info`         |
| `shortMessage` | `string`                                                             | A short message describing the error, with minimal additional details.                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`shortMessage` |
| `transaction`  | [`TransactionRequest`](/sdk/content/type-aliases/TransactionRequest) | The transaction.                                                                                                               | -                                                                 |


# ServerError
Source: https://docs.qu.ai/sdk/content/interfaces/ServerError



This Error indicates there was a problem fetching a resource from a server.

## Extends

* [`quaisError`](/sdk/content/interfaces/quaisError)\<`"SERVER_ERROR"`>

## Properties

| Property       | Type                                                            | Description                                                                                                                    | Inherited from                                                    |
| :------------- | :-------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------- |
| `code`         | [`ErrorCode`](/sdk/content/type-aliases/ErrorCode)              | The string error code.                                                                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`code`         |
| `error?`       | `Error`                                                         | Any related error.                                                                                                             | [`quaisError`](/sdk/content/interfaces/quaisError).`error`        |
| `info?`        | `Record`\<`string`, `any`>                                      | Additional info regarding the error that may be useful.<br /><br />This is generally helpful mostly for human-based debugging. | [`quaisError`](/sdk/content/interfaces/quaisError).`info`         |
| `request`      | `string` \| [`FetchRequest`](/sdk/content/classes/FetchRequest) | The requested resource.                                                                                                        | -                                                                 |
| `response?`    | [`FetchResponse`](/sdk/content/classes/FetchResponse)           | The response received from the server, if available.                                                                           | -                                                                 |
| `shortMessage` | `string`                                                        | A short message describing the error, with minimal additional details.                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`shortMessage` |


# TimeoutError
Source: https://docs.qu.ai/sdk/content/interfaces/TimeoutError



This Error indicates that the timeout duration has expired and that the operation has been implicitly cancelled.

The side-effect of the operation may still occur, as this generally means a request has been sent and there has
simply been no response to indicate whether it was processed or not.

## Extends

* [`quaisError`](/sdk/content/interfaces/quaisError)\<`"TIMEOUT"`>

## Properties

| Property       | Type                                                | Description                                                                                                                    | Inherited from                                                    |
| :------------- | :-------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------- |
| `code`         | [`ErrorCode`](/sdk/content/type-aliases/ErrorCode)  | The string error code.                                                                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`code`         |
| `error?`       | `Error`                                             | Any related error.                                                                                                             | [`quaisError`](/sdk/content/interfaces/quaisError).`error`        |
| `info?`        | `Record`\<`string`, `any`>                          | Additional info regarding the error that may be useful.<br /><br />This is generally helpful mostly for human-based debugging. | [`quaisError`](/sdk/content/interfaces/quaisError).`info`         |
| `operation`    | `string`                                            | The attempted operation.                                                                                                       | -                                                                 |
| `reason`       | `string`                                            | The reason.                                                                                                                    | -                                                                 |
| `request?`     | [`FetchRequest`](/sdk/content/classes/FetchRequest) | The resource request, if available.                                                                                            | -                                                                 |
| `shortMessage` | `string`                                            | A short message describing the error, with minimal additional details.                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`shortMessage` |


# TransactionReplacedError
Source: https://docs.qu.ai/sdk/content/interfaces/TransactionReplacedError



A pending transaction was replaced by another.

## Extends

* [`quaisError`](/sdk/content/interfaces/quaisError)\<`"TRANSACTION_REPLACED"`>

## Properties

| Property       | Type                                                                                                    | Description                                                                                                                    | Inherited from                                                    |
| :------------- | :------------------------------------------------------------------------------------------------------ | :----------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------- |
| `cancelled`    | `boolean`                                                                                               | If the transaction was cancelled, such that the original effects of the transaction cannot be assured.                         | -                                                                 |
| `code`         | [`ErrorCode`](/sdk/content/type-aliases/ErrorCode)                                                      | The string error code.                                                                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`code`         |
| `error?`       | `Error`                                                                                                 | Any related error.                                                                                                             | [`quaisError`](/sdk/content/interfaces/quaisError).`error`        |
| `hash`         | `string`                                                                                                | The hash of the replaced transaction.                                                                                          | -                                                                 |
| `info?`        | `Record`\<`string`, `any`>                                                                              | Additional info regarding the error that may be useful.<br /><br />This is generally helpful mostly for human-based debugging. | [`quaisError`](/sdk/content/interfaces/quaisError).`info`         |
| `reason`       | `"cancelled"` \| `"replaced"` \| `"repriced"`                                                           | The reason the transaction was replaced.                                                                                       | -                                                                 |
| `receipt`      | [`TransactionReceipt`](/sdk/content/classes/TransactionReceipt)                                         | The receipt of the transaction that replace the transaction.                                                                   | -                                                                 |
| `replacement`  | [`TransactionResponse`](/sdk/content/type-aliases/TransactionResponse) \| `ExternalTransactionResponse` | The transaction that replaced the transaction.                                                                                 | -                                                                 |
| `shortMessage` | `string`                                                                                                | A short message describing the error, with minimal additional details.                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`shortMessage` |


# UnexpectedArgumentError
Source: https://docs.qu.ai/sdk/content/interfaces/UnexpectedArgumentError



This Error indicates too many arguments were provided.

## Extends

* [`quaisError`](/sdk/content/interfaces/quaisError)\<`"UNEXPECTED_ARGUMENT"`>

## Properties

| Property        | Type                                               | Description                                                                                                                    | Inherited from                                                    |
| :-------------- | :------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------- |
| `code`          | [`ErrorCode`](/sdk/content/type-aliases/ErrorCode) | The string error code.                                                                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`code`         |
| `count`         | `number`                                           | The number of arguments received.                                                                                              | -                                                                 |
| `error?`        | `Error`                                            | Any related error.                                                                                                             | [`quaisError`](/sdk/content/interfaces/quaisError).`error`        |
| `expectedCount` | `number`                                           | The number of arguments expected.                                                                                              | -                                                                 |
| `info?`         | `Record`\<`string`, `any`>                         | Additional info regarding the error that may be useful.<br /><br />This is generally helpful mostly for human-based debugging. | [`quaisError`](/sdk/content/interfaces/quaisError).`info`         |
| `shortMessage`  | `string`                                           | A short message describing the error, with minimal additional details.                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`shortMessage` |


# UnknownError
Source: https://docs.qu.ai/sdk/content/interfaces/UnknownError



This Error is a catch-all for when there is no way for quais to know what the underlying problem is.

## Extends

* [`quaisError`](/sdk/content/interfaces/quaisError)\<`"UNKNOWN_ERROR"`>

## Properties

| Property       | Type                                               | Description                                                                                                                    | Inherited from                                                    |
| :------------- | :------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------- |
| `code`         | [`ErrorCode`](/sdk/content/type-aliases/ErrorCode) | The string error code.                                                                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`code`         |
| `error?`       | `Error`                                            | Any related error.                                                                                                             | [`quaisError`](/sdk/content/interfaces/quaisError).`error`        |
| `info?`        | `Record`\<`string`, `any`>                         | Additional info regarding the error that may be useful.<br /><br />This is generally helpful mostly for human-based debugging. | [`quaisError`](/sdk/content/interfaces/quaisError).`info`         |
| `shortMessage` | `string`                                           | A short message describing the error, with minimal additional details.                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`shortMessage` |


# UnsupportedOperationError
Source: https://docs.qu.ai/sdk/content/interfaces/UnsupportedOperationError



This Error indicates that the attempted operation is not supported.

This could range from a specific JSON-RPC end-point not supporting a feature to a specific configuration of an object
prohibiting the operation.

For example, a [Wallet](../classes/Wallet) with no connected [Provider](../interfaces/Provider) is unable to send a
transaction.

## Extends

* [`quaisError`](/sdk/content/interfaces/quaisError)\<`"UNSUPPORTED_OPERATION"`>

## Properties

| Property       | Type                                               | Description                                                                                                                    | Inherited from                                                    |
| :------------- | :------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------- |
| `code`         | [`ErrorCode`](/sdk/content/type-aliases/ErrorCode) | The string error code.                                                                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`code`         |
| `error?`       | `Error`                                            | Any related error.                                                                                                             | [`quaisError`](/sdk/content/interfaces/quaisError).`error`        |
| `info?`        | `Record`\<`string`, `any`>                         | Additional info regarding the error that may be useful.<br /><br />This is generally helpful mostly for human-based debugging. | [`quaisError`](/sdk/content/interfaces/quaisError).`info`         |
| `operation`    | `string`                                           | The attempted operation.                                                                                                       | -                                                                 |
| `shortMessage` | `string`                                           | A short message describing the error, with minimal additional details.                                                         | [`quaisError`](/sdk/content/interfaces/quaisError).`shortMessage` |


# quaisError
Source: https://docs.qu.ai/sdk/content/interfaces/quaisError



All errors in quais include properties to assist in machine-readable errors.

## Extends

* `Error`

## Extended by

* [`UnknownError`](/sdk/content/interfaces/UnknownError)
* [`NotImplementedError`](/sdk/content/interfaces/NotImplementedError)
* [`UnsupportedOperationError`](/sdk/content/interfaces/UnsupportedOperationError)
* [`NetworkError`](/sdk/content/interfaces/NetworkError)
* [`ServerError`](/sdk/content/interfaces/ServerError)
* [`TimeoutError`](/sdk/content/interfaces/TimeoutError)
* [`BadDataError`](/sdk/content/interfaces/BadDataError)
* [`CancelledError`](/sdk/content/interfaces/CancelledError)
* [`BufferOverrunError`](/sdk/content/interfaces/BufferOverrunError)
* [`NumericFaultError`](/sdk/content/interfaces/NumericFaultError)
* [`InvalidArgumentError`](/sdk/content/interfaces/InvalidArgumentError)
* [`MissingArgumentError`](/sdk/content/interfaces/MissingArgumentError)
* [`UnexpectedArgumentError`](/sdk/content/interfaces/UnexpectedArgumentError)
* [`CallExceptionError`](/sdk/content/interfaces/CallExceptionError)
* [`InsufficientFundsError`](/sdk/content/interfaces/InsufficientFundsError)
* [`NonceExpiredError`](/sdk/content/interfaces/NonceExpiredError)
* [`ReplacementUnderpricedError`](/sdk/content/interfaces/ReplacementUnderpricedError)
* [`TransactionReplacedError`](/sdk/content/interfaces/TransactionReplacedError)
* [`ActionRejectedError`](/sdk/content/interfaces/ActionRejectedError)

## Type parameters

| Type parameter                                                   | Value                                              |
| :--------------------------------------------------------------- | :------------------------------------------------- |
| `T` *extends* [`ErrorCode`](/sdk/content/type-aliases/ErrorCode) | [`ErrorCode`](/sdk/content/type-aliases/ErrorCode) |

## Properties

| Property       | Type                                               | Description                                                                                                                    |
| :------------- | :------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------- |
| `code`         | [`ErrorCode`](/sdk/content/type-aliases/ErrorCode) | The string error code.                                                                                                         |
| `error?`       | `Error`                                            | Any related error.                                                                                                             |
| `info?`        | `Record`\<`string`, `any`>                         | Additional info regarding the error that may be useful.<br /><br />This is generally helpful mostly for human-based debugging. |
| `shortMessage` | `string`                                           | A short message describing the error, with minimal additional details.                                                         |


# BigNumberish
Source: https://docs.qu.ai/sdk/content/type-aliases/BigNumberish



```ts theme={null}
type BigNumberish: string | Numeric;
```

Any type that can be used where a big number is needed.

## Source

[utils/maths.ts:21](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/maths.ts#L21)


# BytesLike
Source: https://docs.qu.ai/sdk/content/type-aliases/BytesLike



```ts theme={null}
type BytesLike: DataHexString | Uint8Array;
```

An object that can be used to represent binary data.

## Source

[utils/data.ts:27](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/data.ts#L27)


# CallExceptionAction
Source: https://docs.qu.ai/sdk/content/type-aliases/CallExceptionAction



```ts theme={null}
type CallExceptionAction: 
  | "call"
  | "estimateGas"
  | "getTransactionResult"
  | "sendTransaction"
  | "unknown";
```

The action that resulted in the call exception.

## Source

[utils/errors.ts:418](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/errors.ts#L418)


# CallExceptionTransaction
Source: https://docs.qu.ai/sdk/content/type-aliases/CallExceptionTransaction



```ts theme={null}
type CallExceptionTransaction: {
  "data": string;
  "from": string;
  "to": null | string;
};
```

The related transaction that caused the error.

## Type declaration

### data

```ts theme={null}
data: string;
```

### from?

```ts theme={null}
optional from: string;
```

### to

```ts theme={null}
to: null | string;
```

## Source

[utils/errors.ts:425](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/errors.ts#L425)


# CodedquaisError
Source: https://docs.qu.ai/sdk/content/type-aliases/CodedquaisError



```ts theme={null}
type CodedquaisError<T>: T extends "UNKNOWN_ERROR" ? UnknownError : T extends "NOT_IMPLEMENTED" ? NotImplementedError : T extends "UNSUPPORTED_OPERATION" ? UnsupportedOperationError : T extends "NETWORK_ERROR" ? NetworkError : T extends "SERVER_ERROR" ? ServerError : T extends "TIMEOUT" ? TimeoutError : T extends "BAD_DATA" ? BadDataError : T extends "CANCELLED" ? CancelledError : T extends "BUFFER_OVERRUN" ? BufferOverrunError : T extends "NUMERIC_FAULT" ? NumericFaultError : ... extends ... ? ... : ...;
```

A conditional type that transforms the [**ErrorCode**](/sdk/content/type-aliases/ErrorCode) T into its quaisError type.

## Type parameters

| Type parameter |
| :------------- |
| `T`            |

## Source

[utils/errors.ts:596](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/errors.ts#L596)


# EncryptOptions
Source: https://docs.qu.ai/sdk/content/type-aliases/EncryptOptions



```ts theme={null}
type EncryptOptions: {
  "client": string;
  "entropy": BytesLike;
  "iv": BytesLike;
  "progressCallback": ProgressCallback;
  "salt": BytesLike;
  "scrypt": {
     "N": number;
     "p": number;
     "r": number;
    };
  "uuid": string;
};
```

The parameters to use when encrypting a JSON Keystore Wallet.

## Type declaration

### client?

```ts theme={null}
optional client: string;
```

### entropy?

```ts theme={null}
optional entropy: BytesLike;
```

### iv?

```ts theme={null}
optional iv: BytesLike;
```

### progressCallback?

```ts theme={null}
optional progressCallback: ProgressCallback;
```

### salt?

```ts theme={null}
optional salt: BytesLike;
```

### scrypt?

```ts theme={null}
optional scrypt: {
  "N": number;
  "p": number;
  "r": number;
};
```

### scrypt.N?

```ts theme={null}
optional N: number;
```

### scrypt.p?

```ts theme={null}
optional p: number;
```

### scrypt.r?

```ts theme={null}
optional r: number;
```

### uuid?

```ts theme={null}
optional uuid: string;
```

## Source

[wallet/json-keystore.ts:43](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/json-keystore.ts#L43)


# FetchGatewayFunc
Source: https://docs.qu.ai/sdk/content/type-aliases/FetchGatewayFunc



```ts theme={null}
type FetchGatewayFunc: (url, signal?) => Promise<FetchRequest | FetchResponse>;
```

Called on Gateway URLs.

## Parameters

| Parameter | Type                |
| :-------- | :------------------ |
| `url`     | `string`            |
| `signal`? | `FetchCancelSignal` |

## Returns

`Promise`\<[`FetchRequest`](/sdk/content/classes/FetchRequest) | [`FetchResponse`](/sdk/content/classes/FetchResponse)>

## Source

[utils/fetch.ts:73](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L73)


# FetchGetUrlFunc
Source: https://docs.qu.ai/sdk/content/type-aliases/FetchGetUrlFunc



```ts theme={null}
type FetchGetUrlFunc: (req, signal?) => Promise<GetUrlResponse>;
```

Used to perform a fetch; use this to override the underlying network fetch layer. In NodeJS, the default uses the
"http" and "https" libraries and in the browser `fetch` is used. If you wish to use Axios, this is how you would
register it.

## Parameters

| Parameter | Type                                                |
| :-------- | :-------------------------------------------------- |
| `req`     | [`FetchRequest`](/sdk/content/classes/FetchRequest) |
| `signal`? | `FetchCancelSignal`                                 |

## Returns

`Promise`\<[`GetUrlResponse`](/sdk/content/type-aliases/GetUrlResponse)>

## Source

[utils/fetch.ts:82](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L82)


# FetchPreflightFunc
Source: https://docs.qu.ai/sdk/content/type-aliases/FetchPreflightFunc



```ts theme={null}
type FetchPreflightFunc: (req) => Promise<FetchRequest>;
```

Called before any network request, allowing updated headers (e.g. Bearer tokens), etc.

## Parameters

| Parameter | Type                                                |
| :-------- | :-------------------------------------------------- |
| `req`     | [`FetchRequest`](/sdk/content/classes/FetchRequest) |

## Returns

`Promise`\<[`FetchRequest`](/sdk/content/classes/FetchRequest)>

## Source

[utils/fetch.ts:52](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L52)


# FetchProcessFunc
Source: https://docs.qu.ai/sdk/content/type-aliases/FetchProcessFunc



```ts theme={null}
type FetchProcessFunc: (req, resp) => Promise<FetchResponse>;
```

Called on the response, allowing client-based throttling logic or post-processing.

## Parameters

| Parameter | Type                                                  |
| :-------- | :---------------------------------------------------- |
| `req`     | [`FetchRequest`](/sdk/content/classes/FetchRequest)   |
| `resp`    | [`FetchResponse`](/sdk/content/classes/FetchResponse) |

## Returns

`Promise`\<[`FetchResponse`](/sdk/content/classes/FetchResponse)>

## Source

[utils/fetch.ts:59](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L59)


# FetchRetryFunc
Source: https://docs.qu.ai/sdk/content/type-aliases/FetchRetryFunc



```ts theme={null}
type FetchRetryFunc: (req, resp, attempt) => Promise<boolean>;
```

Called prior to each retry; return true to retry, false to abort.

## Parameters

| Parameter | Type                                                  |
| :-------- | :---------------------------------------------------- |
| `req`     | [`FetchRequest`](/sdk/content/classes/FetchRequest)   |
| `resp`    | [`FetchResponse`](/sdk/content/classes/FetchResponse) |
| `attempt` | `number`                                              |

## Returns

`Promise`\<`boolean`>

## Source

[utils/fetch.ts:66](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L66)


# FixedFormat
Source: https://docs.qu.ai/sdk/content/type-aliases/FixedFormat



```ts theme={null}
type FixedFormat: number | string | {
  "decimals": number;
  "signed": boolean;
  "width": number;
};
```

Returns a new FixedFormat for `value`.

If `value` is specified as a `number`, the bit-width is 128 bits and `value` is used for the `decimals`.

A string `value` may begin with `fixed` or `ufixed` for signed and unsigned respectfully. If no other properties are
specified, the bit-width is 128-bits with 18 decimals.

To specify the bit-width and demicals, append them separated by an `"x"` to the `value`.

For example, `ufixed128x18` describes an unsigned, 128-bit wide format with 18 decimals.

If `value` is an other object, its properties for `signed`, `width` and `decimals` are checked.

## Source

[utils/fixednumber.ts:52](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fixednumber.ts#L52)


# GetUrlResponse
Source: https://docs.qu.ai/sdk/content/type-aliases/GetUrlResponse



```ts theme={null}
type GetUrlResponse: {
  "body": null | Uint8Array;
  "headers": Record<string, string>;
  "statusCode": number;
  "statusMessage": string;
};
```

An environment's implementation of `getUrl` must return this type.

## Type declaration

### body

```ts theme={null}
body: null | Uint8Array;
```

### headers

```ts theme={null}
headers: Record<string, string>;
```

### statusCode

```ts theme={null}
statusCode: number;
```

### statusMessage

```ts theme={null}
statusMessage: string;
```

## Source

[utils/fetch.ts:29](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/fetch.ts#L29)


# KeystoreAccount
Source: https://docs.qu.ai/sdk/content/type-aliases/KeystoreAccount



```ts theme={null}
type KeystoreAccount: {
  "address": string;
  "mnemonic": {
     "entropy": string;
     "locale": string;
     "path": string;
    };
  "privateKey": string;
};
```

The contents of a JSON Keystore Wallet.

## Type declaration

### address

```ts theme={null}
address: string;
```

### mnemonic?

```ts theme={null}
optional mnemonic: {
  "entropy": string;
  "locale": string;
  "path": string;
};
```

### mnemonic.entropy

```ts theme={null}
entropy: string;
```

### mnemonic.locale?

```ts theme={null}
optional locale: string;
```

### mnemonic.path?

```ts theme={null}
optional path: string;
```

### privateKey

```ts theme={null}
privateKey: string;
```

## Source

[wallet/json-keystore.ts:28](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wallet/json-keystore.ts#L28)


# Listener
Source: https://docs.qu.ai/sdk/content/type-aliases/Listener



```ts theme={null}
type Listener: (...args) => void;
```

A callback function called when a an event is triggered.

## Parameters

| Parameter | Type     |
| :-------- | :------- |
| ...`args` | `any`\[] |

## Returns

`void`

## Source

[utils/events.ts:13](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/events.ts#L13)


# Numeric
Source: https://docs.qu.ai/sdk/content/type-aliases/Numeric



```ts theme={null}
type Numeric: number | bigint;
```

Any type that can be used where a numeric value is needed.

## Source

[utils/maths.ts:14](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/utils/maths.ts#L14)


# wordlists
Source: https://docs.qu.ai/sdk/content/variables/wordlists



```ts theme={null}
const wordlists: Record<string, Wordlist>;
```

The available Wordlists by their [ISO 639-1 Language Code](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) .

(**i.e.** LangCz | cz, [en](/sdk/content/classes/LangEn), [es](/sdk/content/classes/LangEs), LangFr | fr, LangJa | ja,
LangKo | ko, LangIt | it, LangPt | pt, LangZh | zh\_cn, LangZh | zh\_tw)

The dist files (in the `/dist` folder) have had all languages except English stripped out, which reduces the library
size by about 80kb. If required, they are available by importing the included `wordlists-extra.min.js` file.

## Source

[wordlists/wordlists.ts:24](https://github.com/dominant-strategies/quais.js/blob/c1c12d43f9d34c6baad2b0542bd6d0acd6fefcbf/src/wordlists/wordlists.ts#L24)