> ## Documentation Index
> Fetch the complete documentation index at: https://docs.polymarket.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Relayer Client

> Use Polymarket's Polygon relayer to execute gasless transactions for your users

## Overview

The Relayer Client routes onchain transactions through Polymarket's infrastructure, providing gasless transactions for your users. Builder authentication is required to access the relayer.

<CardGroup cols={3}>
  <Card title="Gasless Transactions" icon="gas-pump">
    Polymarket pays all gas fees
  </Card>

  <Card title="Wallet Deployment" icon="wallet">
    Deploy Safe or Proxy wallets
  </Card>

  <Card title="CTF Operations" icon="arrows-split-up-and-left">
    Split, merge, and redeem positions
  </Card>
</CardGroup>

***

## Builder API Credentials

Each builder receives API credentials from their [Builder Profile](/developers/builders/builder-profile):

| Credential   | Description                          |
| ------------ | ------------------------------------ |
| `key`        | Your builder API key identifier      |
| `secret`     | Secret key for signing requests      |
| `passphrase` | Additional authentication passphrase |

<Warning>
  **Security Notice**: Your Builder API keys must be kept secure. Never expose them in client-side code.
</Warning>

***

## Installation

<CodeGroup>
  ```bash TypeScript theme={null}
  npm install @polymarket/builder-relayer-client
  ```

  ```bash Python theme={null}
  pip install py-builder-relayer-client
  ```
</CodeGroup>

***

## Relayer Endpoint

All relayer requests are sent to Polymarket's relayer service on Polygon:

```
https://relayer-v2.polymarket.com/
```

***

## Signing Methods

<Tabs>
  <Tab title="Remote Signing (Recommended)">
    Remote signing keeps your credentials secure on a server you control.

    **How it works:**

    1. Client sends request details to your signing server
    2. Your server generates the HMAC signature
    3. Client attaches headers and sends to relayer

    ### Server Implementation

    Your signing server receives request details and returns the authentication headers:

    <CodeGroup>
      ```typescript TypeScript theme={null}
      import { 
        buildHmacSignature, 
        BuilderApiKeyCreds 
      } from "@polymarket/builder-signing-sdk";

      const BUILDER_CREDENTIALS: BuilderApiKeyCreds = {
        key: process.env.POLY_BUILDER_API_KEY!,
        secret: process.env.POLY_BUILDER_SECRET!,
        passphrase: process.env.POLY_BUILDER_PASSPHRASE!,
      };

      // POST /sign - receives { method, path, body } from the client SDK
      export async function handleSignRequest(request) {
        const { method, path, body } = await request.json();
        
        const timestamp = Date.now().toString();
        
        const signature = buildHmacSignature(
          BUILDER_CREDENTIALS.secret,
          parseInt(timestamp),
          method,
          path,
          body
        );

        return {
          POLY_BUILDER_SIGNATURE: signature,
          POLY_BUILDER_TIMESTAMP: timestamp,
          POLY_BUILDER_API_KEY: BUILDER_CREDENTIALS.key,
          POLY_BUILDER_PASSPHRASE: BUILDER_CREDENTIALS.passphrase,
        };
      }
      ```

      ```python Python theme={null}
      import os
      import time
      from py_builder_signing_sdk.signing.hmac import build_hmac_signature
      from py_builder_signing_sdk import BuilderApiKeyCreds

      BUILDER_CREDENTIALS = BuilderApiKeyCreds(
          key=os.environ["POLY_BUILDER_API_KEY"],
          secret=os.environ["POLY_BUILDER_SECRET"],
          passphrase=os.environ["POLY_BUILDER_PASSPHRASE"],
      )

      # POST /sign - receives { method, path, body } from the client SDK
      def handle_sign_request(method: str, path: str, body: str):
          timestamp = str(int(time.time()))
          
          signature = build_hmac_signature(
              BUILDER_CREDENTIALS.secret,
              timestamp,
              method,
              path,
              body
          )

          return {
              "POLY_BUILDER_SIGNATURE": signature,
              "POLY_BUILDER_TIMESTAMP": timestamp,
              "POLY_BUILDER_API_KEY": BUILDER_CREDENTIALS.key,
              "POLY_BUILDER_PASSPHRASE": BUILDER_CREDENTIALS.passphrase,
          }
      ```
    </CodeGroup>

    <Warning>
      Never commit credentials to version control. Use environment variables or a secrets manager.
    </Warning>

    ### Client Configuration

    Point your client to your signing server:

    <CodeGroup>
      ```typescript TypeScript theme={null}
      import { createWalletClient, http, Hex } from "viem";
      import { privateKeyToAccount } from "viem/accounts";
      import { polygon } from "viem/chains";
      import { RelayClient } from "@polymarket/builder-relayer-client";
      import { BuilderConfig } from "@polymarket/builder-signing-sdk";

      // Create wallet
      const account = privateKeyToAccount(process.env.PRIVATE_KEY as Hex);
      const wallet = createWalletClient({
        account,
        chain: polygon,
        transport: http(process.env.RPC_URL)
      });

      // Configure remote signing
      const builderConfig = new BuilderConfig({
        remoteBuilderConfig: { 
          url: "https://your-server.com/sign" 
        }
      });

      const RELAYER_URL = "https://relayer-v2.polymarket.com/";
      const CHAIN_ID = 137;

      const client = new RelayClient(
        RELAYER_URL,
        CHAIN_ID,
        wallet,
        builderConfig
      );
      ```

      ```python Python theme={null}
      import os
      from py_builder_relayer_client.client import RelayClient
      from py_builder_signing_sdk import BuilderConfig, RemoteBuilderConfig

      private_key = os.getenv("PRIVATE_KEY")

      # Configure remote signing
      builder_config = BuilderConfig(
          remote_builder_config=RemoteBuilderConfig(
              url="https://your-server.com/sign"
          )
      )

      client = RelayClient(
          "https://relayer-v2.polymarket.com",
          137,
          private_key,
          builder_config
      )
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Local Signing">
    Sign locally when your backend handles all transactions.

    **How it works:**

    1. Your system creates transactions on behalf of users
    2. Your system uses Builder API credentials locally to add headers
    3. Complete signed request is sent directly to the relayer

    <CodeGroup>
      ```typescript TypeScript theme={null}
      import { createWalletClient, http, Hex } from "viem";
      import { privateKeyToAccount } from "viem/accounts";
      import { polygon } from "viem/chains";
      import { RelayClient } from "@polymarket/builder-relayer-client";
      import { BuilderConfig } from "@polymarket/builder-signing-sdk";

      // Create wallet
      const account = privateKeyToAccount(process.env.PRIVATE_KEY as Hex);
      const wallet = createWalletClient({
        account,
        chain: polygon,
        transport: http(process.env.RPC_URL)
      });

      // Configure local signing
      const builderConfig = new BuilderConfig({
        localBuilderCreds: {
          key: process.env.POLY_BUILDER_API_KEY!,
          secret: process.env.POLY_BUILDER_SECRET!,
          passphrase: process.env.POLY_BUILDER_PASSPHRASE!
        }
      });

      const RELAYER_URL = "https://relayer-v2.polymarket.com/";
      const CHAIN_ID = 137;

      const client = new RelayClient(
        RELAYER_URL,
        CHAIN_ID,
        wallet,
        builderConfig
      );
      ```

      ```python Python theme={null}
      import os
      from py_builder_relayer_client.client import RelayClient
      from py_builder_signing_sdk import BuilderConfig, BuilderApiKeyCreds

      private_key = os.getenv("PRIVATE_KEY")

      # Configure local signing
      builder_config = BuilderConfig(
          local_builder_creds=BuilderApiKeyCreds(
              key=os.getenv("POLY_BUILDER_API_KEY"),
              secret=os.getenv("POLY_BUILDER_SECRET"),
              passphrase=os.getenv("POLY_BUILDER_PASSPHRASE"),
          )
      )

      client = RelayClient(
          "https://relayer-v2.polymarket.com",
          137,
          private_key,
          builder_config
      )
      ```
    </CodeGroup>

    <Warning>
      Never commit credentials to version control. Use environment variables or a secrets manager.
    </Warning>
  </Tab>
</Tabs>

***

## Authentication Headers

The SDK automatically generates and attaches these headers to each request:

| Header                    | Description                          |
| ------------------------- | ------------------------------------ |
| `POLY_BUILDER_API_KEY`    | Your builder API key                 |
| `POLY_BUILDER_TIMESTAMP`  | Unix timestamp of signature creation |
| `POLY_BUILDER_PASSPHRASE` | Your builder passphrase              |
| `POLY_BUILDER_SIGNATURE`  | HMAC signature of the request        |

<Info>
  With **local signing**, the SDK constructs and attaches these headers automatically. With **remote signing**, your server must return these headers (see Server Implementation above), and the SDK attaches them to the request.
</Info>

***

## Wallet Types

Choose your wallet type before using the relayer:

<Tabs>
  <Tab title="Safe Wallets">
    Gnosis Safe-based proxy wallets that require explicit deployment before use.

    * **Best for:** Most builder integrations
    * **Deployment:** Call `client.deploy()` before first transaction
    * **Gas fees:** Paid by Polymarket

    <CodeGroup>
      ```typescript TypeScript theme={null}
      const client = new RelayClient(
        "https://relayer-v2.polymarket.com", 
        137,
        eoaSigner, 
        builderConfig, 
        RelayerTxType.SAFE  // Default
      );

      // Deploy before first use
      const response = await client.deploy();
      const result = await response.wait();
      console.log("Safe Address:", result?.proxyAddress);
      ```

      ```python Python theme={null}
      from py_builder_relayer_client.client import RelayClient, RelayerTxType

      client = RelayClient(
          "https://relayer-v2.polymarket.com",
          137,
          private_key,
          builder_config,
          RelayerTxType.SAFE  # Default
      )

      # Deploy before first use
      response = client.deploy()
      result = response.wait()
      print(f"Safe Address: {result.proxy_address}")
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Proxy Wallets">
    Custom Polymarket proxy wallets that auto-deploy on first transaction.

    * **Used for:** Magic Link users from Polymarket.com
    * **Deployment:** Automatic on first transaction
    * **Gas fees:** Paid by Polymarket

    <CodeGroup>
      ```typescript TypeScript theme={null}
      const client = new RelayClient(
        "https://relayer-v2.polymarket.com", 
        137,
        eoaSigner, 
        builderConfig, 
        RelayerTxType.PROXY
      );

      // No deploy() needed - auto-deploys on first tx
      await client.execute([transaction], "First transaction");
      ```

      ```python Python theme={null}
      from py_builder_relayer_client.client import RelayClient, RelayerTxType

      client = RelayClient(
          "https://relayer-v2.polymarket.com",
          137,
          private_key,
          builder_config,
          RelayerTxType.PROXY
      )

      # No deploy() needed - auto-deploys on first tx
      client.execute([transaction], "First transaction")
      ```
    </CodeGroup>
  </Tab>
</Tabs>

<Accordion title="Wallet Comparison Table">
  | Feature           |     Safe Wallets    |      Proxy Wallets      |
  | ----------------- | :-----------------: | :---------------------: |
  | Deployment        | Explicit `deploy()` | Auto-deploy on first tx |
  | Gas Fees          |   Polymarket pays   |     Polymarket pays     |
  | ERC20 Approvals   |          ✅          |            ✅            |
  | CTF Operations    |          ✅          |            ✅            |
  | Send Transactions |          ✅          |            ✅            |
</Accordion>

***

## Usage

### Deploy a Wallet

For Safe wallets, deploy before executing transactions:

<CodeGroup>
  ```typescript TypeScript theme={null}
  const response = await client.deploy();
  const result = await response.wait();

  if (result) {
    console.log("Safe deployed successfully!");
    console.log("Transaction Hash:", result.transactionHash);
    console.log("Safe Address:", result.proxyAddress);
  }
  ```

  ```python Python theme={null}
  response = client.deploy()
  result = response.wait()

  if result:
      print("Safe deployed successfully!")
      print(f"Transaction Hash: {result.transaction_hash}")
      print(f"Safe Address: {result.proxy_address}")
  ```
</CodeGroup>

### Execute Transactions

The `execute` method sends transactions through the relayer. Pass an array of transactions to batch multiple operations in a single call.

<CodeGroup>
  ```typescript TypeScript theme={null}
  interface Transaction {
    to: string;    // Target contract or wallet address
    data: string;  // Encoded function call (use "0x" for simple transfers)
    value: string; // Amount of MATIC to send (usually "0")
  }

  const response = await client.execute(transactions, "Description");
  const result = await response.wait();

  if (result) {
    console.log("Transaction confirmed:", result.transactionHash);
  }
  ```

  ```python Python theme={null}
  # Transaction dict format:
  # { "to": str, "data": str, "value": str }

  response = client.execute(transactions, "Description")
  result = response.wait()

  if result:
      print(f"Transaction confirmed: {result.transaction_hash}")
  ```
</CodeGroup>

### Transaction Examples

<Tabs>
  <Tab title="Transfer">
    Transfer tokens to any address (e.g., withdrawals):

    <CodeGroup>
      ```typescript TypeScript theme={null}
      import { encodeFunctionData, parseUnits } from "viem";

      const transferTx = {
        to: "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174", // USDCe
        data: encodeFunctionData({
          abi: [{
            name: "transfer",
            type: "function",
            inputs: [
              { name: "to", type: "address" },
              { name: "amount", type: "uint256" }
            ],
            outputs: [{ type: "bool" }]
          }],
          functionName: "transfer",
          args: [
            "0xRecipientAddressHere",
            parseUnits("100", 6) // 100 USDCe (6 decimals)
          ]
        }),
        value: "0"
      };

      const response = await client.execute([transferTx], "Transfer USDCe");
      await response.wait();
      ```

      ```python Python theme={null}
      from web3 import Web3

      USDC_E = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174"

      transfer_tx = {
          "to": USDC_E,
          "data": Web3().eth.contract(
              address=USDC_E,
              abi=[{"name": "transfer", "type": "function", "inputs": [{"name": "to", "type": "address"}, {"name": "amount", "type": "uint256"}], "outputs": [{"type": "bool"}]}]
          ).encode_abi(abi_element_identifier="transfer", args=["0xRecipientAddressHere", 100 * 10**6]),
          "value": "0"
      }

      response = client.execute([transfer_tx], "Transfer USDCe")
      response.wait()
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Approve">
    Set token allowances to enable trading:

    <CodeGroup>
      ```typescript TypeScript theme={null}
      import { encodeFunctionData, maxUint256 } from "viem";

      const approveTx = {
        to: "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174", // USDCe
        data: encodeFunctionData({
          abi: [{
            name: "approve",
            type: "function",
            inputs: [
              { name: "spender", type: "address" },
              { name: "amount", type: "uint256" }
            ],
            outputs: [{ type: "bool" }]
          }],
          functionName: "approve",
          args: [
            "0x4d97dcd97ec945f40cf65f87097ace5ea0476045", // CTF
            maxUint256
          ]
        }),
        value: "0"
      };

      const response = await client.execute([approveTx], "Approve USDCe for CTF");
      await response.wait();
      ```

      ```python Python theme={null}
      from web3 import Web3

      USDC_E = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174"
      CTF = "0x4d97dcd97ec945f40cf65f87097ace5ea0476045"
      MAX_UINT256 = 2**256 - 1

      approve_tx = {
          "to": USDC_E,
          "data": Web3().eth.contract(
              address=USDC_E,
              abi=[{"name": "approve", "type": "function", "inputs": [{"name": "spender", "type": "address"}, {"name": "amount", "type": "uint256"}], "outputs": [{"type": "bool"}]}]
          ).encode_abi(abi_element_identifier="approve", args=[CTF, MAX_UINT256]),
          "value": "0"
      }

      response = client.execute([approve_tx], "Approve USDCe for CTF")
      response.wait()
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Redeem Positions">
    Redeem winning conditional tokens after market resolution:

    <CodeGroup>
      ```typescript TypeScript theme={null}
      import { encodeFunctionData } from "viem";

      const redeemTx = {
        to: ctfAddress,
        data: encodeFunctionData({
          abi: [{
            name: "redeemPositions",
            type: "function",
            inputs: [
              { name: "collateralToken", type: "address" },
              { name: "parentCollectionId", type: "bytes32" },
              { name: "conditionId", type: "bytes32" },
              { name: "indexSets", type: "uint256[]" }
            ],
            outputs: []
          }],
          functionName: "redeemPositions",
          args: [collateralToken, parentCollectionId, conditionId, indexSets]
        }),
        value: "0"
      };

      const response = await client.execute([redeemTx], "Redeem positions");
      await response.wait();
      ```

      ```python Python theme={null}
      from web3 import Web3

      CTF = "0x4d97dcd97ec945f40cf65f87097ace5ea0476045"

      redeem_tx = {
          "to": CTF,
          "data": Web3().eth.contract(
              address=CTF,
              abi=[{"name": "redeemPositions", "type": "function", "inputs": [{"name": "collateralToken", "type": "address"}, {"name": "parentCollectionId", "type": "bytes32"}, {"name": "conditionId", "type": "bytes32"}, {"name": "indexSets", "type": "uint256[]"}], "outputs": []}]
          ).encode_abi(abi_element_identifier="redeemPositions", args=[collateral_token, parent_collection_id, condition_id, index_sets]),
          "value": "0"
      }

      response = client.execute([redeem_tx], "Redeem positions")
      response.wait()
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Split Positions">
    Split collateral tokens into conditional outcome tokens:

    <CodeGroup>
      ```typescript TypeScript theme={null}
      import { encodeFunctionData } from "viem";

      const splitTx = {
        to: ctfAddress,
        data: encodeFunctionData({
          abi: [{
            name: "splitPosition",
            type: "function",
            inputs: [
              { name: "collateralToken", type: "address" },
              { name: "parentCollectionId", type: "bytes32" },
              { name: "conditionId", type: "bytes32" },
              { name: "partition", type: "uint256[]" },
              { name: "amount", type: "uint256" }
            ],
            outputs: []
          }],
          functionName: "splitPosition",
          args: [collateralToken, parentCollectionId, conditionId, partition, amount]
        }),
        value: "0"
      };

      const response = await client.execute([splitTx], "Split positions");
      await response.wait();
      ```

      ```python Python theme={null}
      from web3 import Web3

      CTF = "0x4d97dcd97ec945f40cf65f87097ace5ea0476045"

      split_tx = {
          "to": CTF,
          "data": Web3().eth.contract(
              address=CTF,
              abi=[{"name": "splitPosition", "type": "function", "inputs": [{"name": "collateralToken", "type": "address"}, {"name": "parentCollectionId", "type": "bytes32"}, {"name": "conditionId", "type": "bytes32"}, {"name": "partition", "type": "uint256[]"}, {"name": "amount", "type": "uint256"}], "outputs": []}]
          ).encode_abi(abi_element_identifier="splitPosition", args=[collateral_token, parent_collection_id, condition_id, partition, amount]),
          "value": "0"
      }

      response = client.execute([split_tx], "Split positions")
      response.wait()
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Merge Positions">
    Merge conditional tokens back into collateral:

    <CodeGroup>
      ```typescript TypeScript theme={null}
      import { encodeFunctionData } from "viem";

      const mergeTx = {
        to: ctfAddress,
        data: encodeFunctionData({
          abi: [{
            name: "mergePositions",
            type: "function",
            inputs: [
              { name: "collateralToken", type: "address" },
              { name: "parentCollectionId", type: "bytes32" },
              { name: "conditionId", type: "bytes32" },
              { name: "partition", type: "uint256[]" },
              { name: "amount", type: "uint256" }
            ],
            outputs: []
          }],
          functionName: "mergePositions",
          args: [collateralToken, parentCollectionId, conditionId, partition, amount]
        }),
        value: "0"
      };

      const response = await client.execute([mergeTx], "Merge positions");
      await response.wait();
      ```

      ```python Python theme={null}
      from web3 import Web3

      CTF = "0x4d97dcd97ec945f40cf65f87097ace5ea0476045"

      merge_tx = {
          "to": CTF,
          "data": Web3().eth.contract(
              address=CTF,
              abi=[{"name": "mergePositions", "type": "function", "inputs": [{"name": "collateralToken", "type": "address"}, {"name": "parentCollectionId", "type": "bytes32"}, {"name": "conditionId", "type": "bytes32"}, {"name": "partition", "type": "uint256[]"}, {"name": "amount", "type": "uint256"}], "outputs": []}]
          ).encode_abi(abi_element_identifier="mergePositions", args=[collateral_token, parent_collection_id, condition_id, partition, amount]),
          "value": "0"
      }

      response = client.execute([merge_tx], "Merge positions")
      response.wait()
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Batch Transactions">
    Execute multiple transactions atomically in a single call:

    <CodeGroup>
      ```typescript TypeScript theme={null}
      import { encodeFunctionData, parseUnits, maxUint256 } from "viem";

      const erc20Abi = [
        {
          name: "approve",
          type: "function",
          inputs: [
            { name: "spender", type: "address" },
            { name: "amount", type: "uint256" }
          ],
          outputs: [{ type: "bool" }]
        },
        {
          name: "transfer",
          type: "function",
          inputs: [
            { name: "to", type: "address" },
            { name: "amount", type: "uint256" }
          ],
          outputs: [{ type: "bool" }]
        }
      ] as const;

      // Approve CTF to spend USDCe
      const approveTx = {
        to: "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174",
        data: encodeFunctionData({
          abi: erc20Abi,
          functionName: "approve",
          args: ["0x4d97dcd97ec945f40cf65f87097ace5ea0476045", maxUint256]
        }),
        value: "0"
      };

      // Transfer some USDCe to another wallet
      const transferTx = {
        to: "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174",
        data: encodeFunctionData({
          abi: erc20Abi,
          functionName: "transfer",
          args: ["0xRecipientAddressHere", parseUnits("50", 6)]
        }),
        value: "0"
      };

      // Both transactions execute in one call
      const response = await client.execute(
        [approveTx, transferTx], 
        "Approve and transfer"
      );
      await response.wait();
      ```

      ```python Python theme={null}
      from web3 import Web3

      USDC_E = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174"
      CTF = "0x4d97dcd97ec945f40cf65f87097ace5ea0476045"
      MAX_UINT256 = 2**256 - 1

      erc20_abi = [
          {"name": "approve", "type": "function", "inputs": [{"name": "spender", "type": "address"}, {"name": "amount", "type": "uint256"}], "outputs": [{"type": "bool"}]},
          {"name": "transfer", "type": "function", "inputs": [{"name": "to", "type": "address"}, {"name": "amount", "type": "uint256"}], "outputs": [{"type": "bool"}]}
      ]

      contract = Web3().eth.contract(address=USDC_E, abi=erc20_abi)

      # Approve CTF to spend USDCe
      approve_tx = {
          "to": USDC_E,
          "data": contract.encode_abi(abi_element_identifier="approve", args=[CTF, MAX_UINT256]),
          "value": "0"
      }

      # Transfer some USDCe to another wallet
      transfer_tx = {
          "to": USDC_E,
          "data": contract.encode_abi(abi_element_identifier="transfer", args=["0xRecipientAddressHere", 50 * 10**6]),
          "value": "0"
      }

      # Both transactions execute in one call
      response = client.execute([approve_tx, transfer_tx], "Approve and transfer")
      response.wait()
      ```
    </CodeGroup>

    <Info>
      Batching reduces latency and ensures all transactions succeed or fail together.
    </Info>
  </Tab>
</Tabs>

***

## Reference

### Contracts & Approvals

| Contract              | Address                                      | USDCe | Outcome Tokens |
| --------------------- | -------------------------------------------- | :---: | :------------: |
| USDCe                 | `0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174` |   —   |        —       |
| CTF                   | `0x4d97dcd97ec945f40cf65f87097ace5ea0476045` |   ✅   |        —       |
| CTF Exchange          | `0x4bFb41d5B3570DeFd03C39a9A4D8dE6Bd8B8982E` |   ✅   |        ✅       |
| Neg Risk CTF Exchange | `0xC5d563A36AE78145C45a50134d48A1215220f80a` |   ✅   |        ✅       |
| Neg Risk Adapter      | `0xd91E80cF2E7be2e162c6513ceD06f1dD0dA35296` |   —   |        ✅       |

### Transaction States

| State             | Description                                  |
| ----------------- | -------------------------------------------- |
| `STATE_NEW`       | Transaction received by relayer              |
| `STATE_EXECUTED`  | Transaction executed onchain                 |
| `STATE_MINED`     | Transaction included in a block              |
| `STATE_CONFIRMED` | Transaction confirmed (final ✅)              |
| `STATE_FAILED`    | Transaction failed (terminal ❌)              |
| `STATE_INVALID`   | Transaction rejected as invalid (terminal ❌) |

### TypeScript Types

<Accordion title="View Type Definitions">
  ```typescript  theme={null}
  // Transaction type used in all examples
  interface Transaction {
    to: string;
    data: string;
    value: string;
  }

  // Wallet type selector
  enum RelayerTxType {
    SAFE = "SAFE",
    PROXY = "PROXY"
  }

  // Transaction states
  enum RelayerTransactionState {
    STATE_NEW = "STATE_NEW",
    STATE_EXECUTED = "STATE_EXECUTED",
    STATE_MINED = "STATE_MINED",
    STATE_CONFIRMED = "STATE_CONFIRMED",
    STATE_FAILED = "STATE_FAILED",
    STATE_INVALID = "STATE_INVALID"
  }

  // Response from relayer
  interface RelayerTransaction {
    transactionID: string;
    transactionHash: string;
    from: string;
    to: string;
    proxyAddress: string;
    data: string;
    state: string;
    type: string;
    metadata: string;
    createdAt: Date;
    updatedAt: Date;
  }
  ```
</Accordion>

***

## Next Steps

<CardGroup cols={2}>
  <Card title="Order Attribution" icon="tag" href="/developers/builders/order-attribution">
    Attribute orders to your builder account
  </Card>

  <Card title="Example Apps" icon="code" href="/developers/builders/examples">
    Complete integration examples
  </Card>
</CardGroup>