@zoralabs/coins-sdk 0.2.10 → 0.3.0

package/src/actions/createCoin.ts

@@ -1,138 +1,113 @@
-import { coinFactoryABI as zoraFactoryImplABI } from "@zoralabs/protocol-deployments";
+import {
+  coinFactoryAddress,
+  coinFactoryABI as zoraFactoryImplABI,
+} from "@zoralabs/protocol-deployments";
 import {
   Address,
   TransactionReceipt,
   WalletClient,
-  SimulateContractParameters,
   ContractEventArgsFromTopics,
   parseEventLogs,
-  zeroAddress,
-  keccak256,
-  toBytes,
   Hex,
   Account,
+  isAddressEqual,
 } from "viem";
-import { base, baseSepolia } from "viem/chains";
-import { COIN_FACTORY_ADDRESS } from "../constants";
+import { base } from "viem/chains";
 import { validateClientNetwork } from "../utils/validateClientNetwork";
 import { GenericPublicClient } from "../utils/genericPublicClient";
 import { validateMetadataURIContent } from "../metadata";
 import { ValidMetadataURI } from "../uploader/types";
-import { getAttribution } from "../utils/attribution";
-import {
-  COIN_ETH_PAIR_POOL_CONFIG,
-  COIN_ZORA_PAIR_POOL_CONFIG,
-} from "../utils/poolConfigUtils";
-import { getPrepurchaseHook } from "../utils/getPrepurchaseHook";
 import { getChainFromId } from "../utils/getChainFromId";
+import { postCreateContent } from "../api";
+import { rethrowDecodedRevert } from "../utils/rethrowDecodedRevert";
 
 export type CoinDeploymentLogArgs = ContractEventArgsFromTopics<
   typeof zoraFactoryImplABI,
   "CoinCreatedV4"
 >;
 
-export enum DeployCurrency {
-  ZORA = 1,
-  ETH = 2,
-}
+const STARTING_MARKET_CAPS = {
+  LOW: "LOW",
+  HIGH: "HIGH",
+} as const;
+export type StartingMarketCap = keyof typeof STARTING_MARKET_CAPS;
 
-export enum InitialPurchaseCurrency {
-  ETH = 1,
-  // TODO: Add USDC and ZORA support with signature approvals
+export interface RawUriMetadata {
+  type: "RAW_URI";
+  uri: string;
 }
 
+const CONTENT_COIN_CURRENCIES = {
+  CREATOR_COIN: "CREATOR_COIN",
+  ZORA: "ZORA",
+  ETH: "ETH",
+  CREATOR_COIN_OR_ZORA: "CREATOR_COIN_OR_ZORA",
+} as const;
+export type ContentCoinCurrency = keyof typeof CONTENT_COIN_CURRENCIES;
+
+export const CreateConstants = {
+  StartingMarketCaps: STARTING_MARKET_CAPS,
+  ContentCoinCurrencies: CONTENT_COIN_CURRENCIES,
+} as const;
+
 export type CreateCoinArgs = {
+  creator: string;
   name: string;
   symbol: string;
-  uri: ValidMetadataURI;
+  metadata: RawUriMetadata;
+  currency: ContentCoinCurrency;
   chainId?: number;
-  owners?: Address[];
-  payoutRecipient: Address;
-  platformReferrer?: Address;
-  currency?: DeployCurrency;
-  initialPurchase?: {
-    currency: InitialPurchaseCurrency;
-    amount: bigint;
-  };
+  startingMarketCap?: StartingMarketCap;
+  platformReferrer?: string;
+  additionalOwners?: Address[];
+  payoutRecipientOverride?: Address;
+  skipMetadataValidation?: boolean;
 };
 
-function getPoolConfig(currency: DeployCurrency, chainId: number) {
-  if (currency === DeployCurrency.ZORA && chainId == baseSepolia.id) {
-    throw new Error("ZORA is not supported on Base Sepolia");
-  }
-
-  switch (currency) {
-    case DeployCurrency.ZORA:
-      return COIN_ZORA_PAIR_POOL_CONFIG[
-        chainId as keyof typeof COIN_ZORA_PAIR_POOL_CONFIG
-      ];
-    case DeployCurrency.ETH:
-      return COIN_ETH_PAIR_POOL_CONFIG[
-        chainId as keyof typeof COIN_ETH_PAIR_POOL_CONFIG
-      ];
-    default:
-      throw new Error("Invalid currency");
-  }
-}
+type TransactionParameters = {
+  to: Address;
+  data: Hex;
+  value: bigint;
+};
 
 export async function createCoinCall({
+  creator,
   name,
   symbol,
-  uri,
-  owners,
-  payoutRecipient,
+  metadata,
   currency,
   chainId = base.id,
-  platformReferrer = "0x0000000000000000000000000000000000000000",
-  initialPurchase,
-}: CreateCoinArgs): Promise<
-  SimulateContractParameters<typeof zoraFactoryImplABI, "deploy">
-> {
-  if (!owners) {
-    owners = [payoutRecipient];
-  }
-
-  if (!currency) {
-    currency = chainId !== base.id ? DeployCurrency.ETH : DeployCurrency.ZORA;
+  payoutRecipientOverride,
+  additionalOwners,
+  platformReferrer,
+  skipMetadataValidation = false,
+}: CreateCoinArgs): Promise<TransactionParameters[]> {
+  // Validate metadata URI
+  if (!skipMetadataValidation) {
+    await validateMetadataURIContent(metadata.uri as ValidMetadataURI);
   }
 
-  const poolConfig = getPoolConfig(currency, chainId);
-
-  // This will throw an error if the metadata is not valid
-  await validateMetadataURIContent(uri);
+  const createContentRequest = await postCreateContent({
+    currency,
+    chainId,
+    metadata,
+    creator,
+    name,
+    symbol,
+    platformReferrer,
+    additionalOwners,
+    payoutRecipientOverride,
+  });
 
-  let deployHook = {
-    hook: zeroAddress as Address,
-    hookData: "0x" as Hex,
-    value: 0n,
-  };
-  if (initialPurchase) {
-    deployHook = await getPrepurchaseHook({
-      initialPurchase,
-      payoutRecipient,
-      chainId,
-    });
+  if (!createContentRequest.data?.calls) {
+    throw new Error("Failed to create content calldata");
   }
 
-  return {
-    abi: zoraFactoryImplABI,
-    functionName: "deploy",
-    address: COIN_FACTORY_ADDRESS,
-    args: [
-      payoutRecipient,
-      owners,
-      uri,
-      name,
-      symbol,
-      poolConfig,
-      platformReferrer,
-      deployHook.hook,
-      deployHook.hookData,
-      keccak256(toBytes(Math.random().toString())), // coinSalt
-    ],
-    value: deployHook.value,
-    dataSuffix: getAttribution(),
-  } as const;
+  return createContentRequest.data.calls.map((data) => ({
+    to: data.to as Address,
+    data: data.data as Hex,
+    value: BigInt(data.value),
+  }));
 }
 
 /**
@@ -152,30 +127,97 @@ export function getCoinCreateFromLogs(
 }
 
 // Update createCoin to return both receipt and coin address
-export async function createCoin(
-  call: CreateCoinArgs,
-  walletClient: WalletClient,
-  publicClient: GenericPublicClient,
+export async function createCoin({
+  call,
+  walletClient,
+  publicClient,
+  options,
+}: {
+  call: CreateCoinArgs;
+  walletClient: WalletClient;
+  publicClient: GenericPublicClient;
   options?: {
     gasMultiplier?: number;
     account?: Account | Address;
-  },
-) {
+    skipValidateTransaction?: boolean;
+  };
+}) {
   validateClientNetwork(publicClient);
 
-  const createCoinRequest = await createCoinCall(call);
-  const { request } = await publicClient.simulateContract({
-    ...createCoinRequest,
-    account: options?.account ?? walletClient.account,
-  });
+  const callRequest = await createCoinCall(call);
 
-  // Add a 2/5th buffer on gas.
-  if (request.gas) {
-    // Gas limit multiplier is a percentage argument.
-    request.gas = (request.gas * BigInt(options?.gasMultiplier ?? 100)) / 100n;
+  if (callRequest.length !== 1) {
+    throw new Error("Only one call is supported for this SDK version");
   }
-  const hash = await walletClient.writeContract(request);
-  const receipt = await publicClient.waitForTransactionReceipt({ hash });
+
+  const createContentCall = callRequest[0];
+
+  if (!createContentCall) {
+    throw new Error("Failed to load create content calldata from API");
+  }
+
+  const coinFactoryAddressForChain =
+    coinFactoryAddress[call.chainId as keyof typeof coinFactoryAddress];
+
+  // Sanity check that the call is for the correct factory contract
+  if (!isAddressEqual(createContentCall.to, coinFactoryAddressForChain)) {
+    throw new Error("Creator coin is not supported for this SDK version");
+  }
+
+  // Sanity check to ensure no buy orders are sent with there parameters
+  if (createContentCall.value !== 0n) {
+    throw new Error(
+      "Creator coin and purchase is not supported for this SDK version.",
+    );
+  }
+
+  // Prefer a LocalAccount from the wallet client when available to ensure
+  // offline signing (eth_sendRawTransaction) instead of wallet_sendTransaction
+  // which can error when a `from` field is present.
+  const selectedAccount =
+    (typeof options?.account === "string" ? undefined : options?.account) ??
+    walletClient.account;
+
+  if (!selectedAccount) {
+    throw new Error("Account is required");
+  }
+
+  const viemCall = {
+    ...createContentCall,
+    account: selectedAccount,
+  };
+
+  // simulate call
+  if (!options?.skipValidateTransaction) {
+    try {
+      await publicClient.call(viemCall);
+    } catch (err) {
+      rethrowDecodedRevert(err, zoraFactoryImplABI);
+    }
+  }
+
+  const gasEstimate = options?.skipValidateTransaction
+    ? 10_000_000n
+    : await publicClient.estimateGas(viemCall);
+  const gasPrice = await publicClient.getGasPrice();
+
+  const hash = await (async () => {
+    try {
+      return await walletClient.sendTransaction({
+        ...viemCall,
+        gasPrice,
+        gas: gasEstimate,
+        chain: publicClient.chain,
+      });
+    } catch (err) {
+      rethrowDecodedRevert(err, zoraFactoryImplABI);
+    }
+  })();
+
+  const receipt = await publicClient.waitForTransactionReceipt({
+    hash,
+  });
+
   const deployment = getCoinCreateFromLogs(receipt);
 
   return {

package/src/api/create.ts

@@ -0,0 +1,24 @@
+import {
+  PostCreateContentData,
+  PostCreateContentResponse,
+} from "../client/types.gen";
+import { postCreateContent as postCreateContentSDK } from "../client/sdk.gen";
+import { getApiKeyMeta } from "./api-key";
+import { RequestOptionsType } from "./query-types";
+import { RequestResult } from "@hey-api/client-fetch";
+
+type PostCreateContentQuery = PostCreateContentData["body"];
+export type { PostCreateContentQuery, PostCreateContentResponse };
+
+export type CoinCreateData = NonNullable<PostCreateContentResponse>;
+
+export const postCreateContent = async (
+  body: PostCreateContentQuery,
+  options?: RequestOptionsType<PostCreateContentData>,
+): Promise<RequestResult<PostCreateContentResponse>> => {
+  return await postCreateContentSDK({
+    ...options,
+    body,
+    ...getApiKeyMeta(),
+  });
+};

package/src/api/index.ts

@@ -6,6 +6,14 @@ export type * from "./explore";
 export * from "./queries";
 export type * from "./queries";
 
+// Export all of the pool config queries
+export * from "./pool-config";
+export type * from "./pool-config";
+
+// Export all of the create queries
+export * from "./create";
+export type * from "./create";
+
 // Only export the set function for external use.
 // All other exports are for internal use.
 export { setApiKey } from "./api-key";

package/src/api/pool-config.ts

@@ -0,0 +1,17 @@
+import {
+  getCreateContentPoolConfig as getCreateContentPoolConfigSDK,
+  GetCreateContentPoolConfigData,
+  GetCreateContentPoolConfigResponse,
+} from "../client";
+import { RequestOptionsType } from "./query-types";
+import { RequestResult } from "@hey-api/client-fetch";
+
+export const getCreateContentPoolConfig = async (
+  query: GetCreateContentPoolConfigData["query"],
+  options?: RequestOptionsType<GetCreateContentPoolConfigData>,
+): Promise<RequestResult<GetCreateContentPoolConfigResponse>> => {
+  return getCreateContentPoolConfigSDK({
+    query,
+    ...options,
+  });
+};

package/src/api/queries.ts

@@ -2,9 +2,13 @@ import {
   GetCoinCommentsData,
   GetCoinCommentsResponse,
   GetCoinData,
+  GetCoinHoldersData,
+  GetCoinHoldersResponse,
   GetCoinResponse,
   GetCoinsData,
   GetCoinsResponse,
+  GetCoinSwapsData,
+  GetCoinSwapsResponse,
   GetProfileBalancesData,
   GetProfileBalancesResponse,
   GetProfileCoinsData,
@@ -16,6 +20,8 @@ import {
   getCoin as getCoinSDK,
   getCoins as getCoinsSDK,
   getCoinComments as getCoinCommentsSDK,
+  getCoinHolders as getCoinHoldersSDK,
+  getCoinSwaps as getCoinSwapsSDK,
   getProfile as getProfileSDK,
   getProfileBalances as getProfileBalancesSDK,
   getProfileCoins as getProfileCoinsSDK,
@@ -60,6 +66,36 @@ export const getCoins = async (
   });
 };
 
+type GetCoinHoldersQuery = GetCoinHoldersData["query"];
+export type { GetCoinHoldersQuery, GetCoinHoldersData };
+export type { GetCoinHoldersResponse } from "../client/types.gen";
+
+export const getCoinHolders = async (
+  query: GetCoinHoldersQuery,
+  options?: RequestOptionsType<GetCoinHoldersData>,
+): Promise<RequestResult<GetCoinHoldersResponse>> => {
+  return await getCoinHoldersSDK({
+    query,
+    ...getApiKeyMeta(),
+    ...options,
+  });
+};
+
+type GetCoinSwapsQuery = GetCoinSwapsData["query"];
+export type { GetCoinSwapsQuery, GetCoinSwapsData };
+export type { GetCoinSwapsResponse } from "../client/types.gen";
+
+export const getCoinSwaps = async (
+  query: GetCoinSwapsQuery,
+  options?: RequestOptionsType<GetCoinSwapsData>,
+): Promise<RequestResult<GetCoinSwapsResponse>> => {
+  return await getCoinSwapsSDK({
+    query,
+    ...getApiKeyMeta(),
+    ...options,
+  });
+};
+
 type GetCoinCommentsQuery = GetCoinCommentsData["query"];
 export type { GetCoinCommentsQuery, GetCoinCommentsData };
 export type { GetCoinCommentsResponse } from "../client/types.gen";

package/src/client/sdk.gen.ts

@@ -12,6 +12,10 @@ import type {
   GetCoinResponse,
   GetCoinCommentsData,
   GetCoinCommentsResponse,
+  GetCoinHoldersData,
+  GetCoinHoldersResponse,
+  GetCoinSwapsData,
+  GetCoinSwapsResponse,
   GetCoinsData,
   GetCoinsResponse,
   SetCreateUploadJwtData,
@@ -27,6 +31,12 @@ import type {
   PostQuoteData,
   PostQuoteResponse,
   PostQuoteError,
+  GetCreateContentPoolConfigData,
+  GetCreateContentPoolConfigResponse,
+  GetCreateContentPoolConfigError,
+  PostCreateContentData,
+  PostCreateContentResponse,
+  PostCreateContentError,
 } from "./types.gen";
 import { client as _heyApiClient } from "./client.gen";
 
@@ -113,6 +123,50 @@ export const getCoinComments = <ThrowOnError extends boolean = false>(
   });
 };
 
+/**
+ * zoraSDK_coinHolders query
+ */
+export const getCoinHolders = <ThrowOnError extends boolean = false>(
+  options: Options<GetCoinHoldersData, ThrowOnError>,
+) => {
+  return (options.client ?? _heyApiClient).get<
+    GetCoinHoldersResponse,
+    unknown,
+    ThrowOnError
+  >({
+    security: [
+      {
+        name: "api-key",
+        type: "apiKey",
+      },
+    ],
+    url: "/coinHolders",
+    ...options,
+  });
+};
+
+/**
+ * zoraSDK_coinSwaps query
+ */
+export const getCoinSwaps = <ThrowOnError extends boolean = false>(
+  options: Options<GetCoinSwapsData, ThrowOnError>,
+) => {
+  return (options.client ?? _heyApiClient).get<
+    GetCoinSwapsResponse,
+    unknown,
+    ThrowOnError
+  >({
+    security: [
+      {
+        name: "api-key",
+        type: "apiKey",
+      },
+    ],
+    url: "/coinSwaps",
+    ...options,
+  });
+};
+
 /**
  * zoraSDK_coins query
  */
@@ -271,3 +325,47 @@ export const postQuote = <ThrowOnError extends boolean = false>(
     },
   });
 };
+
+export const getCreateContentPoolConfig = <
+  ThrowOnError extends boolean = false,
+>(
+  options?: Options<GetCreateContentPoolConfigData, ThrowOnError>,
+) => {
+  return (options?.client ?? _heyApiClient).get<
+    GetCreateContentPoolConfigResponse,
+    GetCreateContentPoolConfigError,
+    ThrowOnError
+  >({
+    security: [
+      {
+        name: "api-key",
+        type: "apiKey",
+      },
+    ],
+    url: "/create/content/pool-config",
+    ...options,
+  });
+};
+
+export const postCreateContent = <ThrowOnError extends boolean = false>(
+  options?: Options<PostCreateContentData, ThrowOnError>,
+) => {
+  return (options?.client ?? _heyApiClient).post<
+    PostCreateContentResponse,
+    PostCreateContentError,
+    ThrowOnError
+  >({
+    security: [
+      {
+        name: "api-key",
+        type: "apiKey",
+      },
+    ],
+    url: "/create/content",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options?.headers,
+    },
+  });
+};