@zoralabs/coins-sdk 0.2.4 → 0.2.6

package/src/actions/tradeCoin.ts

@@ -0,0 +1,230 @@
+import { permit2ABI, permit2Address } from "@zoralabs/protocol-deployments";
+import { postQuote, PostQuoteResponse } from "src/client";
+import { GenericPublicClient } from "src/utils/genericPublicClient";
+import {
+  Account,
+  Address,
+  erc20Abi,
+  WalletClient,
+  maxUint256,
+  Hex,
+} from "viem";
+import { base } from "viem/chains";
+
+type TradeERC20 = {
+  type: "erc20";
+  address: Address;
+};
+
+type TradeETH = {
+  type: "eth";
+};
+
+type PermitDetails = {
+  token: Address;
+  amount: bigint;
+  expiration: number;
+  nonce: number;
+};
+
+type Permit = {
+  details: PermitDetails;
+  spender: Address;
+  sigDeadline: bigint;
+};
+
+type PermitDetailsStringAmounts = {
+  token: Address;
+  amount: string;
+  expiration: number;
+  nonce: number;
+};
+
+type PermitStringAmounts = {
+  details: PermitDetailsStringAmounts;
+  spender: Address;
+  sigDeadline: string;
+};
+
+type SignatureWithPermit<TPermit = Permit> = {
+  signature: Hex;
+  permit: TPermit;
+};
+
+function convertBigIntToString(permit: Permit): PermitStringAmounts {
+  return {
+    ...permit,
+    details: {
+      ...permit.details,
+      amount: `${permit.details.amount}`,
+    },
+    sigDeadline: `${permit.sigDeadline}`,
+  };
+}
+
+const PERMIT_SINGLE_TYPES = {
+  PermitSingle: [
+    { name: "details", type: "PermitDetails" },
+    { name: "spender", type: "address" },
+    { name: "sigDeadline", type: "uint256" },
+  ],
+  PermitDetails: [
+    { name: "token", type: "address" },
+    { name: "amount", type: "uint160" },
+    { name: "expiration", type: "uint48" },
+    { name: "nonce", type: "uint48" },
+  ],
+};
+
+type TradeCurrency = TradeERC20 | TradeETH;
+
+export type TradeParameters = {
+  sell: TradeCurrency;
+  buy: TradeCurrency;
+  amountIn: bigint;
+  slippage?: number;
+  // can be smart wallet or EOA here.
+  sender: Address;
+  // needs to be EOA, if signer is blank assumes EOA in sender.
+  signer?: Address;
+  recipient?: Address;
+  signatures?: SignatureWithPermit<PermitStringAmounts>[];
+  permitActiveSeconds?: number;
+};
+
+export async function tradeCoin(
+  tradeParameters: TradeParameters,
+  walletClient: WalletClient,
+  account: Account,
+  publicClient: GenericPublicClient,
+  validateTransaction = true,
+) {
+  const quote = await createTradeCall(tradeParameters);
+
+  // todo replace any
+  const signatures: { signature: Hex; permit: any }[] = [];
+  if (quote.permits) {
+    for (const permit of quote.permits) {
+      const [, nonce] = await publicClient.readContract({
+        abi: permit2ABI,
+        address: permit2Address[base.id],
+        functionName: "allowance",
+        args: [
+          permit.permit.details.token as Address,
+          account.address,
+          permit.permit.spender as Address,
+        ],
+      });
+      const permitToken = permit.permit.details.token as Address;
+      const allowance = await publicClient.readContract({
+        abi: erc20Abi,
+        address: permitToken,
+        functionName: "allowance",
+        args: [permitToken, permit2Address[base.id]],
+      });
+      if (allowance < BigInt(permit.permit.details.amount)) {
+        const approvalTx = await walletClient.writeContract({
+          abi: erc20Abi,
+          address: permitToken,
+          functionName: "approve",
+          chain: base,
+          args: [permit2Address[base.id], maxUint256],
+          account,
+        });
+        await publicClient.waitForTransactionReceipt({
+          hash: approvalTx,
+        });
+      }
+      const message = {
+        details: {
+          token: permit.permit.details.token as Address,
+          amount: BigInt(permit.permit.details.amount!),
+          expiration: Number(permit.permit.details.expiration!),
+          nonce: nonce,
+        },
+        spender: permit.permit.spender as Address,
+        sigDeadline: BigInt(permit.permit.sigDeadline!),
+      };
+      const signature = await walletClient.signTypedData({
+        domain: {
+          name: "Permit2",
+          chainId: base.id,
+          verifyingContract: permit2Address[base.id],
+        },
+        primaryType: "PermitSingle",
+        types: PERMIT_SINGLE_TYPES,
+        message,
+        account,
+      });
+      signatures.push({
+        signature,
+        permit: convertBigIntToString(message),
+      });
+    }
+  }
+
+  const newQuote = await createTradeCall({
+    ...tradeParameters,
+    signatures,
+  });
+
+  const call = {
+    to: newQuote.call.target as Address,
+    data: newQuote.call.data as Hex,
+    value: BigInt(newQuote.call.value),
+    chain: base,
+    account,
+  };
+
+  // simulate call
+  if (validateTransaction) {
+    await publicClient.call(call);
+  }
+
+  const gasEstimate = validateTransaction
+    ? await publicClient.estimateGas(call)
+    : 10_000_000n;
+  const gasPrice = await publicClient.getGasPrice();
+
+  const tx = await walletClient.sendTransaction({
+    ...call,
+    gasPrice,
+    gas: gasEstimate,
+  });
+
+  const receipt = await publicClient.waitForTransactionReceipt({
+    hash: tx,
+  });
+
+  return receipt;
+}
+
+export async function createTradeCall(
+  tradeParameters: TradeParameters,
+): Promise<PostQuoteResponse> {
+  if (tradeParameters.slippage && tradeParameters.slippage > 1) {
+    throw new Error("Slippage must be less than 1, max 0.99");
+  }
+  if (tradeParameters.amountIn === BigInt(0)) {
+    throw new Error("Amount in must be greater than 0");
+  }
+
+  const quote = await postQuote({
+    body: {
+      tokenIn: tradeParameters.sell,
+      tokenOut: tradeParameters.buy,
+      amountIn: tradeParameters.amountIn.toString(),
+      slippage: tradeParameters.slippage,
+      chainId: base.id,
+      sender: tradeParameters.sender,
+      recipient: tradeParameters.recipient || tradeParameters.sender,
+      signatures: tradeParameters.signatures,
+    },
+  });
+
+  if (!quote.data) {
+    throw new Error("Quote failed");
+  }
+
+  return quote.data;
+}

package/src/api/api-key.ts

@@ -1,8 +1,12 @@
 let apiKey: string | undefined;
-export function setApiKey(key: string) {
+export function setApiKey(key: string | undefined) {
   apiKey = key;
 }
 
+export function getApiKey() {
+  return apiKey;
+}
+
 export function getApiKeyMeta() {
   if (!apiKey) {
     return {};

package/src/api/internal.ts

@@ -7,16 +7,16 @@ import { getApiKeyMeta } from "./api-key";
 import { RequestOptionsType } from "./query-types";
 import { RequestResult } from "@hey-api/client-fetch";
 
-type SetCreateUploadJwtQuery = SetCreateUploadJwtData["query"];
+type SetCreateUploadJwtQuery = SetCreateUploadJwtData["body"];
 export type { SetCreateUploadJwtQuery, SetCreateUploadJwtData };
 export type { SetCreateUploadJwtResponse } from "../client/types.gen";
 
 export const setCreateUploadJwt = async (
-  query: SetCreateUploadJwtQuery,
+  body: SetCreateUploadJwtQuery,
   options?: RequestOptionsType<SetCreateUploadJwtData>,
 ): Promise<RequestResult<SetCreateUploadJwtResponse>> => {
   return await setCreateUploadJwtSDK({
-    query,
+    body,
     ...getApiKeyMeta(),
     ...options,
   });

package/src/client/sdk.gen.ts

@@ -24,6 +24,9 @@ import type {
   GetProfileBalancesResponse,
   GetProfileCoinsData,
   GetProfileCoinsResponse,
+  PostQuoteData,
+  PostQuoteResponse,
+  PostQuoteError,
 } from "./types.gen";
 import { client as _heyApiClient } from "./client.gen";
 
@@ -245,3 +248,26 @@ export const getProfileCoins = <ThrowOnError extends boolean = false>(
     ...options,
   });
 };
+
+export const postQuote = <ThrowOnError extends boolean = false>(
+  options?: Options<PostQuoteData, ThrowOnError>,
+) => {
+  return (options?.client ?? _heyApiClient).post<
+    PostQuoteResponse,
+    PostQuoteError,
+    ThrowOnError
+  >({
+    security: [
+      {
+        name: "api-key",
+        type: "apiKey",
+      },
+    ],
+    url: "/quote",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options?.headers,
+    },
+  });
+};

package/src/client/types.gen.ts

@@ -204,6 +204,20 @@ export type GetCoinResponses = {
        * The `Int` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.
        */
       uniqueHolders: number;
+      uniswapV4PoolKey: {
+        token0Address: string;
+        token1Address: string;
+        /**
+         * The `Int` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.
+         */
+        fee: number;
+        /**
+         * The `Int` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.
+         */
+        tickSpacing: number;
+        hookAddress: string;
+      };
+      uniswapV3PoolAddress: string;
       zoraComments: {
         pageInfo: {
           /**
@@ -582,6 +596,20 @@ export type GetCoinsResponses = {
        * The `Int` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.
        */
       uniqueHolders: number;
+      uniswapV4PoolKey: {
+        token0Address: string;
+        token1Address: string;
+        /**
+         * The `Int` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.
+         */
+        fee: number;
+        /**
+         * The `Int` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.
+         */
+        tickSpacing: number;
+        hookAddress: string;
+      };
+      uniswapV3PoolAddress: string;
       zoraComments: {
         pageInfo: {
           /**
@@ -858,6 +886,20 @@ export type GetExploreResponses = {
            * The `Int` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.
            */
           uniqueHolders: number;
+          uniswapV4PoolKey: {
+            token0Address: string;
+            token1Address: string;
+            /**
+             * The `Int` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.
+             */
+            fee: number;
+            /**
+             * The `Int` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.
+             */
+            tickSpacing: number;
+            hookAddress: string;
+          };
+          uniswapV3PoolAddress: string;
         };
         /**
          * The `String` scalar type represents textual data, represented as UTF-8 character sequences. The String type is most often used by GraphQL to represent free-form human-readable text.
@@ -1187,6 +1229,20 @@ export type GetProfileBalancesResponses = {
                * The `Int` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.
                */
               uniqueHolders: number;
+              uniswapV4PoolKey: {
+                token0Address: string;
+                token1Address: string;
+                /**
+                 * The `Int` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.
+                 */
+                fee: number;
+                /**
+                 * The `Int` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.
+                 */
+                tickSpacing: number;
+                hookAddress: string;
+              };
+              uniswapV3PoolAddress: string;
             };
           };
         }>;
@@ -1406,6 +1462,20 @@ export type GetProfileCoinsResponses = {
              * The `Int` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.
              */
             uniqueHolders: number;
+            uniswapV4PoolKey: {
+              token0Address: string;
+              token1Address: string;
+              /**
+               * The `Int` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.
+               */
+              fee: number;
+              /**
+               * The `Int` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.
+               */
+              tickSpacing: number;
+              hookAddress: string;
+            };
+            uniswapV3PoolAddress: string;
             zoraComments: {
               pageInfo: {
                 /**
@@ -1485,6 +1555,97 @@ export type GetProfileCoinsResponses = {
 export type GetProfileCoinsResponse =
   GetProfileCoinsResponses[keyof GetProfileCoinsResponses];
 
+export type PostQuoteData = {
+  body?: {
+    signatures?: Array<{
+      permit: {
+        details: {
+          token: string;
+          amount: string;
+          expiration: number;
+          nonce: number;
+        };
+        spender: string;
+        sigDeadline: string;
+      };
+      signature: string;
+    }>;
+    permitActiveSeconds?: number;
+    chainId?: number;
+    tokenOut?: {
+      type: "eth" | "erc20";
+      address?: string;
+    };
+    tokenIn?: {
+      type: "eth" | "erc20";
+      address?: string;
+    };
+    amountIn?: string;
+    slippage?: number;
+    recipient?: string;
+    sender?: string;
+  };
+  path?: never;
+  query?: never;
+  url: "/quote";
+};
+
+export type PostQuoteErrors = {
+  /**
+   * Error
+   */
+  500: {
+    error?: string;
+  };
+};
+
+export type PostQuoteError = PostQuoteErrors[keyof PostQuoteErrors];
+
+export type PostQuoteResponses = {
+  /**
+   * Success
+   */
+  200: {
+    success: boolean;
+    call: {
+      data: string;
+      value: string;
+      target: string;
+    };
+    /**
+     * The approval information for the token
+     */
+    permits?: Array<{
+      signature: string;
+      permit: {
+        sigDeadline: string;
+        spender: string;
+        details: {
+          token: string;
+          amount: string;
+          expiration: number;
+          nonce: number;
+        };
+      };
+    }>;
+    trade?: {
+      commands: Array<string>;
+      value: string;
+      inputs: Array<string>;
+    };
+    quote: {
+      amountOut: string;
+      slippage: number;
+      tokenIn?: {
+        type?: string;
+        address?: string;
+      };
+    };
+  };
+};
+
+export type PostQuoteResponse = PostQuoteResponses[keyof PostQuoteResponses];
+
 export type ClientOptions = {
   baseUrl:
     | "https://api-sdk.zora.engineering/"

package/src/index.ts

@@ -23,6 +23,9 @@ export {
 } from "./actions/updatePayoutRecipient";
 export type { UpdatePayoutRecipientArgs } from "./actions/updatePayoutRecipient";
 
+export { tradeCoin, createTradeCall } from "./actions/tradeCoin";
+export type { TradeParameters } from "./actions/tradeCoin";
+
 // API Read Actions
 export * from "./api/queries";
 export type * from "./api/queries";
@@ -36,3 +39,6 @@ export { setApiKey } from "./api/api-key";
 
 // Metadata Validation Utils
 export * from "./metadata";
+
+// Uploader
+export * from "./uploader";

package/src/metadata/cleanAndValidateMetadataURI.ts

@@ -1,8 +1,4 @@
-export type ValidMetadataURI =
-  | `ipfs://${string}`
-  | `ar://${string}`
-  | `data:${string}`
-  | `https://${string}`;
+import { ValidMetadataURI } from "../uploader/types";
 
 /**
  * Clean the metadata URI to HTTPS format

package/src/metadata/index.ts

@@ -1,7 +1,4 @@
-export {
-  cleanAndValidateMetadataURI,
-  type ValidMetadataURI,
-} from "./cleanAndValidateMetadataURI";
+export { cleanAndValidateMetadataURI } from "./cleanAndValidateMetadataURI";
 export { validateMetadataJSON } from "./validateMetadataJSON";
 export type { ValidMetadataJSON } from "./validateMetadataJSON";
 export { validateMetadataURIContent } from "./validateMetadataURIContent";

package/src/metadata/validateMetadataURIContent.ts

@@ -1,7 +1,5 @@
-import {
-  cleanAndValidateMetadataURI,
-  ValidMetadataURI,
-} from "./cleanAndValidateMetadataURI";
+import { cleanAndValidateMetadataURI } from "./cleanAndValidateMetadataURI";
+import { ValidMetadataURI } from "../uploader/types";
 import { validateMetadataJSON } from "./validateMetadataJSON";
 
 /**

package/src/uploader/index.ts

@@ -0,0 +1,16 @@
+/**
+ * Uploader package for storing files on IPFS and other decentralized storage
+ * @packageDocumentation
+ */
+
+// Export core types
+export * from "./types";
+
+// Export the metadata builder
+export * from "./metadata";
+
+// Export all providers
+export * from "./providers/zora";
+
+export { createMetadataBuilder } from "./metadata";
+export { createZoraUploaderForCreator } from "./providers/zora";