Docs update for coins SDK (#1461)

* Docs update for coins SDK

* docs re-update

Author: iainnash

docs/pages/coins/sdk/create-coin.mdx

@@ -1,6 +1,6 @@
 ### Creating Coins
 
-The Coins SDK provides functions to create new coins on the Zora protocol. 
+The Coins SDK provides functions to create new coins on the Zora protocol.
 
 ### Overview
 
@@ -10,25 +10,29 @@ Creating a coin involves generating calldata through the SDK and sending a trans
 
 ```ts
 import { Address } from "viem";
-import { CreateConstants, ContentCoinCurrency, StartingMarketCap } from "@zoralabs/coins-sdk";
+import {
+  CreateConstants,
+  ContentCoinCurrency,
+  StartingMarketCap,
+} from "@zoralabs/coins-sdk";
 
 type MetadataType = {
   type: "RAW_URI";
   uri: string; // e.g., an IPFS URI
 };
 
 type CreateCoinArgs = {
-  creator: Address;                // Creator address
-  name: string;                    // Coin name (e.g., "My Awesome Coin")
-  symbol: string;                  // Ticker (e.g., "MAC")
-  metadata: MetadataType;          // Metadata descriptor
-  currency: ContentCoinCurrency;          // CREATOR_COIN | CREATOR_COIN_OR_ZORA | ZORA | ETH
-  chainId?: number;                 // Chain ID to deploy on (defaults to Base mainnet `8453`)
+  creator: Address; // Creator address
+  name: string; // Coin name (e.g., "My Awesome Coin")
+  symbol: string; // Ticker (e.g., "MAC")
+  metadata: MetadataType; // Metadata descriptor
+  currency: ContentCoinCurrency; // CREATOR_COIN | CREATOR_COIN_OR_ZORA | ZORA | ETH
+  chainId?: number; // Chain ID to deploy on (defaults to Base mainnet `8453`)
   startingMarketCap?: StartingMarketCap; // LOW | HIGH (defaults to LOW)
-  platformReferrer?: Address;    // Optional referral address
+  platformReferrer?: Address; // Optional referral address
   additionalOwners?: Address[];
   payoutRecipientOverride?: Address;
-  skipMetadataValidation?: boolean;     // Skip URI validation (not recommended)
+  skipMetadataValidation?: boolean; // Skip URI validation (not recommended)
 };
 ```
 
@@ -39,7 +43,10 @@ type CreateCoinArgs = {
 
 ```ts twoslash
 import { Address } from "viem";
-import { createMetadataBuilder, createZoraUploaderForCreator } from "@zoralabs/coins-sdk";
+import {
+  createMetadataBuilder,
+  createZoraUploaderForCreator,
+} from "@zoralabs/coins-sdk";
 
 const creatorAddress = "0xYourAddress" as Address;
 
@@ -80,8 +87,18 @@ Provide the exact `chainId` you intend to deploy on (e.g., Base mainnet `8453`).
 #### High‑level: send transaction and wait for receipt
 
 ```ts twoslash
-import { createCoin, CreateConstants, ContentCoinCurrency } from "@zoralabs/coins-sdk";
-import { Hex, Address, createWalletClient, createPublicClient, http } from "viem";
+import {
+  createCoin,
+  CreateConstants,
+  ContentCoinCurrency,
+} from "@zoralabs/coins-sdk";
+import {
+  Hex,
+  Address,
+  createWalletClient,
+  createPublicClient,
+  http,
+} from "viem";
 import { base } from "viem/chains";
 
 const publicClient = createPublicClient({
@@ -119,11 +136,53 @@ const result = await createCoin({
 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 Structure
+
+The `createCoin` function returns an object with the following properties:
+
+```ts
+type CreateCoinResult = {
+  hash: string; // Transaction hash
+  receipt: TransactionReceipt; // Full transaction receipt from the blockchain
+  address?: string; // Deployed coin contract address (extracted from logs)
+  deployment?: {
+    // Detailed deployment information from CoinCreatedV4 event
+    coin: string; // Coin contract address
+    creator: string; // Creator address
+    poolAddress: string; // Uniswap pool address
+    // ... additional deployment details
+  };
+  chain: Chain; // Chain object (e.g., base, baseSepolia)
+};
+```
+
+**Key Fields:**
+
+- `address`: The newly deployed coin's contract address - use this to interact with the coin
+- `hash`: Transaction hash for tracking the deployment transaction
+- `receipt`: Full transaction receipt containing all logs and events
+- `deployment`: Complete deployment details parsed from the `CoinCreatedV4` event, including pool information
+- `chain`: Chain configuration object for the network where the coin was deployed
+
 #### Low‑level: integrate with WAGMI using a raw transaction
 
-`createCoinCall` returns `{ to, data, value }`, which can be passed to your tx‑sending flow (e.g., WAGMI `useSendTransaction`).
+`createCoinCall` returns an object with transaction parameters and the predicted coin address:
+
+```ts
+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
+};
+```
+
+The `calls` array contains the transaction parameters that can be passed to your tx‑sending flow (e.g., WAGMI `useSendTransaction`). The `predictedCoinAddress` provides the coin's address before the transaction is sent, allowing immediate UI updates or address storage.
 
 ```tsx
 import * as React from "react";
@@ -132,28 +191,42 @@ import { Address } from "viem";
 import { useSendTransaction } from "wagmi";
 import { base } from "viem/chains";
 
-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 txCalls = await createCoinCall(args);
-
 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 (
-    <button
-      disabled={status === "pending"}
-      onClick={() => sendTransaction({ to: txCalls[0].to, data: txCalls[0].data, value: txCalls[0].value })}
-    >
-      {status === "pending" ? "Creating..." : "Create Coin"}
-    </button>
+    <div>
+      <button disabled={status === "pending"} onClick={handleCreate}>
+        {status === "pending" ? "Creating..." : "Create Coin"}
+      </button>
+      {coinAddress && <p>Coin address: {coinAddress}</p>}
+    </div>
   );
 }
 ```
@@ -184,4 +257,4 @@ console.log("Deployed coin address:", coinDeployment?.coin);
 
 ### More Information
 
-See [Creating a Coin](/coins/contracts/creating-a-coin) and [Contract Architecture](/coins/contracts/architecture) for protocol‑level details.
+See [Creating a Coin](/coins/contracts/creating-a-coin) and [Contract Architecture](/coins/contracts/architecture) for protocol‑level details.

docs/pages/coins/sdk/queries/coin.mdx

@@ -12,8 +12,8 @@ The `getCoin` function retrieves detailed information about a specific coin, inc
 
 ```ts twoslash
 type GetCoinParams = {
-  address: string;   // The coin contract address
-  chain?: number;    // Optional: The chain ID (defaults to Base: 8453)
+  address: string; // The coin contract address
+  chain?: number; // Optional: The chain ID (defaults to Base: 8453)
 };
 ```
 
@@ -32,17 +32,25 @@ import { GetCoinResponse } from "@zoralabs/coins-sdk";
 
 // The Zora20Token type is imported from the SDK's generated types.
 // It includes detailed information about a specific coin, such as its metadata, market data, and creator information.
-type Zora20Token = GetCoinResponse['zora20Token'];
+type Zora20Token = GetCoinResponse["zora20Token"];
 //    ^?
 
-
-
-
-
 //
-
 ```
 
+**Key Response Fields:**
+
+- `platformBlocked`: Boolean indicating whether the coin is blocked on the platform (most applications should exclude blocked coins from visibility)
+- `creatorProfile.platformBlocked`: Boolean indicating whether the creator's profile is blocked on the platform (most applications should exclude blocked profiles from visibility)
+- `address`: The coin's contract address
+- `name`, `symbol`: Coin identification
+- `marketCap`, `totalSupply`, `volume24h`: Market metrics
+- `tokenPrice`: Pricing information in USDC and pool token
+- `creatorProfile`: Profile information for the coin creator, including social accounts and avatar
+- `mediaContent`: Associated media like images or videos
+- `uniqueHolders`: Number of unique token holders
+- `uniswapV4PoolKey`: Uniswap V4 pool configuration details
+
 ### getCoins
 
 The `getCoins` function retrieves information about multiple coins at once, useful for batch processing or displaying multiple coins.
@@ -54,7 +62,7 @@ type GetCoinsParams = {
   coins: {
     collectionAddress: string;
     chainId: number;
-  }[]
+  }[];
 };
 ```
 
@@ -76,10 +84,10 @@ The `getCoinHolders` function retrieves information about who holds a specific c
 
 ```ts twoslash
 type GetCoinHoldersParams = {
-  chainId: number;    // The chain ID
-  address: string;    // The coin contract address
-  after?: string;     // Optional: Pagination cursor for fetching next page
-  count?: number;     // Optional: Number of holders to return per page
+  chainId: number; // The chain ID
+  address: string; // The coin contract address
+  after?: string; // Optional: Pagination cursor for fetching next page
+  count?: number; // Optional: Number of holders to return per page
 };
 ```
 
@@ -97,11 +105,11 @@ const response = await getCoinHolders({
 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'}`);
+    console.log(`Profile: ${node.ownerProfile?.handle || "No profile"}`);
   });
 }
 ```
@@ -118,10 +126,10 @@ The `getCoinSwaps` function retrieves swap activities for a specific coin, showi
 
 ```ts twoslash
 type GetCoinSwapsParams = {
-  address: string;    // The coin contract address
-  chain?: number;     // Optional: The chain ID (defaults to Base: 8453)
-  after?: string;     // Optional: Pagination cursor for fetching next page
-  first?: number;     // Optional: Number of swaps to return per page
+  address: string; // The coin contract address
+  chain?: number; // Optional: The chain ID (defaults to Base: 8453)
+  after?: string; // Optional: Pagination cursor for fetching next page
+  first?: number; // Optional: Number of swaps to return per page
 };
 ```
 
@@ -139,7 +147,7 @@ const response = await getCoinSwaps({
 if (response.data?.zora20Token?.swapActivities) {
   const swaps = response.data.zora20Token.swapActivities.edges;
   console.log(`Found ${swaps.length} swaps`);
-  
+
   swaps.forEach(({ node }) => {
     console.log(`Activity: ${node.activityType}`); // "BUY" or "SELL"
     console.log(`Amount: ${node.coinAmount}`);
@@ -161,10 +169,10 @@ The `getCoinComments` function retrieves comments associated with a specific coi
 
 ```ts twoslash
 type GetCoinCommentsParams = {
-  address: string;    // The coin contract address
-  chain?: number;     // Optional: The chain ID (defaults to Base: 8453)
-  after?: string;     // Optional: Pagination cursor for fetching next page
-  count?: number;     // Optional: Number of comments to return per page
+  address: string; // The coin contract address
+  chain?: number; // Optional: The chain ID (defaults to Base: 8453)
+  after?: string; // Optional: Pagination cursor for fetching next page
+  count?: number; // Optional: Number of comments to return per page
 };
 ```
 
@@ -186,7 +194,6 @@ To fetch all comments for a coin, you can use pagination:
 
 The response includes a `comments` array and pagination information:
 
-
 ## Error Handling
 
 All query functions follow the same error handling pattern. When an error occurs, the promise is rejected with an error object that includes details about what went wrong.