Zora

https://docs.zora.co
Admin
Zora provides developer tools, including a Coins SDK, to build projects that create, manage, and...
Tokens:49,781
Snippets:366
Trust Score:9.6
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install Coins SDK

Source: https://docs.zora.co/coins/sdk

Install the Coins SDK using npm. Ensure viem is installed as a peer dependency for on-chain operations.

```bash
npm install @zoralabs/coins-sdk
```

```bash
npm install viem
```

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

### Get Coin Data with Python SDK

Source: https://docs.zora.co/coins/sdk/public-rest-api

This Python script demonstrates how to fetch coin data using the requests library. Ensure you have the 'requests' library installed.

```python
import requests

API_KEY = "your-api-key-here"
BASE_URL = "https://api-sdk.zora.engineering/api"

headers = {
    "api-key": API_KEY
}

# Get coin data
response = requests.get(
    f"{BASE_URL}/coin",
    headers=headers,
    params={
        "address": "0xCoinContractAddress",
        "chain": 8453
    }
)

coin_data = response.json()
print(coin_data)
```

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

### Pagination Example

Source: https://docs.zora.co/coins/sdk/queries/explore

Demonstrates how to implement pagination to fetch all coins matching a specific explore query, such as top gainers, by iteratively fetching data using cursors.

```APIDOC
## Pagination

Most explore queries support pagination to handle large result sets. Here's an example of how to implement pagination to fetch all coins that match a particular explore query:

```javascript
import { getCoinsTopGainers } from "@zoralabs/coins-sdk";

async function fetchAllTopGainers() {
  let allCoins: any[] = [];
  let cursor = undefined;
  const pageSize = 20;

  // Continue fetching until no more pages
  do {
    const response = await getCoinsTopGainers({
      count: pageSize,
      after: cursor,
    });

    // Add coins to our collection
    if (response.data?.exploreList && response.data?.exploreList?.edges?.length || 0 > 0) {
      allCoins = [...allCoins, ...(response.data?.exploreList?.edges?.map((edge: any) => edge.node) || [])];
    }

    // Update cursor for next page
    cursor = response.data?.exploreList?.pageInfo?.endCursor;

    // Break if no more results
    if (!cursor || response.data?.exploreList?.edges?.length === 0) {
      break;
    }

  } while (true);

  console.log(`Fetched ${allCoins.length} total top gaining coins`);
  return allCoins;
}
```
```

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

### Create Coin (High-level)

Source: https://docs.zora.co/coins/sdk/create-coin

This example demonstrates the high-level `createCoin` function, which sends and waits for the transaction to deploy an ERC20 coin with protocol integrations.

```APIDOC
## createCoin

### Description
Sends a transaction to deploy an ERC20 coin with protocol integrations and waits for the transaction receipt.

### Method
`createCoin(args: { call: CreateCoinArgs; walletClient: WalletClient; publicClient: PublicClient; options?: { account?: Hex; skipValidateTransaction?: boolean } }): Promise<{ hash: Hex; address: Address; deployment: Deployment; chain: Chain }> 

### Parameters
#### `call` (CreateCoinArgs) - Required
Arguments for creating the coin.
- **creator** (Address) - Required - Creator address.
- **name** (string) - Required - Coin name (e.g., "My Awesome Coin").
- **symbol** (string) - Required - Ticker (e.g., "MAC").
- **metadata** (MetadataType) - Required - Metadata descriptor.
  - **type** ("RAW_URI") - Required - Must be "RAW_URI".
  - **uri** (string) - Required - e.g., an IPFS URI.
- **currency** (ContentCoinCurrency) - Required - CREATOR_COIN | CREATOR_COIN_OR_ZORA | ZORA | ETH.
- **chainId** (number) - Optional - Chain ID to deploy on (defaults to Base mainnet `8453`).
- **startingMarketCap** (StartingMarketCap) - Optional - LOW | HIGH (defaults to LOW).
- **platformReferrer** (Address) - Optional - Referral address.
- **additionalOwners** (Address[]) - Optional - Additional owner addresses.
- **payoutRecipientOverride** (Address) - Optional - Override for the payout recipient.
- **skipMetadataValidation** (boolean) - Optional - Skip URI validation (not recommended).

#### `walletClient` (WalletClient) - Required
The wallet client to use for sending the transaction.

#### `publicClient` (PublicClient) - Required
The public client to use for interacting with the blockchain.

#### `options` (object) - Optional
Options for the transaction.
- **account** (Hex) - Optional - Override the account to use for the transaction.
- **skipValidateTransaction** (boolean) - Optional - Skip transaction validation (defaults to `false`).

### Request Example
```javascript
import {
  createCoin,
  CreateConstants,
  ContentCoinCurrency,
} from "@zoralabs/coins-sdk";
import {
  Hex,
  Address,
  createWalletClient,
  createPublicClient,
  http,
} from "viem";
import { base } from "viem/chains";

const publicClient = createPublicClient({
  chain: base,
  transport: http("<RPC_URL>"),
});

const walletClient = createWalletClient({
  account: "0x<YOUR_ACCOUNT>" as Hex,
  chain: base,
  transport: http("<RPC_URL>"),
});

const args = {
  creator: "0xYourAddress" as Address,
  name: "My Awesome Coin",
  symbol: "MAC",
  metadata: { type: "RAW_URI" as const, uri: "ipfs://bafy..." },
  currency: CreateConstants.ContentCoinCurrencies.ZORA,
  chainId: base.id,
  startingMarketCap: CreateConstants.StartingMarketCaps.LOW,
  platformReferrerAddress: "0xOptionalReferrer" as Address,
};

const result = await createCoin({
  call: args,
  walletClient,
  publicClient,
  options: {
    // account: optional override
    // skipValidateTransaction: false by default
  },
});

console.log("Transaction hash:", result.hash);
console.log("Coin address:", result.address);
console.log("Deployment details:", result.deployment);
console.log("Chain info:", result.chain);
```

### Response
#### Success Response (200)
Returns an object containing the transaction hash, coin address, deployment details, and chain information.
- **hash** (Hex) - The transaction hash.
- **address** (Address) - The deployed coin's address.
- **deployment** (Deployment) - Details about the coin deployment.
- **chain** (Chain) - Information about the chain the coin was deployed on.

#### Response Example
```json
{
  "hash": "0x...",
  "address": "0x...",
  "deployment": { ... },
  "chain": { ... }
}
```
```

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

### Trading Creator Coin for ETH

Source: https://docs.zora.co/coins/sdk/trade-coin

Example of how to trade a Creator Coin for ETH using the tradeCoin function.

```APIDOC
const tradeParameters: TradeParameters = {
  sell: {
    type: "erc20",
    address: "0x4e93a01c90f812284f71291a8d1415a904957156" // Creator Coin address
  },
  buy: { type: "eth" },
  amountIn: parseEther("100"), // 100 tokens (adjust decimals as needed)
  slippage: 0.15, // 15% slippage tolerance
  sender: account.address,
};

const receipt = await tradeCoin({
  tradeParameters,
  walletClient,
  account,
  publicClient,
});
```

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

### Get Coin Data with Go SDK

Source: https://docs.zora.co/coins/sdk/public-rest-api

This Go program shows how to make a GET request to the ZORA API to retrieve coin data. It handles JSON unmarshalling and error checking.

```go
package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

const (
    APIKey  = "your-api-key-here"
    BaseURL = "https://api-sdk.zora.engineering/api"
)

func getCoin(address string, chain int) (map[string]interface{}, error) {
    url := fmt.Sprintf("%s/coin?address=%s&chain=%d", BaseURL, address, chain)

    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        return nil, err
    }

    req.Header.Set("api-key", APIKey)

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }

    var result map[string]interface{}
    err = json.Unmarshal(body, &result)
    return result, err
}
```

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

### Error Handling Examples

Source: https://docs.zora.co/coins/sdk/trade-coin

Illustrates common validation errors thrown by the SDK, such as invalid slippage values and zero amounts.

```APIDOC
## Error Handling

The function validates parameters and throws descriptive errors:

```typescript
// Invalid slippage (must be less than 1.0)
const invalidSlippage: TradeParameters = {
  // ... other parameters
  slippage: 1.5, // > 1.0
};
// Throws: "Slippage must be less than 1, max 0.99"

// Zero amount
const zeroAmount: TradeParameters = {
  // ... other parameters
  amountIn: BigInt(0),
};
// Throws: "Amount in must be greater than 0"
```
```

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

### Fetch User Created Coins Example

Source: https://docs.zora.co/coins/sdk/queries/profile

Demonstrates how to use the `getProfileCoins` function to retrieve and display details of coins created by a user. Ensure the SDK is imported before use.

```typescript
import { getProfileCoins } from "@zoralabs/coins-sdk";

async function fetchUserCreatedCoins() {
  const response = await getProfileCoins({
    identifier: "0xUserWalletAddress", // Can also be zora user profile handle
    count: 20, // Optional: number of coins per page
    after: undefined, // Optional: for pagination
  });

  const profile = response.data?.profile;

  if (profile?.createdCoins) {
    console.log(`Found ${profile.createdCoins.count} created coins`);

    profile.createdCoins.edges?.forEach((edge, index) => {
      const coin = edge.node;
      console.log(`Coin ${index + 1}:`);
      console.log("- Name:", coin.name);
      console.log("- Symbol:", coin.symbol);
      console.log("- Description:", coin.description);
      console.log("- Market Cap:", coin.marketCap);
      console.log("- Total Supply:", coin.totalSupply);
      console.log("- Unique Holders:", coin.uniqueHolders);

      if (coin.mediaContent?.previewImage?.medium) {
        console.log("- Image:", coin.mediaContent.previewImage.medium);
      }
    });
  } else {
    console.log("User has not created any coins");
  }

  return response;
}
```

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

### Paginate Explore Queries with getCoinsTopGainers

Source: https://docs.zora.co/coins/sdk/queries/explore

Demonstrates how to fetch all coins matching an explore query by implementing pagination. This example uses a do-while loop to repeatedly fetch data until no more results are available, updating the cursor with each request.

```typescript
import { getCoinsTopGainers } from "@zoralabs/coins-sdk";

async function fetchAllTopGainers() {
  let allCoins: any[] = [];
  let cursor = undefined;
  const pageSize = 20;
  
  // Continue fetching until no more pages
  do {
    const response = await getCoinsTopGainers({
      count: pageSize,
      after: cursor,
    });
    
    // Add coins to our collection
    if (response.data?.exploreList && response.data?.exploreList?.edges?.length || 0 > 0) {
      allCoins = [...allCoins, ...(response.data?.exploreList?.edges?.map((edge: any) => edge.node) || [])];
    }
    
    // Update cursor for next page
    cursor = response.data?.exploreList?.pageInfo?.endCursor;
    
    // Break if no more results
    if (!cursor || response.data?.exploreList?.edges?.length === 0) {
      break;
    }
    
  } while (true);
  
  console.log(`Fetched ${allCoins.length} total top gaining coins`);
  return allCoins;
}
```

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

### Paginate Through All User Coin Balances

Source: https://docs.zora.co/coins/sdk/queries/profile

This example demonstrates how to fetch all of a user's coin balances by repeatedly calling `getProfileBalances` until all pages are retrieved. It accumulates balances and updates the cursor for subsequent requests.

```typescript
import { getProfileBalances } from "@zoralabs/coins-sdk";

async function fetchAllUserBalances(userAddress: string) {
  let allBalances: any[] = [];
  let cursor = undefined;
  const pageSize = 20;

  // Continue fetching until no more pages
  do {
    const response = await getProfileBalances({
      identifier: userAddress, // UserAddress or zora handle
      count: pageSize,
      after: cursor,
    });

    const profile: any = response.data?.profile;

    // Add balances to our collection
    if (profile && profile.coinBalances) {
      allBalances = [
        ...allBalances,
        ...profile.coinBalances.edges.map((edge: any) => edge.node),
      ];
    }

    // Update cursor for next page
    cursor = profile?.coinBalances?.pageInfo?.endCursor;

    // Break if no more results
    if (!cursor || profile?.coinBalances?.edges?.length === 0) {
      break;
    }
  } while (true);

  console.log(`Fetched ${allBalances.length} total coin balances`);
  return allBalances;
}
```

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

### Deploy Creator Coin

Source: https://docs.zora.co/coins/contracts/creating-a-coin

A complete Solidity example demonstrating how to deploy a creator coin using the Zora Factory. Ensure you replace placeholder values like `hex"..."` with actual configuration bytes and metadata URIs.

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13; 

import {IZoraFactory} from "@zoralabs/coins/src/interfaces/IZoraFactory.sol";
import {CoinConfigurationVersions} from "@zoralabs/coins/src/libs/CoinConfigurationVersions.sol";

contract CoinDeployer {
    address constant FACTORY_ADDRESS = 0x777777751622c0d3258f214F9DF38E35BF45baF3;
    address constant ZORA_TOKEN_ADDRESS = 0x1111111111166b7FE7bd91427724B487980aFc69;
    
    function deployMyCoin() external returns (address coin) {
        IZoraFactory factory = IZoraFactory(FACTORY_ADDRESS);
        
        // Set up coin owners
        address[] memory owners = new address[](1);
        owners[0] = msg.sender;
        
        // Pool configuration bytes (get from Zora configuration API)
        bytes memory poolConfig = hex"..."; // Replace with actual configuration bytes
        
        // Generate unique salt for deterministic deployment
        bytes32 salt = keccak256(abi.encodePacked("MyCoin", msg.sender, block.timestamp));
        
        // Deploy the coin
        (coin, ) = factory.deploy(
            msg.sender,              // payoutRecipient - receives creator rewards
            owners,                  // owners - can update metadata/payout
            "ipfs://your-metadata-hash", // uri - metadata URI
            "My Creator Coin",       // name - full name
            "MYCOIN",                // symbol - trading symbol
            poolConfig,              // poolConfig - pool settings
            address(0),              // platformReferrer - no referrer
            address(0),              // postDeployHook - no post-deploy hook
            "",                      // postDeployHookData - empty
            salt                     // coinSalt - for deterministic address
        );
        
        return coin;
    }
}
```

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

### Get Profile Balances Parameters

Source: https://docs.zora.co/coins/sdk/queries/profile

Defines the parameters for fetching a user's coin balances. Requires the user's wallet address and supports pagination.

```typescript
type GetProfileBalancesParams = {
  address: string; // The user's wallet address
  after?: string; // Optional: Pagination cursor for fetching next page
  count?: number; // Optional: Number of balances to return per page
};
```

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

### Get Hook Version

Source: https://docs.zora.co/coins/contracts/hook-registry

Retrieves the version string of a specific registered hook address.

```solidity
function getHookVersion(address hook) external view returns (string memory);
```

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

### Quick Start: Fetch Zora Coins SDK Skill

Source: https://docs.zora.co/agents

Copy and paste this prompt into your agent's configuration to fetch and follow the Zora Coins SDK skill.

```text
Fetch and follow the Zora Coins SDK skill from https://docs.zora.co/skill.md
```

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

### High-Level Create Coin Transaction

Source: https://docs.zora.co/coins/sdk/create-coin

Example of using the `createCoin` function to deploy a new coin, send the transaction, and wait for the receipt. Requires configured viem clients and coin creation arguments.

```typescript
import {
  createCoin,
  CreateConstants,
  ContentCoinCurrency,
} from "@zoralabs/coins-sdk";
import {
  Hex,
  Address,
  createWalletClient,
  createPublicClient,
  http,
} from "viem";
import { base } from "viem/chains";

const publicClient = createPublicClient({
  chain: base,
  transport: http("<RPC_URL>"),
});

const walletClient = createWalletClient({
  account: "0x<YOUR_ACCOUNT>" as Hex,
  chain: base,
  transport: http("<RPC_URL>"),
});

const args = {
  creator: "0xYourAddress" as Address,
  name: "My Awesome Coin",
  symbol: "MAC",
  metadata: { type: "RAW_URI" as const, uri: "ipfs://bafy..." },
  currency: CreateConstants.ContentCoinCurrencies.ZORA,
  chainId: base.id,
  startingMarketCap: CreateConstants.StartingMarketCaps.LOW,
  platformReferrerAddress: "0xOptionalReferrer" as Address,
};

const result = await createCoin({
  call: args,
  walletClient,
  publicClient,
  options: {
    // account: optional override
    // skipValidateTransaction: false by default
  },
});

console.log("Transaction hash:", result.hash);
console.log("Coin address:", result.address);
console.log("Deployment details:", result.deployment);
console.log("Chain info:", result.chain);
```

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

### Error Handling Examples

Source: https://docs.zora.co/coins/sdk/trade-coin

Demonstrates how the SDK validates parameters and throws descriptive errors for invalid inputs like slippage or zero amounts. Ensure proper try-catch blocks are used to handle these exceptions.

```typescript
// Invalid slippage (must be less than 1.0)
const invalidSlippage: TradeParameters = {
  // ... other parameters
  slippage: 1.5, // > 1.0
};
// Throws: "Slippage must be less than 1, max 0.99"

// Zero amount
const zeroAmount: TradeParameters = {
  // ... other parameters
  amountIn: BigInt(0),
};
// Throws: "Amount in must be greater than 0"

```

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

### Get Profile Coins Parameters

Source: https://docs.zora.co/coins/sdk/queries/profile

Defines the parameters for fetching coins created by a user. Supports filtering by chain and referrer, and pagination.

```typescript
type GetProfileCoinsParams = {
  identifier: string; // The user's wallet address or zora handle
  count?: number; // Optional: Number of coins to return per page (default: 20)
  after?: string; // Optional: Pagination cursor for fetching next page
  chainIds?: Array<number>; // Optional: Filter by specific chain IDs
  platformReferrerAddress?: Array<string>; // Optional: Filter by platform referrer addresses
};
```

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

### Get Coin Data with Ruby SDK

Source: https://docs.zora.co/coins/sdk/public-rest-api

This Ruby script demonstrates fetching coin data using the 'net/http' and 'json' libraries. It constructs the request and parses the JSON response.

```ruby
require 'net/http'
require 'json'
require 'uri'

API_KEY = 'your-api-key-here'
BASE_URL = 'https://api-sdk.zora.engineering/api'

def get_coin(address, chain = 8453)
  uri = URI("#{BASE_URL}/coin")
  uri.query = URI.encode_www_form(address: address, chain: chain)

  request = Net::HTTP::Get.new(uri)
  request['api-key'] = API_KEY

  response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
    http.request(request)
  end

  JSON.parse(response.body)
end

coin_data = get_coin('0xCoinContractAddress')
puts coin_data
```

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

### Trading Between ERC20 Tokens

Source: https://docs.zora.co/coins/sdk/trade-coin

Example for trading between two ERC20 tokens, such as USDC and a Creator Coin, utilizing permit signatures.

```APIDOC
import { TradeParameters, tradeCoin } from "@zoralabs/coins-sdk";

const tradeParameters: TradeParameters = {
  sell: {
    type: "erc20",
    address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", // USDC
  },
  buy: {
    type: "erc20",
    address: "0x9b13358e3a023507e7046c18f508a958cda75f54", // @jacob Creator Coin
  },
  amountIn: BigInt(4 * 10 ** 6), // 4 USDC (6 decimals)
  slippage: 0.04, // 4% slippage
  sender: account.address,
};

const receipt = await tradeCoin({
  tradeParameters,
  walletClient,
  account,
  publicClient,
});
```

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

### Get Profile Balances via REST API

Source: https://docs.zora.co/coins/sdk/public-rest-api

Retrieve a user's profile balances by specifying their wallet address in the 'identifier' query parameter.

```bash
# Get profile balances
curl -H "api-key: your-api-key-here" \
  "https://api-sdk.zora.engineering/profile?identifier=0xUserAddress"
```

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

### Get Hook Tag

Source: https://docs.zora.co/coins/contracts/hook-registry

Retrieves the tag associated with a specific registered hook address.

```solidity
function getHookTag(address hook) external view returns (string memory);
```

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

### Get All Registered Hook Addresses

Source: https://docs.zora.co/coins/contracts/hook-registry

Retrieves an array containing only the addresses of all registered hooks.

```solidity
function getHookAddresses() external view returns (address[] memory);
```

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

### Get All Registered Hooks

Source: https://docs.zora.co/coins/contracts/hook-registry

Retrieves an array of all registered Zora hooks, including their addresses, tags, and versions.

```solidity
function getHooks() external view returns (ZoraHook[] memory);
```

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

### Get Profile Balances

Source: https://docs.zora.co/coins/sdk/public-rest-api

Access user or wallet information, including their holdings and activity. Requires a user identifier.

```APIDOC
## GET /profile

### Description
Retrieves information about a user's profile, including their coin holdings and transaction activity.

### Method
GET

### Endpoint
/profile

### Query Parameters
- **identifier** (string) - Required - The user's wallet address or unique identifier.
```

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

### Metadata Builder Usage

Source: https://docs.zora.co/coins/sdk/create-coin

Demonstrates how to use the Metadata Builder to create coin metadata, including uploading an image, and obtaining parameters suitable for the `createCoin` function.

```typescript
import { Address } from "viem";
import {
  createMetadataBuilder,
  createZoraUploaderForCreator,
} from "@zoralabs/coins-sdk";

const creatorAddress = "0xYourAddress" as Address;

const { createMetadataParameters } = await createMetadataBuilder()
  .withName("Test ZORA Coin")
  .withSymbol("TZC")
  .withDescription("Test Description")
  .withImage(new File(["FILE"], "test.png", { type: "image/png" }))
  .upload(createZoraUploaderForCreator(creatorAddress));

// createMetadataParameters can be used to spread in the createCoin call to handle metadata (name, symbol, and uri)
```

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

### Fetch Recently Traded Coins with getCoinsLastTraded

Source: https://docs.zora.co/coins/sdk/queries/explore

Use `getCoinsLastTraded` to get coins that have been traded most recently. Supports pagination and count limits.

```typescript
import { getCoinsLastTraded } from "@zoralabs/coins-sdk";

async function fetchLastTradedCoins() {
  const response = await getCoinsLastTraded({
    count: 10,        // Optional: number of coins per page
    after: undefined, // Optional: for pagination
  });
  
  console.log(`Recently Traded Coins (${response.data?.exploreList?.edges?.length || 0} coins):`);
  
  response.data?.exploreList?.edges?.forEach((coin: any, index: number) => {
    console.log(`${index + 1}. ${coin.node.name} (${coin.node.symbol})`);
    console.log(`   Market Cap: ${coin.node.marketCap}`);
    console.log(`   Volume 24h: ${coin.node.volume24h}`);
    console.log('-----------------------------------');
  });
  
  // For pagination
  if (response.data?.exploreList?.pageInfo?.endCursor) {
    console.log("Next page cursor:", response.data?.exploreList?.pageInfo?.endCursor);
  }
  
  return response;
}
```

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

### Paginating Through All Balances

Source: https://docs.zora.co/coins/sdk/queries/profile

Demonstrates how to paginate through all of a user's coin balances when they hold a large number of coins.

```APIDOC
## fetchAllUserBalances

### Description
Iteratively fetches all coin balances for a user by handling pagination.

### Method
SDK Function

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
`fetchAllUserBalances` accepts the following parameters:
- **userAddress** (string) - The wallet address or Zora handle of the user whose balances are to be fetched.

### Request Example
```javascript
import { getProfileBalances } from "@zoralabs/coins-sdk";

async function fetchAllUserBalances(userAddress: string) {
  let allBalances: any[] = [];
  let cursor = undefined;
  const pageSize = 20;

  // Continue fetching until no more pages
  do {
    const response = await getProfileBalances({
      identifier: userAddress, // UserAddress or zora handle
      count: pageSize,
      after: cursor,
    });

    const profile: any = response.data?.profile;

    // Add balances to our collection
    if (profile && profile.coinBalances) {
      allBalances = [
        ...allBalances,
        ...profile.coinBalances.edges.map((edge: any) => edge.node),
      ];
    }

    // Update cursor for next page
    cursor = profile?.coinBalances?.pageInfo?.endCursor;

    // Break if no more results
    if (!cursor || profile?.coinBalances?.edges?.length === 0) {
      break;
    }
  } while (true);

  console.log(`Fetched ${allBalances.length} total coin balances`);
  return allBalances;
}
```

### Response
#### Success Response (200)
Returns an array containing all of the user's coin balances.
- **allBalances** (array) - An array of objects, where each object represents a coin balance.

#### Response Example
```json
[
  {
    "id": "balance-id-1",
    "token": {
      "id": "token-id-1",
      "name": "Example Coin",
      "symbol": "EXC",
      "address": "0xTokenAddress",
      "chainId": 1,
      "totalSupply": "1000000000000000000",
      "marketCap": "1000000000",
      "volume24h": "1000000",
      "createdAt": "2023-01-01T00:00:00Z",
      "uniqueHolders": 10000,
      "media": {
        "previewImage": "https://example.com/image.png"
      }
    },
    "amount": {
      "amountRaw": "1000000000000000000",
      "amountDecimal": 1
    },
    "valueUsd": "1000",
    "timestamp": "2023-10-27T10:00:00Z"
  },
  {
    "id": "balance-id-2",
    "token": {
      "id": "token-id-2",
      "name": "Another Coin",
      "symbol": "ANC",
      "address": "0xAnotherTokenAddress",
      "chainId": 1,
      "totalSupply": "21000000000000000000",
      "marketCap": "21000000000",
      "volume24h": "2000000",
      "createdAt": "2023-02-15T00:00:00Z",
      "uniqueHolders": 20000,
      "media": {
        "previewImage": "https://example.com/another_image.png"
      }
    },
    "amount": {
      "amountRaw": "5000000000000000000",
      "amountDecimal": 5
    },
    "valueUsd": "5000",
    "timestamp": "2023-10-27T10:05:00Z"
  }
]
```
```

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

### Create a coin with metadata upload

Source: https://docs.zora.co/skill.md

Builds and uploads metadata before deploying the coin contract and verifying the result.

```ts
// 1. Build and upload metadata
const { createMetadataParameters } = await createMetadataBuilder()
  .withName("My Coin")
  .withSymbol("MC")
  .withDescription("A coin")
  .withImage(imageFile)
  .upload(createZoraUploaderForCreator(creatorAddress));

// 2. Create the coin (spreads name, symbol, uri from metadata)
const result = await createCoin({
  call: {
    ...createMetadataParameters,
    creator: creatorAddress,
    currency: "ZORA",
    chainId: 8453,
  },
  walletClient,
  publicClient,
});

// 3. Verify deployment
const coin = await getCoin({ address: result.address });
```

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

### Deploy Function for Creating Coins with Platform Referrer

Source: https://docs.zora.co/coins/contracts/rewards

This Solidity function signature shows how to specify the `platformReferrer` address during coin creation via the factory's deploy function. This address receives a percentage of all trading fees.

```solidity
function deploy(
  address payoutRecipient,
  address[] memory owners,
  string memory uri,
  string memory name,
  string memory symbol,
  bytes memory poolConfig,
  address platformReferrer, // This is the platform referral
  address postDeployHook,
  bytes calldata postDeployHookData,
  bytes32 coinSalt
) external payable returns (address coin, bytes memory postDeployHookDataOut);
```

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

### Get Coin Holders with Zora SDK

Source: https://docs.zora.co/coins/sdk/queries/coin

Retrieves a list of addresses holding a specific coin, along with their balances and profile information. Supports pagination.

```typescript
import { getCoinHolders } from "@zoralabs/coins-sdk";
 
const response = await getCoinHolders({
  chainId: 8453, // Base mainnet
  address: "0x1234567890123456789012345678901234567890",
  count: 20, // Get first 20 holders
});
 
if (response.data?.zora20Token?.tokenBalances) {
  const holders = response.data.zora20Token.tokenBalances.edges;
  console.log(`Found ${holders.length} holders`);
 
  holders.forEach(({ node }) => {
    console.log(`Address: ${node.ownerAddress}`);
    console.log(`Balance: ${node.balance}`);
    console.log(`Profile: ${node.ownerProfile?.handle || "No profile"}`);
  });
}
```

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

### How Permits Work

Source: https://docs.zora.co/coins/sdk/trade-coin

Explains the automatic permit generation and signing process for ERC20 token trades using the EIP-2612 standard, enabling gasless approvals.

```APIDOC
## How Permits Work

When trading ERC20 tokens, `tradeCoin` automatically:
  1. **Checks existing allowances** for the token being sold
  2. **Requests approval** if insufficient allowance exists
  3. **Generates permit signatures** using EIP-2612 standard
  4. **Signs typed data** with your EOA for secure, gasless approvals
  5. **Includes permits** in the trade transaction

This eliminates the need for separate approval transactions while maintaining security.
```

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

### Get Profile Balances

Source: https://docs.zora.co/coins/sdk/queries/profile

Fetches a user's coin balances. This function can be used to retrieve a paginated list of coin balances for a given user identifier.

```APIDOC
## getProfileBalances

### Description
Fetches a paginated list of coin balances for a given user identifier.

### Method
SDK Function

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
`getProfileBalances` accepts an object with the following properties:
- **identifier** (string) - Required - The user's wallet address or Zora profile handle.
- **count** (number) - Optional - The number of balances to retrieve per page. Defaults to 20.
- **after** (string | undefined) - Optional - A cursor for pagination, used to fetch the next page of results.

### Request Example
```javascript
import { getProfileBalances } from "@zoralabs/coins-sdk";

async function fetchUserBalances() {
  const response = await getProfileBalances({
    identifier: "0xUserWalletAddress", // Can also be zora user profile handle
    count: 20, // Optional: number of balances per page
    after: undefined, // Optional: for pagination
  });

  const profile: any = response.data?.profile;

  console.log(`Found ${profile.coinBalances?.length || 0} coin balances`);

  profile.coinBalances?.forEach((balance: any, index: number) => {
    console.log(balance);
  });

  // For pagination
  if (profile.coinBalances?.pageInfo?.endCursor) {
    console.log("Next page cursor:", profile.coinBalances?.pageInfo?.endCursor);
  }

  return response;
}
```

### Response
#### Success Response (200)
The response contains profile data, including coin balances and pagination information.
- **data** (object) - Contains the profile and pagination details.
  - **profile** (object) - User's profile information.
    - **coinBalances** (object) - An object containing coin balance data and pagination info.
      - **edges** (array) - An array of balance edges.
        - **node** (object) - Represents a single coin balance.
      - **pageInfo** (object) - Pagination details.
        - **endCursor** (string) - The cursor for the next page.

#### Response Example
```json
{
  "data": {
    "profile": {
      "coinBalances": {
        "edges": [
          {
            "node": {
              "id": "balance-id-1",
              "token": {
                "id": "token-id-1",
                "name": "Example Coin",
                "symbol": "EXC",
                "address": "0xTokenAddress",
                "chainId": 1,
                "totalSupply": "1000000000000000000",
                "marketCap": "1000000000",
                "volume24h": "1000000",
                "createdAt": "2023-01-01T00:00:00Z",
                "uniqueHolders": 10000,
                "media": {
                  "previewImage": "https://example.com/image.png"
                }
              },
              "amount": {
                "amountRaw": "1000000000000000000",
                "amountDecimal": 1
              },
              "valueUsd": "1000",
              "timestamp": "2023-10-27T10:00:00Z"
            }
          }
        ],
        "pageInfo": {
          "endCursor": "next-page-cursor-string"
        }
      }
    }
  }
}
```
```

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

### Get Coin Information

Source: https://docs.zora.co/coins/sdk/public-rest-api

Retrieve information about a specific coin, including metadata and market data. Requires the coin's contract address and chain ID.

```APIDOC
## GET /coin

### Description
Retrieves detailed information about a specific coin, including its metadata and market data.

### Method
GET

### Endpoint
/coin

### Query Parameters
- **address** (string) - Required - The contract address of the coin.
- **chain** (integer) - Required - The ID of the blockchain network the coin is on.
```

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

### Create and Upload Metadata with SDK

Source: https://docs.zora.co/coins/sdk/metadata-builder

Use the `createMetadataBuilder` to construct metadata parameters, including name, symbol, description, and image. The `upload` method, using `createZoraUploaderForCreator`, handles the IPFS upload. The resulting metadata can be directly used with ZORA's create coin APIs.

```typescript
import { createMetadataBuilder, createZoraUploaderForCreator } from "@zoralabs/coins-sdk";
import { Address } from "viem";

const creatorAddress = "0x17cd072cBd45031EFc21Da538c783E0ed3b25DCc";

const { createMetadataParameters } = await createMetadataBuilder()
  .withName("Test Base ZORA Coin")
  .withSymbol("TBZC")
  .withDescription("Test Description")
  .withImage(
    new File([/* data for png as bytes or file from user */ ""], "test.png", { type: "image/png" }),
  )
  .upload(createZoraUploaderForCreator(creatorAddress as Address));

// Use this directly with the create coin APIs:
// metadata: createMetadataParameters.metadata
const metadata = createMetadataParameters.metadata;
```

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

### Update Coin URI Parameters

Source: https://docs.zora.co/coins/sdk/update-coin

Defines the arguments required for updating a coin's metadata URI. The new URI must start with 'ipfs://'.

```typescript
import { Address } from "viem";
 
type UpdateCoinURIArgs = {
  coin: Address;    // The coin contract address
  newURI: string;   // The new URI for the coin metadata (must start with "ipfs://")
};

```

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

### Low-level: Integrate with WAGMI using a raw transaction

Source: https://docs.zora.co/coins/sdk/create-coin

Use `createCoinCall` to get transaction parameters for sending via WAGMI's `useSendTransaction` and predict the coin address.

```APIDOC
## Low-level: Integrate with WAGMI using a raw transaction

### Description
`createCoinCall` returns an object with transaction parameters and the predicted coin address. This allows for immediate UI updates or address storage before the transaction is confirmed.

### Type Definition
```typescript
type CreateCoinCallResponse = {
  calls: Array<{
    to: Address; // Target contract address (coin factory)
    data: Hex; // Encoded function call data
    value: bigint; // ETH value to send (typically 0n for coin creation)
  }>;
  predictedCoinAddress: Address; // Deterministic address where coin will be deployed
};
```

### Usage Example
```javascript
import * as React from "react";
import { createCoinCall, CreateConstants } from "@zoralabs/coins-sdk";
import { Address } from "viem";
import { useSendTransaction } from "wagmi";
import { base } from "viem/chains";
 
function CreateCoinButton() {
  const { sendTransaction, status } = useSendTransaction();
  const [coinAddress, setCoinAddress] = React.useState<Address | null>(null);
 
  const handleCreate = async () => {
    const args = {
      creator: "0xYourAddress" as Address,
      name: "My Awesome Coin",
      symbol: "MAC",
      metadata: { type: "RAW_URI" as const, uri: "ipfs://bafy..." },
      currency: CreateConstants.ContentCoinCurrencies.ZORA,
      chainId: base.id,
      startingMarketCap: CreateConstants.StartingMarketCaps.LOW,
    };
 
    const { calls, predictedCoinAddress } = await createCoinCall(args);
 
    // Store predicted address immediately for UI updates
    setCoinAddress(predictedCoinAddress);
    console.log("Coin will be deployed at:", predictedCoinAddress);
 
    // Send transaction with the first call parameters
    sendTransaction({
      to: calls[0].to,
      data: calls[0].data,
      value: calls[0].value,
    });
  };
 
  return (
    <div>
      <button disabled={status === "pending"} onClick={handleCreate}>
        {status === "pending" ? "Creating..." : "Create Coin"}
      </button>
      {coinAddress && <p>Coin address: {coinAddress}</p>}
    </div>
  );
}
```
```

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

### Trading USDC for Creator Coin (with Permits)

Source: https://docs.zora.co/coins/sdk/trade-coin

Demonstrates trading USDC for a Creator Coin, leveraging permit signatures for secure, gasless approvals.

```APIDOC
import { TradeParameters, tradeCoin } from "@zoralabs/coins-sdk";

const tradeParameters: TradeParameters = {
  sell: {
    type: "erc20",
    address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", // USDC address
  },
  buy: {
    type: "erc20", 
    address: "0x9b13358e3a023507e7046c18f508a958cda75f54", // @jacob Creator Coin
  },
  amountIn: BigInt(4 * 10 ** 6), // 4 USDC (6 decimals)
  slippage: 0.05, // 5% slippage
  sender: account.address,
};

const receipt = await tradeCoin({
  tradeParameters,
  walletClient,
  account,
  publicClient,
});
```

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

### Deploy Function for New Coin Deployments

Source: https://docs.zora.co/coins/contracts/creating-a-coin

Use the `deploy` function for new deployments when integrating directly with contracts. This method supports deterministic addressing and post-deployment hooks. The `msg.sender` that calls this function is considered the creator of the coin.

```Solidity
function deploy(
    address payoutRecipient,
    address[] memory owners,
    string memory uri,
    string memory name,
    string memory symbol,
    bytes memory poolConfig,
    address platformReferrer,
    address postDeployHook,
    bytes calldata postDeployHookData,
    bytes32 coinSalt
) external payable returns (address coin, bytes memory postDeployHookDataOut);
```

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

### Get Coin Comments with Zora SDK

Source: https://docs.zora.co/coins/sdk/queries/coin

Retrieves comments associated with a specific coin, including author, text, and replies. Supports pagination and defaults to Base chain.

```typescript
import { getCoinComments } from "@zoralabs/coins-sdk";
import { Address } from "viem";
 
export async function fetchCoinComments() {
  const response = await getCoinComments({
    address: "0xCoinContractAddress" as Address,
    chain: 8453, // Optional: Base chain
    after: undefined, // Optional: for pagination
    count: 20, // Optional: number of comments per page
  });
 
  // Process comments
  console.log(
    `Found ${response.data?.zora20Token?.zoraComments?.edges?.length || 0} comments`,
  );
 
  response.data?.zora20Token?.zoraComments?.edges?.forEach(
    (edge, index: number) => {
      console.log(`Comment ${index + 1}:`);
      console.log(
        `- Author: ${edge.node?.userProfile?.handle || edge.node?.userAddress}`,
      );
      console.log(`- Text: ${edge.node?.comment}`);
      console.log(`- Created At: ${edge.node?.timestamp}`);
 
      edge.node?.replies?.edges?.forEach((reply: any) => {
        console.log(`- Reply: ${reply.node.text}`);
      });
 
      console.log("-----------------------------------");
    },
  );
 
  // For pagination
  if (response.data?.zora20Token?.zoraComments?.pageInfo?.endCursor) {
    console.log(
      "Next page cursor:",
      response.data?.zora20Token?.zoraComments?.pageInfo?.endCursor,
    );
  }
 
  return response;
}
```

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

### Deploy Function (Direct Contract Integration)

Source: https://docs.zora.co/coins/contracts/creating-a-coin

Use the `deploy` function for new deployments when integrating directly with contracts. This method supports deterministic addressing and post-deployment hooks. The `msg.sender` that calls the deployment function is considered the creator of the coin.

```APIDOC
## deploy

### Description
Deploys a new coin with specified parameters, supporting deterministic addressing and post-deployment hooks.

### Method
`deploy`

### Parameters
- `payoutRecipient` (address) - Required - Address that receives creator rewards from trading activity.
- `owners` (address[]) - Required - Array of addresses with permission to manage the coin.
- `uri` (string) - Required - Metadata URI for the coin (e.g., IPFS URL).
- `name` (string) - Required - Human-readable name of the coin.
- `symbol` (string) - Required - Trading symbol for the coin (e.g., "MYCOIN").
- `poolConfig` (bytes) - Required - Encoded configuration determining coin version and pool parameters.
- `platformReferrer` (address) - Required - Address that receives platform referral rewards (use `address(0)` if none).
- `postDeployHook` (address) - Optional - Contract address to call after deployment (use `address(0)` if none).
- `postDeployHookData` (bytes) - Optional - Data to pass to the post-deployment hook (use empty bytes if none).
- `coinSalt` (bytes32) - Required - Salt for deterministic deployment (enables predictable addresses).

### Returns
- `coin` (address) - The address of the newly deployed coin.
- `postDeployHookDataOut` (bytes) - Output data from the post-deployment hook.
```

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

### Get Coin Information via REST API

Source: https://docs.zora.co/coins/sdk/public-rest-api

Use this cURL command to retrieve detailed information about a specific coin by providing its contract address and chain ID.

```bash
# Get coin information
curl -H "api-key: your-api-key-here" \
  "https://api-sdk.zora.engineering/coin?address=0xCoinContractAddress&chain=8453"
```

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

### Import tradeCoin and TradeParameters

Source: https://docs.zora.co/coins/sdk/trade-coin

Import the necessary functions and types for trading coins.

```typescript
import { tradeCoin, TradeParameters } from "@zoralabs/coins-sdk";
```
Tokens:
Raw