Sequence

https://docs.sequence.xyz
Admin
Sequence is a modular crypto infrastructure stack that unifies wallets, 1-click cross-chain...
Tokens:980,905
Snippets:5,657
Trust Score:9.4
Update:19 hours ago
Show doc for...
Tokens:
Raw
### Install dependencies and run the project

Source: https://docs.sequence.xyz/guides/primary-sales

After cloning the repository, install dependencies and start the development server. This command is used in both the GitHub clone and template methods.

```bash
pnpm install && pnpm dev
```

--------------------------------

### Install go-sequence via go get

Source: https://docs.sequence.xyz/api-references/indexer/installation

Install the Go SDK for the Sequence Indexer.

```bash
go get -u github.com/0xsequence/go-sequence@latest
```

--------------------------------

### Install Dependencies and Run Dev Server

Source: https://docs.sequence.xyz/guides/webgl-guide

Use pnpm (or your preferred package manager) to install dependencies and start the development server. After running, you should see a plane flying over water.

```bash
# or your choice of package manager
pnpm install
pnpm run dev
```

--------------------------------

### Install dependencies and run the React project

Source: https://docs.sequence.xyz/sdk/unity/wallets/embedded-wallet/onboard/authentication/oidc

After building your Unity project on Web platforms, run these commands in the build root to install dependencies and start the development server on localhost:4444.

```bash
pnpm install
```

```bash
pnpm dev
```

--------------------------------

### Install dependencies and run dev server

Source: https://docs.sequence.xyz/guides/unity-webgl-telegram

Run these commands in the React project's root directory to install dependencies and start the development server for testing the game in the browser.

```bash
pnpm install
pnpm run dev
```

--------------------------------

### Install @0xsequence/checkout and @0xsequence/connect

Source: https://docs.sequence.xyz/solutions/payments/checkout-sdk

Install the required packages for the Checkout SDK.

```bash
pnpm add @0xsequence/checkout @0xsequence/connect
```

--------------------------------

### Market Purchase Example - Setup Handler Component

Source: https://docs.sequence.xyz/sdk/web/marketplace-sdk/hooks/marketplace-actions/useBuyModal

First step of the market purchase example: a main component that loads and validates the marketplace config, then renders the MarketPurchase component with the first collection's chainId and itemsAddress.

```typescript
import {
  useBuyModal,
  useLowestListing,
  useMarketplaceConfig,
} from '@0xsequence/marketplace-sdk/react';
import type { Address } from 'viem';

function MarketPurchaseExample() {
  const { data: marketplaceConfig, isLoading: isMarketplaceConfigLoading } =
    useMarketplaceConfig();

  // Handle loading states
  if (isMarketplaceConfigLoading) {
    return <div style={{ padding: '20px' }}>Loading marketplace config...</div>;
  }

  if (!marketplaceConfig) {
    return (
      <div style={{ padding: '20px' }}>No marketplace config available</div>
    );
  }

  const collection = marketplaceConfig.market.collections[0];

  if (!collection) {
    return <div style={{ padding: '20px' }}>No collections available</div>;
  }

  const chainId = collection.chainId;
  const collectionAddress = collection.itemsAddress as Address;

  return (
    <MarketPurchase
      chainId={chainId}
      collectionAddress={collectionAddress}
      collectibleId="0"
    />
  );
}
```

--------------------------------

### Install dependencies and run Sidekick in dev mode without Docker

Source: https://docs.sequence.xyz/solutions/infrastructure/sidekick/quickstart

Run these commands to install dependencies and start Sidekick in development mode without Docker. This will also start a Redis server.

```bash
pnpm install
pnpm dev:withRedis
```

--------------------------------

### Go: Setup Indexer Gateway client and send ping request

Source: https://docs.sequence.xyz/api-references/indexer-gateway/installation

Create an Indexer Gateway client in Go using the indexer package, set the X-Access-Key header with the token, and send a ping request to check service availability. The example shows the necessary imports and the main function structure.

```go
package main

import (
	"context"
	"net/http"

	"github.com/0xsequence/go-sequence/indexer"
)

const indexerToken = "AQAAAAAAAF_JvPALhBthL7VGn6jV0YDqaFY"

func main() {
	seqIndexerGW := indexer.NewIndexerGatewayClient(
		"https://indexer.sequence.app",
		http.DefaultClient,
	)
	
  authCtx, err := indexer.WithHTTPRequestHeaders(ctx, http.Header{
		"X-Access-Key": []string{indexerToken},
	})
	if err != nil {
		log.Fatal(err)
	}

  ok, err := seqIndexerGW.Ping()
  // ...
}
```

--------------------------------

### Install Checkout SDK with npm, pnpm, or yarn

Source: https://docs.sequence.xyz/sdk/web/checkout-sdk/getting-started

Install the @0xsequence/checkout package using your preferred package manager. The Connect SDK must be installed and set up first.

```bash
npm install @0xsequence/checkout
# or
pnpm install @0xsequence/checkout
# or
yarn add @0xsequence/checkout
```

--------------------------------

### Go: Get Token Balances Summary

Source: https://docs.sequence.xyz/api-references/indexer-gateway/examples/get-token-balances-details

Use this Go example with the go-sequence indexer package to fetch token balance summaries. It sets up an IndexerGatewayClient, adds the X-Access-Key header, and calls GetTokenBalancesSummary with the account address and networks.

```go
package main

import (
	"context"
	"fmt"
	"log"
	"net/http"

	"github.com/0xsequence/go-sequence/indexer"
	"github.com/0xsequence/go-sequence/lib/prototyp"
)

const indexerToken = "AQAAAAAAAF_JvPALhBthL7VGn6jV0YDqaFY"

func main() {
	ctx := context.TODO()

	seqIndexerGW := indexer.NewIndexerGatewayClient(
		"https://indexer.sequence.app",
		http.DefaultClient,
	)

	authCtx, err := indexer.WithHTTPRequestHeaders(ctx, http.Header{
		"X-Access-Key": []string{indexerToken},
	})
	if err != nil {
		log.Fatal(err)
	}

	accountAddress := "0x8e3E38fe7367dd3b52D1e281E4e8400447C8d8B9"

	_, nativeBalances, balances, err := seqIndexerGW.GetTokenBalancesSummary(
		authCtx,
		nil, // No chainId filter
		networks,
    []string{"polygon", "mainnet"},
		&indexer.TokenBalancesFilter{
			AccountAddresses: []prototyp.Hash{
				prototyp.HashFromString(accountAddress),
			},
		},
		nil, // Default omitMetadata
		nil, // Default page
	)
	if err != nil {
		log.Fatal(err)
	}

	// Native Balances
	for _, nativeBalance := range nativeBalances {
		fmt.Printf("chainId: %d (native balances)\n", nativeBalance.ChainId)
		for _, result := range nativeBalance.Results {
			fmt.Printf("\tbalance: %s\n", result.Balance)
		}
	}

	// Token Balances
	for _, balance := range balances {
		fmt.Printf("chainId: %d (token balances)\n", balance.ChainID)
		for _, result := range balance.Results {
			fmt.Printf("\tcontractAddress: %s, balance: %s\n",
				result.ContractAddress, result.Balance)
		}
	}
}
```

--------------------------------

### Install @0xsequence/waas with npm

Source: https://docs.sequence.xyz/sdk/headless-wallet/authentication

Install the Sequence WaaS SDK using npm.

```bash
npm install @0xsequence/waas
```

--------------------------------

### Install @0xsequence/waas with pnpm

Source: https://docs.sequence.xyz/sdk/headless-wallet/authentication

Install the Sequence WaaS SDK using pnpm.

```bash
pnpm install @0xsequence/waas
```

--------------------------------

### Install Wallet Widget SDK

Source: https://docs.sequence.xyz/sdk/web/wallet-widget-sdk/getting-started

Install the @0xsequence/wallet-widget package using npm, pnpm, or yarn. This package depends on the Connect SDK, which must be installed and set up first.

```bash
npm install @0xsequence/wallet-widget
# or
pnpm install @0xsequence/wallet-widget
# or
yarn add @0xsequence/wallet-widget
```

--------------------------------

### Basic Example: SellToOfferExample

Source: https://docs.sequence.xyz/sdk/web/marketplace-sdk/hooks/marketplace-actions/useSellModal

A complete component that uses useSellModal along with useBalanceOfCollectible and useListOffersForCollectible to verify ownership and display available offers before allowing the user to accept an offer. It requires the collection address and chainId from the marketplace config, and assumes the user has followed the Getting Started guide.

```tsx
import {
  useSellModal,
  useBalanceOfCollectible,
  useListOffersForCollectible,
} from "@0xsequence/marketplace-sdk/react";
import { useAccount } from "wagmi";
import type { Address } from "viem";
import type { Order } from "@0xsequence/marketplace-sdk";

export default function SellToOfferExample() {
  const { address: accountAddress } = useAccount();
  const { data: marketplaceConfig, isLoading: isMarketplaceConfigLoading } =
    useMarketplaceConfig();

  const collection = marketplaceConfig?.market.collections[0];
  const chainId = collection?.chainId as number;
  const collectionAddress = collection?.itemsAddress as Address;
  // Replace with your collectible ID that has at least one offer
  const collectibleId = "0";

  // Check if user owns the collectible
  const {
    data: balance,
    isLoading: isLoadingBalance,
    isError: isErrorBalance,
  } = useBalanceOfCollectible({
    collectionAddress,
    collectableId: collectibleId,
    userAddress: accountAddress,
    chainId,
  });

  // Get available offers for this collectible
  const {
    data: offersData,
    isLoading: isLoadingOffers,
    error: offersError,
  } = useListOffersForCollectible({
    chainId,
    collectionAddress,
    collectibleId,
  });

  const { show: showSellModal } = useSellModal({
    onSuccess: ({ hash, orderId }) => {
      console.log("Sale completed successfully", { hash, orderId });
    },
    onError: (error) => {
      console.error("Sale failed:", error.message);
    },
  });

  const handleSellToOffer = (offer: Order) => {
    if (!balance || Number(balance) === 0) return;

    showSellModal({
      chainId,
      collectionAddress,
      tokenId: collectibleId,
      order: offer,
    });
  };

  const isOwner = balance && Number(balance) > 0;
  const isLoading = isLoadingBalance || isLoadingOffers;
  const hasError = isErrorBalance || offersError;
  const hasOffers = offersData?.orders && offersData.orders.length > 0;

  if (isLoading) {
    return <div>Loading...</div>;
  }

  if (hasError) {
    return <div>Error loading data</div>;
  }

  if (!isOwner) {
    return <div>You don't own this collectible</div>;
  }

  if (!hasOffers) {
    return <div>No offers available for this collectible</div>;
  }

  return (
    <div style={{ padding: "20px" }}>
      <h3>Available Offers</h3>
      <p>Collectible ID: {collectibleId}</p>
      <p>Your Balance: {balance}</p>

      <div style={{ marginTop: "16px" }}>
        {offersData.orders.map((offer) => (
          <div
            key={offer.orderId}
            style={{
              border: "1px solid #e0e0e0",
              borderRadius: "8px",
              padding: "16px",
              marginBottom: "12px",
              display: "flex",
              justifyContent: "space-between",
              alignItems: "center",
            }}
          >
            <div>
              <p>
                Price: {offer.priceAmount} {offer.priceCurrency?.symbol}
              </p>
              <p>From: {offer.createdBy}</p>
              <p>
                Expires:{" "}
                {new Date(offer.validUntil * 1000).toLocaleDateString()}
              </p>
            </div>

            <button
              onClick={() => handleSellToOffer(offer)}
              style={{
                backgroundColor: "#28a745",
                color: "white",
                border: "none",
                padding: "8px 16px",
                borderRadius: "4px",
                cursor: "pointer",
              }}
            >
              Accept Offer
            </button>
          </div>
        ))}
      </div>
    </div>
  );
}
```

--------------------------------

### Go example for ResumeAllWebhookListeners

Source: https://docs.sequence.xyz/api-references/indexer/endpoints/secret/resume-all-webhook-listeners

Uses net/http to send a POST request with a JSON body. Prints the response body.

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://amoy-indexer.sequence.app/rpc/Indexer/ResumeAllWebhookListeners"

	payload := strings.NewReader("{\n  \"projectId\": 123\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

--------------------------------

### Get Wallet Address with SequenceWaaS

Source: https://docs.sequence.xyz/sdk/headless-wallet/use-wallets

Initializes the SequenceWaaS client and retrieves the user's wallet address. The address is unique, immutable, 42 characters long, and starts with '0x'. The example also logs the address and compares it to the wallet object from signIn.

```typescript
import { SequenceWaaS } from "@0xsequence/waas";

const sequence = new SequenceWaaS(
  {
    projectAccessKey: `${process.env.VITE_PROJECT_ACCESS_KEY}`,
    waasConfigKey: `${process.env.VITE_WAAS_CONFIG_KEY}`,
    network: "arbitrum-nova",
  }
);

const { wallet } = await sequence.signIn({ idToken }, "Session name")
const address = await sequence.getAddress();

console.log(address == wallet) // true

console.log(address)
```

```text
0xE4b10c53aa75E19E088cfDD0cff7D46a0E4206F0
```

--------------------------------

### Install pnpm

Source: https://docs.sequence.xyz/guides/building-relaying-server

Command to install pnpm, a Node.js package manager, required for the environment setup.

```bash
curl -fsSL https://get.pnpm.io/install.sh | sh -
```

--------------------------------

### Go example for GetAllWebhookListeners

Source: https://docs.sequence.xyz/api-references/indexer/endpoints/secret/get-all-webhook-listeners

Uses net/http to send a POST request with a JSON payload. Prints the response body.

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://amoy-indexer.sequence.app/rpc/Indexer/GetAllWebhookListeners"

	payload := strings.NewReader("{\n  \"projectId\": 31396\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

--------------------------------

### Start Sidekick in a Docker container

Source: https://docs.sequence.xyz/solutions/infrastructure/sidekick/quickstart

Runs the pnpm script to start Sidekick in a Docker container. Requires Docker to be installed.

```bash
pnpm docker:start
```

--------------------------------

### Install Sequence and Web3 packages

Source: https://docs.sequence.xyz/guides/custom-marketplace

Install @0xsequence/connect, @0xsequence/hooks, wagmi, ethers, viem, 0xsequence, and @tanstack/react-query using npm, pnpm, or yarn.

```bash
npm install @0xsequence/connect @0xsequence/hooks wagmi ethers viem 0xsequence @tanstack/react-query
# or
pnpm install @0xsequence/connect @0xsequence/hooks wagmi ethers viem 0xsequence @tanstack/react-query
# or
yarn add @0xsequence/connect @0xsequence/hooks wagmi ethers viem 0xsequence @tanstack/react-query
```

--------------------------------

### Usage example of useChain hook

Source: https://docs.sequence.xyz/sdk/web/wallet-sdk/ecosystem/hooks/useChain

Example showing how to use useChain to get the current chain configuration and a specific chain (Ethereum Mainnet) by ID, and display their properties.

```typescript
import { useChain } from '@0xsequence/connect'

function App() {
  // Get current chain configuration
  const currentChain = useChain()
  
  // Get configuration for a specific chain (e.g., Ethereum Mainnet)
  const ethereumChain = useChain(1)
  
  return (
    <div>
      <h2>Current Chain</h2>
      {currentChain && (
        <div>
          <p>Name: {currentChain.name}</p>
          <p>Chain ID: {currentChain.id}</p>
          <p>Network: {currentChain.network}</p>
          <p>Native Currency: {currentChain.nativeCurrency.symbol}</p>
        </div>
      )}
      
      <h2>Ethereum Mainnet</h2>
      {ethereumChain && (
        <div>
          <p>Name: {ethereumChain.name}</p>
          <p>Chain ID: {ethereumChain.id}</p>
          <p>Network: {ethereumChain.network}</p>
          <p>Native Currency: {ethereumChain.nativeCurrency.symbol}</p>
        </div>
      )}
    </div>
  )
}
```

--------------------------------

### Go example for ListContractSources

Source: https://docs.sequence.xyz/api-references/builder/endpoints/list-contract-sources

Go example using net/http to POST to ListContractSources. It builds a JSON payload as a string, sets the API key header, and prints the response body.

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.sequence.app/rpc/Builder/ListContractSources"

	payload := strings.NewReader("{\n  \"projectId\": 123,\n  \"page\": {\n    \"pageSize\": 123,\n    \"page\": 123,\n    \"column\": \"<string>\",\n    \"more\": true,\n    \"before\": {},\n    \"after\": {},\n    \"sort\": [\n      {\n        \"column\": \"<string>\"\n      }\n    ]\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("X-Access-Key", "<api-key>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

--------------------------------

### GetTokenBalances Go Example

Source: https://docs.sequence.xyz/api-references/indexer-gateway/examples/get-token-balances

Go example using github.com/0xsequence/go-sequence/indexer. Creates an IndexerGatewayClient, sets the X-Access-Key header, and calls GetTokenBalances with optional chainIDs, accountAddress, includeMetadata, and metadataOptions. Logs token balances per chain. Includes sample output in a comment.

```go
package main

import (
	"context"
	"fmt"
	"log"
	"net/http"

	"github.com/0xsequence/go-sequence/indexer"
)

const indexerToken = "AQAAAAAAAF_JvPALhBthL7VGn6jV0YDqaFY"

func main() {
	ctx := context.TODO()

	seqIndexerGW := indexer.NewIndexerGatewayClient(
		"https://indexer.sequence.app",
		http.DefaultClient,
	)

	authCtx, err := indexer.WithHTTPRequestHeaders(ctx, http.Header{
		"X-Access-Key": []string{indexerToken},
	})

	includeMetadata := true
	accountAddress := "0x8e3E38fe7367dd3b52D1e281E4e8400447C8d8B9"

	chainIDs := make([]uint64, 0)

	// chainIDs = []uint64{1, 100, 137} // optional filter by chainID

	metadataOptions := indexer.MetadataOptions{
		VerifiedOnly: true,
	}

	_, tokenBalances, err := seqIndexerGW.GetTokenBalances(
    authCtx, 
    chainIDs,
    nil, 
    &accountAddress, 
    nil, 
    nil, 
    &includeMetadata, 
    &metadataOptions, 
    nil,
    nil,
  )
	if err != nil {
		log.Fatal(err)
	}

	for _, tb := range tokenBalances {
		if len(tb.Results) == 0 {
			continue
		}
		fmt.Printf("ChainID: %d -> %d tokens found\n", tb.ChainID, len(tb.Results))
		for _, tokenBalance := range tb.Results {
			fmt.Printf("\tToken: %q (%q): %s\n", tokenBalance.ContractAddress, tokenBalance.ContractInfo.Symbol, tokenBalance.Balance)
		}
	}
}

/*
Sample output:
ChainID: 1 -> 7 tokens found
        Token: "0xc770eefad204b5180df6a14ee197d99d808ee52d" ("FOX"): 58899592885266406938
        Token: "0x6b175474e89094c44da98b954eedeac495271d0f" ("DAI"): 5021334051688125324
        Token: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48" ("USDC"): 221887067
*/
```

--------------------------------

### TransactionQueuer.Setup()

Source: https://docs.sequence.xyz/sdk/unity/wallets/embedded-wallet/blockchain-interactions

Initializes the TransactionQueuer, creating and caching required dependencies. Must be called before using other methods.

```APIDOC
## TransactionQueuer.Setup()

### Description
Initializes the TransactionQueuer, creating and caching required dependencies. Must be called before using other methods.

### Method
Setup

### Parameters
None

### Returns
None
```

--------------------------------

### Basic Listing Creation Example

Source: https://docs.sequence.xyz/sdk/web/marketplace-sdk/hooks/marketplace-actions/useCreateListingModal

Example of implementing a basic listing creation using the useCreateListingModal hook. It uses useCollectible and useBalanceOfCollectible hooks to verify ownership and get collectible details.

```APIDOC
```typescript
export default function BasicListingExample() {
  const { address: accountAddress } = useAccount();
  const { data: marketplaceConfig, isLoading: isMarketplaceConfigLoading } =
    useMarketplaceConfig();

  const collection = marketplaceConfig?.market.collections[0];
  const chainId = collection?.chainId as number;
  const collectionAddress = collection?.itemsAddress as Address;
  const collectibleId = '0';
  const orderbookKind = OrderbookKind.sequence_marketplace_v2;

  // Get collectible metadata
  const {
    data: collectible,
    isLoading: isLoadingCollectible,
    isError: isErrorCollectible,
  } = useCollectible({
    chainId,
    collectionAddress,
    collectibleId,
  });

  // Check if user owns the collectible
  const {
    data: balance,
    isLoading: isLoadingBalance,
    isError: isErrorBalance,
  } = useBalanceOfCollectible({
    collectionAddress,
    collectableId: collectibleId,
    userAddress: accountAddress as Address,
    chainId,
    query: {
      enabled: !!accountAddress,
    },
  });

  const { show: showCreateListingModal } = useCreateListingModal({
    onSuccess: ({ hash, orderId }) => {
      console.log('Listing created successfully', { hash, orderId });
    },
    onError: (error) => {
      console.error('Listing creation failed:', error.message);
    },
  });

  const handleCreateListing = () => {
    if (!collectible || !balance || Number(balance) === 0) return;

    showCreateListingModal({
      chainId,
      collectionAddress,
      collectibleId,
      orderbookKind,
    });
  };

  const isOwner = balance && Number(balance) > 0;
  const isLoading = isLoadingCollectible || isLoadingBalance;
  const hasError = isErrorCollectible || isErrorBalance;

  return (
    <div style={{ padding: '20px' }}>
      <h3>Create Listing</h3>

      {collectible && (
        <div style={{ marginBottom: '16px' }}>
          <p>Name: {collectible.name}</p>
          <p>Collectible ID: {collectibleId}</p>
          <p>Owned: {balance?.balance || '0'}</p>
        </div>
      )}

      <button
        type="button"
        onClick={handleCreateListing}
        disabled={isLoading || hasError || !isOwner || !accountAddress}
        style={{
          backgroundColor: isOwner ? '#007bff' : '#6c757d',
          color: 'white',
          border: 'none',
          padding: '12px 24px',
          borderRadius: '8px',
          cursor: isOwner ? 'pointer' : 'not-allowed',
        }}
      >
        {isLoading
          ? 'Loading...'
          : !accountAddress
            ? 'Connect Wallet'
            : !isOwner
              ? "You don't own this collectible"
              : 'Create Listing'}
      </button>
    </div>
  );
}
```
```

--------------------------------

### Usage example with wagmi useAccount

Source: https://docs.sequence.xyz/sdk/web/checkout-sdk/hooks/useTransferFundsModal

Example showing how to use useTransferFundsModal in a React component. It uses wagmi's useAccount to get the wallet address and opens the transfer funds modal with the address.

```typescript
import { useTransferFundsModal } from '@0xsequence/checkout'
import { useAccount } from 'wagmi'

function App() {
  const { openTransferFundsModal } = useTransferFundsModal()
  const { address } = useAccount()
  
  const handleOpenTransfer = () => {
    openTransferFundsModal({ walletAddress: address || '' })
  }
  
  return (
    <div>
      <button onClick={handleOpenTransfer}>
        Receive Funds
      </button>
    </div>
  )
}
```

--------------------------------

### useWaasFeeOptions Usage Example

Source: https://docs.sequence.xyz/sdk/web/wallet-sdk/embedded/hooks/useWaasFeeOptions

Complete example of using the useWaasFeeOptions hook. It demonstrates getting pending fee options, confirming or rejecting them, and rendering a UI for selecting a fee payment token. The example includes an optional configuration to skip balance checking, shown in a comment.

```typescript
import { useWaasFeeOptions } from '@0xsequence/connect'
import { useEffect, useState } from 'react'

function App() {
  // Use the hook with default balance checking
  // This will return the wallet balance for each fee option
  const [
    pendingFeeOptionConfirmation,
    confirmPendingFeeOption,
    rejectPendingFeeOption
  ] = useWaasFeeOptions()
  
  // Or skip balance checking if needed
  // const [pendingFeeOptionConfirmation, confirmPendingFeeOption, rejectPendingFeeOption] =
  //   useWaasFeeOptions({ skipFeeBalanceCheck: true })
  
  const [selectedFeeOptionTokenName, setSelectedFeeOptionTokenName] = useState<string>()
  
  // Initialize with first option when fee options become available
  useEffect(() => {
    if (pendingFeeOptionConfirmation) {
      console.log('Pending fee options: ', pendingFeeOptionConfirmation.options)
      
      // You could select the first fee option by default
      if (pendingFeeOptionConfirmation.options.length > 0) {
        const firstOption = pendingFeeOptionConfirmation.options[0]
        setSelectedFeeOptionTokenName(firstOption.token.symbol)
      }
    }
  }, [pendingFeeOptionConfirmation])
  
  // Handle fee option selection and confirmation
  const handleConfirmFee = (tokenAddress: string | null) => {
    if (pendingFeeOptionConfirmation) {
      confirmPendingFeeOption(pendingFeeOptionConfirmation.id, tokenAddress)
    }
  }
  
  // Handle fee option rejection
  const handleRejectFee = () => {
    if (pendingFeeOptionConfirmation) {
      rejectPendingFeeOption(pendingFeeOptionConfirmation.id)
    }
  }
  
  // Render fee options UI
  if (pendingFeeOptionConfirmation) {
    return (
      <div>
        <h2>Select Fee Payment Token</h2>
        <div>
          {pendingFeeOptionConfirmation.options.map((option) => (
            <div key={option.token.symbol || option.token.contractAddress}>
              <input
                type="radio"
                name="feeOption"
                checked={selectedFeeOptionTokenName === option.token.symbol}
                onChange={() => setSelectedFeeOptionTokenName(option.token.symbol)}
              />
              <label>
                {option.token.symbol} - {option.token.contractAddress ? 
                  option.token.contractAddress : 'Native Token'}
                {/* Display balance info if extended with balance data */}
                {'balanceFormatted' in option && 
                  ` (Balance: ${option.balanceFormatted} ${option.token.symbol})`}
              </label>
            </div>
          ))}
        </div>
        <div>
          <button onClick={() => handleConfirmFee(
            pendingFeeOptionConfirmation.options.find(
              opt => opt.token.symbol === selectedFeeOptionTokenName
            )?.token.contractAddress || null
          )}>
            Confirm
          </button>
          <button onClick={handleRejectFee}>Cancel</button>
        </div>
      </div>
    )
  }
  
  return <div>No pending fee confirmation</div>
}

```

--------------------------------

### Go example for AddWebhookListener

Source: https://docs.sequence.xyz/api-references/indexer/endpoints/secret/add-webhook-listener

Go program using net/http to call AddWebhookListener. It creates a POST request with the JSON payload and headers, sends it, and prints the response body.

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://amoy-indexer.sequence.app/rpc/Indexer/AddWebhookListener"

	payload := strings.NewReader("{\n  \"filters\": {\n    \"accounts\": [\n      \"0xe6eB28398CCBe46aA505b62b96822c2Ce8DAABf4\"\n    ],\n    \"contractAddresses\": [\n      \"0x9bec34c1f7098e278afd48fedcf13355b854364a\"\n    ],\n    \"events\": [\n      \"Transfer(address indexed from, address indexed to, uint256 indexed tokenId)\"\n    ]\n  },\n  \"projectId\": 31396,\n  \"url\": \"https://webhook.site/#!/view/a2859143-0a52-4b69-98f2-a58733e4dcf0\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

--------------------------------

### Create Go project directory and main.go

Source: https://docs.sequence.xyz/sdk/unity/wallets/embedded-wallet/onboard/authentication/oidc

Commands to create a directory for the Go project and create the main.go file.

```bash
mkdir myUnityServer
cd myUnityServer
touch main.go
```

--------------------------------

### Usage example with useSequenceWaaS

Source: https://docs.sequence.xyz/sdk/web/wallet-sdk/embedded/hooks/useSequenceWaas

Example of using the useSequenceWaaS hook in a React component to get a WaaS instance and call listAccounts(). The instance is automatically configured with project access key and WaaS config key from the Connect configuration.

```typescript
import { useSequenceWaaS } from '@0xsequence/connect'

function App() {
  const sequenceWaaS = useSequenceWaaS()
  
  const handleWaaSOperation = async () => {
    try {
      // Use the WaaS instance to get connected accounts      
      const response = await sequenceWaaS.listAccounts()
      console.log('Accounts:', response.accounts)
    } catch (error) {
      console.error('WaaS operation failed:', error)
    }
  }
  
  return (
    <div>
      <button onClick={handleWaaSOperation}>
        Perform WaaS Operation
      </button>
    </div>
  )
}
```

--------------------------------

### Run the app with pnpm dev

Source: https://docs.sequence.xyz/guides/use-with-privy

Starts the development server for the app.

```bash
pnpm dev
```

--------------------------------

### Usage example with wagmi useAccount

Source: https://docs.sequence.xyz/sdk/web/hooks-sdk/hooks/useGetNativeTokenBalance

Example component using useGetNativeTokenBalance to fetch native token balances for multiple chains. It uses wagmi's useAccount to get the address and displays loading, error, and balance data.

```tsx
import { useGetNativeTokenBalance } from '@0xsequence/hooks'
import { useAccount } from 'wagmi'

function NativeBalances() {
  const { address } = useAccount()
  
  const {
    data: balances,
    isLoading,
    isError,
    error
  } = useGetNativeTokenBalance({
    accountAddress: address || '',
    chainIds: [1, 137] // Fetch ETH on Ethereum and POL on Polygon
  })

  if (isLoading) return <div>Loading...</div>
  if (isError) return <div>Error: {error.message}</div>

  return (
    <div>
      {balances?.map(balance => (
        <div key={balance.chainId}>
          <h3>Chain {balance.chainId}</h3>
          <p>Balance: {balance.balance}</p>
          <p>Token: {balance.contractAddress}</p>
        </div>
      ))}
    </div>
  )
}
```

--------------------------------

### Go example for PauseAllWebhookListeners

Source: https://docs.sequence.xyz/api-references/indexer/endpoints/secret/pause-all-webhook-listeners

Uses net/http to send a POST request with a JSON payload. Prints the response body.

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://amoy-indexer.sequence.app/rpc/Indexer/PauseAllWebhookListeners"

	payload := strings.NewReader("{\n  \"projectId\": 123\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

--------------------------------

### Usage with useIndexerClients

Source: https://docs.sequence.xyz/sdk/web/hooks-sdk/hooks/useIndexerClient

Example using useIndexerClients to get indexer clients for multiple chains (Ethereum mainnet and Polygon) and make parallel requests.

```typescript
import { useIndexerClients } from '@0xsequence/hooks'

const TransactionFetcher = () => {
  // Get indexer clients for Ethereum mainnet and Polygon
  const indexerClients = useIndexerClients([1, 137])

  // Use the clients to fetch data
  const fetchData = async () => {
    // Get Ethereum client
    const ethClient = indexerClients.get(1)

    // Get Polygon client
    const polygonClient = indexerClients.get(137)

    // Make parallel requests
    const [ethData, polygonData] = await Promise.all([
      ethClient.getTransactionHistory(...),
      polygonClient.getTransactionHistory(...)
    ])
  }
}
```

--------------------------------

### Go example using indexer.NewIndexerGateway

Source: https://docs.sequence.xyz/solutions/indexer/cross-chain-balances

Uses the go-sequence indexer package to create a gateway and call GetTokenBalances with an account address and includeMetadata. Logs the result or fatal error.

```go
import (
	"context"
	"fmt"
	"log"
	"net/http"

	"github.com/0xsequence/go-sequence/indexer"
)

func GetTokenBalances(accountAddress string) {
	seqIndexer := indexer.NewIndexerGateway("https://indexer.sequence.app", "AQAAAAAAAF_JvPALhBthL7VGn6jV0YDqaFY")

	includeMetadata := true

	tokenBalances, _, err := seqIndexer.GetTokenBalances(context.Background(), &accountAddress, nil, &includeMetadata, nil, nil)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("tokenBalances:", tokenBalances)
}
```

--------------------------------

### Get Wallet Address

Source: https://docs.sequence.xyz/sdk/headless-wallet/use-wallets

Retrieves the wallet address associated with the authenticated user's account. The address is unique, immutable, and 42 characters long starting with '0x'.

```APIDOC
## Get Wallet Address

### Description
Retrieves the wallet address associated with the authenticated user's account. The address is unique, immutable, and 42 characters long starting with '0x'.

### Method
SDK Method: `getAddress()`

### Parameters
None

### Request Example
```javascript
import { SequenceWaaS } from "@0xsequence/waas";

const sequence = new SequenceWaaS(
  {
    projectAccessKey: `${process.env.VITE_PROJECT_ACCESS_KEY}`,
    waasConfigKey: `${process.env.VITE_WAAS_CONFIG_KEY}`,
    network: "arbitrum-nova",
  }
);

const { wallet } = await sequence.signIn({ idToken }, "Session name")
const address = await sequence.getAddress();

console.log(address == wallet) // true

console.log(address)
```

### Response Example
```
0xE4b10c53aa75E19E088cfDD0cff7D46a0E4206F0
```

```

--------------------------------

### TypeScript example using SequenceIndexer

Source: https://docs.sequence.xyz/solutions/indexer/cross-chain-balances

Uses the @0xsequence/indexer package to create an indexer instance and call getTokenBalances with an account address and includeMetadata. Requires installing the package via npm or yarn.

```typescript
// Make sure to install the @0xsequence/indexer package:
// npm install @0xsequence/indexer
// or
// yarn add @0xsequence/indexer

import { SequenceIndexer } from '@0xsequence/indexer'

const indexer = new SequenceIndexerGateway('https://indexer.sequence.app', 'AQAAAAAAAF_JvPALhBthL7VGn6jV0YDqaFY')

// try any account address you'd like
const accountAddress = '0x8e3E38fe7367dd3b52D1e281E4e8400447C8d8B9'

// query Sequence Indexer for all token balances across all EVM chains we support
// for full list of supported networks, see https://status.sequence.info
const tokenBalances = await indexer.getTokenBalances({
	accountAddress: accountAddress,
	includeMetadata: true
})

console.log('tokens in your account:', tokenBalances)
```

--------------------------------

### Copy example environment and wrangler configuration files

Source: https://docs.sequence.xyz/guides/telegram-integration

Copies the example environment and wrangler configuration files to the project root. Update the .env file with your VITE_PROJECT_ACCESS_KEY and VITE_WAAS_CONFIG_KEY from Sequence Builder.

```bash
cp .env.example .env && cp example.wrangler.toml wrangler.toml
```

--------------------------------

### useListCollectibles usage example

Source: https://docs.sequence.xyz/sdk/web/marketplace-sdk/hooks/marketplace-data/useListCollectibles

Import useListCollectibles and OrderSide, then call the hook with chainId, collectionAddress, optional filter, and side. The returned data is paginated; flatten pages to get an array of collectibles.

```typescript
import { OrderSide } from '@0xsequence/marketplace-sdk';
import { useListCollectibles } from '@0xsequence/marketplace-sdk/react';

## Into your React component:

const {
  data: collectibles,
  isLoading: collectiblesLoading,
  fetchNextPage: fetchNextCollectibles,
} = useListCollectibles({
  chainId,
  collectionAddress,
  filter: {
    // # Optional filters
    includeEmpty,
    searchText,
    properties,
  },
  side: OrderSide.listing,
});

const collectiblesFlat =
  collectibles?.pages.flatMap((p) => p.collectibles) ?? [];

return (
  <div>
    {collectiblesFlat?.map((collectible) => (
      // Your Collectibles component
    ))}
  </div>
);
```

--------------------------------

### Get Checkout Options (C++)

Source: https://docs.sequence.xyz/sdk/unreal/monetization/checkout

C++ example for retrieving checkout options using USequenceCheckout::GetCheckoutOptions. Requires chain ID, wallet address, orders, and additional fee basis points.

```cpp
const TSuccessCallback<FGetCheckoutOptionsResponse> OnApiSuccess = [this, OnSuccess](const FGetCheckoutOptionsResponse& Response) { };
const FFailureCallback OnApiFailure = [this, OnFailure](const FSequenceError& Error) { };

USequenceCheckout* Checkout = NewObject<USequenceCheckout>();
Checkout->GetCheckoutOptions(SequenceSdk::GetChainId(), WalletAddress, Orders, AdditionalFeeBps, OnApiSuccess, OnApiFailure);
```

--------------------------------

### Sign In with Google (C++)

Source: https://docs.sequence.xyz/sdk/unreal/wallets/embedded-wallet/onboarding/authentication

Starts an OIDC session with a valid Google ID token. The token is obtained from the 'Get Google Id Token' node. Provides callbacks for success, failure, and federation-required scenarios.

```cpp
const FString IdToken = "ey1234";

const TFunction<void()> OnApiSuccess = []() { };
const FFailureCallback OnApiFailure = [](const FSequenceError& Error) { };
const TFunction<void(FFederationSupportData)> OnApiFederationRequired = [](const FFederationSupportData& FederationData) { };

USequenceSessions* Sessions = NewObject<USequenceSessions>();
Sessions->StartOidcSession(IdToken, OnApiSuccess, OnApiFailure, OnApiFederationRequired);
```

--------------------------------

### Go example for Analytics/WalletsTotal

Source: https://docs.sequence.xyz/api-references/analytics/endpoints/secret/wallets-total

Uses net/http to send a POST request with a JSON payload and prints the response body.

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.sequence.app/rpc/Analytics/WalletsTotal"

	payload := strings.NewReader("{\n  \"filter\": {\n    \"projectId\": 123,\n    \"ecosystemId\": 123,\n    \"startDate\": \"<string>\",\n    \"endDate\": \"<string>\",\n    \"collections\": [\n      \"<string>\"\n    ],\n    \"tokenId\": \"<string>\"\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

```

--------------------------------

### Fetch token balances with TypeScript SDK

Source: https://docs.sequence.xyz/solutions/indexer/overview

Use the @0xsequence/indexer package to query token balances for an account on Polygon. Install the package with npm or yarn. The example uses an access key and includes metadata in the response.

```typescript
// Make sure to install the @0xsequence/indexer package:
// npm install @0xsequence/indexer
// or
// yarn add @0xsequence/indexer

import { SequenceIndexer } from '@0xsequence/indexer'

const indexer = new SequenceIndexer('https://polygon-indexer.sequence.app', 'AQAAAAAAAF_JvPALhBthL7VGn6jV0YDqaFY')

// try any account address you'd like :)
const accountAddress = '0xabc...'

// query Sequence Indexer for all token balances of the account on Polygon
const tokenBalances = await indexer.getTokenBalances({
	accountAddress: accountAddress,
	includeMetadata: true
})
console.log('tokens in your account:', tokenBalances)
```

--------------------------------

### Demo Scene: Wait for FeeOptions and submit first available

Source: https://docs.sequence.xyz/sdk/unity/wallets/embedded-wallet/blockchain-interactions

Sample from the Demo Scene that requests FeeOptions and submits the first option that is in the user's wallet. Logs an error if none are affordable. Not recommended for production.

```csharp
private async Task WaitForFeeOptionsAndSubmitFirstAvailable(Address toAddress, string amount)
{
    Transaction[] transactions = new Transaction[]
    {
        new RawTransaction(toAddress, amount)
    };
    FeeOptionsResponse response = await _wallet.GetFeeOptions(_chain, transactions)
    int options = response.FeeOptions.Length;
    for (int i = 0; i < options; i++)
    {
        if (response.FeeOptions[i].InWallet)
        {
            await _wallet.SendTransactionWithFeeOptions(_chain, transactions, response.FeeOptions[i].FeeOption,
                response.FeeQuote);
            return;
        }
    }

    Debug.LogError("The user does not have enough of the valid FeeOptions in their wallet");
}
```

--------------------------------

### Get Checkout Options by Orders (C++)

Source: https://docs.sequence.xyz/sdk/unreal/monetization/checkout

C++ example for retrieving checkout options based on orders using USequenceCheckout::GetCheckoutOptionsByOrders. Requires chain ID, wallet address, orders, and additional fee basis points.

```cpp
const TSuccessCallback<FGetCheckoutOptionsResponse> OnApiSuccess = [this, OnSuccess](const FGetCheckoutOptionsResponse& Response) { };
const FFailureCallback OnApiFailure = [this, OnFailure](const FSequenceError& Error) { };

USequenceCheckout* Checkout = NewObject<USequenceCheckout>();
Checkout->GetCheckoutOptionsByOrders(SequenceSdk::GetChainId(), WalletAddress, Orders, AdditionalFeeBps, OnApiSuccess, OnApiFailure);
```

--------------------------------

### Install Sequence, Privy, and wagmi/viem dependencies

Source: https://docs.sequence.xyz/guides/use-with-privy

Install the required packages for integrating Privy with Sequence, including @0xsequence/account, @0xsequence/core, @0xsequence/network, @0xsequence/sessions, @0xsequence/signhub, @privy-io/react-auth, @privy-io/wagmi-connector, wagmi, @privy-io/wagmi, @tanstack/react-query, viem, and ethers.

```bash
pnpm install @0xsequence/account @0xsequence/core @0xsequence/network @0xsequence/sessions @0xsequence/signhub @privy-io/react-auth @privy-io/wagmi-connector wagmi @privy-io/wagmi @tanstack/react-query viem ethers
```

--------------------------------

### Basic setup with SequenceConnect and SequenceCheckoutProvider

Source: https://docs.sequence.xyz/solutions/payments/checkout-sdk

Wrap your app with SequenceConnect and SequenceCheckoutProvider to enable checkout functionality.

```tsx
import { SequenceConnect } from '@0xsequence/connect'
import { SequenceCheckoutProvider } from '@0xsequence/checkout'
import { config } from './config'

export default function App() {
  return (
    <SequenceConnect config={config}>
      <SequenceCheckoutProvider>
        <YourRoutes />
      </SequenceCheckoutProvider>
    </SequenceConnect>
  )
}
```
Tokens:
Raw