@zero-tech/zauction-sdk 0.2.10 → 0.2.12

package/src/contracts/types/index.ts

@@ -0,0 +1,14 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export type { IERC20 } from "./IERC20";
+export type { IERC721 } from "./IERC721";
+export type { IZNSHub } from "./IZNSHub";
+export type { ZAuction } from "./ZAuction";
+export type { ZAuctionV1 } from "./ZAuctionV1";
+
+export { IERC20__factory } from "./factories/IERC20__factory";
+export { IERC721__factory } from "./factories/IERC721__factory";
+export { IZNSHub__factory } from "./factories/IZNSHub__factory";
+export { ZAuction__factory } from "./factories/ZAuction__factory";
+export { ZAuctionV1__factory } from "./factories/ZAuctionV1__factory";

package/src/index.ts

@@ -0,0 +1,468 @@
+import * as subgraph from "./subgraph";
+import * as api from "./api";
+import * as actions from "./actions";
+
+import { ethers } from "ethers";
+
+import {
+  PlaceBidStatusCallback,
+  NewBidParameters,
+  Config,
+  Instance,
+  Bid,
+  BuyNowParams,
+  BuyNowListing,
+  TokenSale,
+  TokenBuy,
+  TokenSaleCollection,
+  TokenBidCollection,
+  TokenBuyNowListingCollection,
+  TokenBidFilter,
+} from "./types";
+import {
+  getERC721Contract,
+  getZAuctionContract,
+  getZnsHubContract,
+} from "./contracts";
+import { IZNSHub } from "./contracts/types";
+import { approveDomainTransfer, approveSpender } from "./actions";
+import { getLogger, Maybe } from "./utilities/";
+
+const logger = getLogger("zauction-sdk");
+
+export * from "./types";
+
+export const createInstance = (config: Config): Instance => {
+  logger.debug("Creating instance of zAuction SDK");
+  logger.debug(config);
+
+  const subgraphClient: subgraph.SubgraphClient = subgraph.createClient(
+    config.subgraphUri,
+    config.wildTokenAddress
+  );
+
+  const apiClient: api.ApiClient = api.createClient(config.apiUri);
+
+  const instance = {
+    listSales: async (tokenId: string): Promise<TokenSale[]> => {
+      const hub = await getZnsHubContract(
+        config.web3Provider,
+        config.znsHubAddress
+      );
+      const domainContract = await hub.getRegistrarForDomain(tokenId);
+      const tokenSales: TokenSale[] = await subgraphClient.listSales(
+        domainContract,
+        tokenId
+      );
+      return tokenSales;
+    },
+    listAllSales: async (): Promise<TokenSaleCollection> => {
+      const tokenSaleCollection: TokenSaleCollection =
+        await subgraphClient.listAllSales();
+      return tokenSaleCollection;
+    },
+    listAllBuyNowListings: async () => {
+      const tokenBuyNowListingCollection: TokenBuyNowListingCollection =
+        await subgraphClient.listAllBuyNowListings();
+      return tokenBuyNowListingCollection;
+    },
+    listBuyNowSales: async (tokenId: string): Promise<TokenBuy[]> => {
+      const hub = await getZnsHubContract(
+        config.web3Provider,
+        config.znsHubAddress
+      );
+      const domainContract = await hub.getRegistrarForDomain(tokenId);
+      const tokenBuys: TokenBuy[] = await subgraphClient.listBuyNowSales(
+        domainContract,
+        tokenId
+      );
+      return tokenBuys;
+    },
+    listBids: async (
+      tokenIds: string[],
+      filter?: TokenBidFilter
+    ): Promise<TokenBidCollection> => {
+      const tokenBidCollection: TokenBidCollection =
+        await apiClient.listBidsForTokens(
+          tokenIds,
+          config.wildTokenAddress,
+          filter
+        );
+      return tokenBidCollection;
+    },
+    listBidsByAccount: async (account: string) => {
+      const bidsList: Bid[] = await apiClient.listBidsByAccount(
+        account,
+        config.wildTokenAddress
+      );
+      return bidsList;
+    },
+    placeBid: async (
+      params: NewBidParameters,
+      signer: ethers.Signer,
+      statusCallback?: PlaceBidStatusCallback
+    ) => {
+      await actions.placeBid({
+        bid: params,
+        config: config,
+        bidder: await signer.getAddress(),
+        encodeBid: apiClient.encodeBid,
+        signMessage: (e) => signer.signMessage(e),
+        submitBid: apiClient.submitBid,
+        statusCallback,
+      });
+    },
+    isZAuctionApprovedToTransferNftByBid: async (
+      account: string,
+      bid: Bid
+    ): Promise<boolean> => {
+      logger.trace(
+        `Calling to check if user ${account} has approved zAuction to transfer NFTs from ${bid.contract}`
+      );
+      const isVersion1 = bid.version === "1.0";
+
+      // route to legacy if version 1.0
+      const zAuctionAddress = isVersion1
+        ? config.zAuctionLegacyAddress
+        : config.zAuctionAddress;
+
+      const nftContract = await getERC721Contract(
+        config.web3Provider,
+        bid.contract
+      );
+
+      const isApproved = await actions.isZAuctionApprovedNftTransfer(
+        account,
+        zAuctionAddress,
+        nftContract
+      );
+
+      return isApproved;
+    },
+
+    isZAuctionApprovedToTransferNftByDomain: async (
+      account: string,
+      tokenId: string
+    ): Promise<boolean> => {
+      const hub = await getZnsHubContract(
+        config.web3Provider,
+        config.znsHubAddress
+      );
+      const domainContract = await hub.getRegistrarForDomain(tokenId);
+      logger.trace(
+        `Calling to check if user ${account} has approved zAuction to transfer NFTs from ${domainContract}`
+      );
+      const nftContract = await getERC721Contract(
+        config.web3Provider,
+        domainContract
+      );
+
+      const isApproved = await actions.isZAuctionApprovedNftTransfer(
+        account,
+        config.zAuctionAddress,
+        nftContract
+      );
+
+      return isApproved;
+    },
+    isZAuctionLegacyApprovedToTransferNft: async (
+      account: string,
+      tokenId: string
+    ): Promise<boolean> => {
+      const hub = await getZnsHubContract(
+        config.web3Provider,
+        config.znsHubAddress
+      );
+      const domainContract = await hub.getRegistrarForDomain(tokenId);
+      logger.trace(
+        `Calling to check if user ${account} has approved zAuction to transfer NFTs from ${domainContract}`
+      );
+      const nftContract = await getERC721Contract(
+        config.web3Provider,
+        domainContract
+      );
+
+      const isApproved = await actions.isZAuctionApprovedNftTransfer(
+        account,
+        config.zAuctionLegacyAddress,
+        nftContract
+      );
+
+      return isApproved;
+    },
+    getZAuctionSpendAllowanceByBid: async (
+      account: string,
+      bid: Bid
+    ): Promise<ethers.BigNumber> => {
+      const isVersion1 = bid.version === "1.0";
+
+      // route to legacy if version 1.0
+      const zAuctionAddress = isVersion1
+        ? config.zAuctionLegacyAddress
+        : config.zAuctionAddress;
+
+      const bidToken = bid.bidToken ?? config.wildTokenAddress;
+
+      const allowance = await actions.getPaymentTokenAllowance(
+        account,
+        bidToken,
+        config.web3Provider,
+        zAuctionAddress
+      );
+
+      return allowance;
+    },
+    getZAuctionSpendAllowanceByDomain: async (
+      account: string,
+      tokenId: string
+    ): Promise<ethers.BigNumber> => {
+      const contract = await getZAuctionContract(
+        config.web3Provider,
+        config.zAuctionAddress
+      );
+      const paymentToken = await contract.getPaymentTokenForDomain(tokenId);
+
+      const allowance = await actions.getPaymentTokenAllowance(
+        account,
+        paymentToken,
+        config.web3Provider,
+        config.zAuctionAddress
+      );
+      return allowance;
+    },
+    getZAuctionSpendAllowance: async (
+      account: string,
+      paymentToken: string
+    ): Promise<ethers.BigNumber> => {
+      const allowance = await actions.getPaymentTokenAllowance(
+        account,
+        paymentToken,
+        config.web3Provider,
+        config.zAuctionAddress
+      );
+      return allowance;
+    },
+    getZAuctionLegacySpendAllowance: async (
+      account: string
+    ): Promise<ethers.BigNumber> => {
+      const allowance = await actions.getPaymentTokenAllowance(
+        account,
+        config.wildTokenAddress,
+        config.web3Provider,
+        config.zAuctionLegacyAddress
+      );
+      return allowance;
+    },
+    // Set the ERC20 token for a specific domain network
+    setNetworkPaymentToken: async (
+      networkId: string,
+      paymentToken: string,
+      signer: ethers.Signer
+    ): Promise<ethers.ContractTransaction> => {
+      const tx = await actions.setNetworkPaymentToken(
+        networkId,
+        paymentToken,
+        signer,
+        config
+      );
+      return tx;
+    },
+    // Return the ERC20 token used for payment in the network that domain is a part of.
+    // This could be either the network payment token or the default payment token
+    getPaymentTokenForDomain: async (
+      domainTokenId: string
+    ): Promise<string> => {
+      const contract = await getZAuctionContract(
+        config.web3Provider,
+        config.zAuctionAddress
+      );
+      const paymentToken = await contract.getPaymentTokenForDomain(
+        domainTokenId
+      );
+      logger.trace(
+        `Payment token for domain with ID ${domainTokenId} is ${paymentToken}`
+      );
+      return paymentToken;
+    },
+    approveZAuctionSpendPaymentTokenByBid: async (
+      bid: Bid,
+      signer: ethers.Signer
+    ): Promise<ethers.ContractTransaction> => {
+      const isVersion1 = bid.version === "1.0";
+
+      // route to legacy if version 1.0
+      const zAuctionAddress = isVersion1
+        ? config.zAuctionLegacyAddress
+        : config.zAuctionAddress;
+
+      const bidToken = bid.bidToken ?? config.wildTokenAddress;
+      const tx = await actions.approveSpender(
+        bidToken,
+        zAuctionAddress,
+        signer
+      );
+      return tx;
+    },
+    approveZAuctionSpendPaymentTokenByDomain: async (
+      tokenId: string,
+      signer: ethers.Signer
+    ): Promise<ethers.ContractTransaction> => {
+      const contract = await getZAuctionContract(
+        config.web3Provider,
+        config.zAuctionAddress
+      );
+      const paymentToken = await contract.getPaymentTokenForDomain(tokenId);
+      const tx = await approveSpender(
+        paymentToken,
+        config.zAuctionAddress,
+        signer
+      );
+      return tx;
+    },
+    approveZAuctionSpendPaymentToken: async (
+      paymentTokenAddress: string,
+      signer: ethers.Signer
+    ): Promise<ethers.ContractTransaction> => {
+      const tx = await approveSpender(
+        paymentTokenAddress,
+        config.zAuctionAddress,
+        signer
+      );
+      return tx;
+    },
+    approveZAuctionTransferNftByBid: async (
+      bid: Bid,
+      signer: ethers.Signer
+    ): Promise<ethers.ContractTransaction> => {
+      const isVersion1 = bid.version === "1.0";
+
+      // route to legacy if version 1.0
+      const zAuctionAddress = isVersion1
+        ? config.zAuctionLegacyAddress
+        : config.zAuctionAddress;
+
+      const hub: IZNSHub = await getZnsHubContract(
+        signer,
+        config.znsHubAddress
+      );
+      const domainContract = await hub.getRegistrarForDomain(bid.tokenId);
+
+      const tx = await approveDomainTransfer(
+        domainContract,
+        zAuctionAddress,
+        signer
+      );
+
+      return tx;
+    },
+    approveZAuctionTransferNftByDomain: async (
+      tokenId: string,
+      signer: ethers.Signer
+    ): Promise<ethers.ContractTransaction> => {
+      const hub: IZNSHub = await getZnsHubContract(
+        signer,
+        config.znsHubAddress
+      );
+      const domainContract = await hub.getRegistrarForDomain(tokenId);
+
+      const tx = approveDomainTransfer(
+        domainContract,
+        config.zAuctionAddress,
+        signer
+      );
+      return tx;
+    },
+    acceptBid: async (
+      bid: Bid,
+      signer: ethers.Signer
+    ): Promise<ethers.ContractTransaction> => {
+      const tx = await actions.acceptBid(bid, signer, config);
+      return tx;
+    },
+    cancelBid: async (
+      bid: Bid,
+      cancelOnChain: boolean,
+      signer: ethers.Signer
+    ): Promise<ethers.ContractTransaction | void> => {
+      const isVersion1 = bid.version === "1.0";
+
+      // route to legacy if version 1.0
+      const zAuctionAddress = isVersion1
+        ? config.zAuctionLegacyAddress
+        : config.zAuctionAddress;
+
+      const tx: ethers.ContractTransaction | void = await actions.cancelBid(
+        bid,
+        cancelOnChain,
+        apiClient,
+        zAuctionAddress,
+        signer
+      );
+      return tx;
+    },
+    buyNow: async (
+      params: BuyNowParams,
+      signer: ethers.Signer
+    ): Promise<ethers.ContractTransaction> => {
+      const tx = await actions.buyNow(params, signer, config);
+      return tx;
+    },
+
+    // IF no return value then that domain is not on sale
+    getBuyNowListing: async (
+      tokenId: string
+    ): Promise<Maybe<BuyNowListing>> => {
+      const listing: Maybe<BuyNowListing> = await actions.getBuyNowListing(
+        tokenId,
+        config
+      );
+      return listing;
+    },
+    setBuyNowPrice: async (
+      params: BuyNowParams,
+      signer: ethers.Signer
+    ): Promise<ethers.ContractTransaction> => {
+      const tx = await actions.setBuyNowPrice(
+        params,
+        signer,
+        config.znsHubAddress,
+        config.zAuctionAddress
+      );
+      return tx;
+    },
+
+    cancelBuyNow: async (
+      tokenId: string,
+      signer: ethers.Signer
+    ): Promise<ethers.ContractTransaction> => {
+      const contract = await getZAuctionContract(
+        signer,
+        config.zAuctionAddress
+      );
+
+      const hub: IZNSHub = await getZnsHubContract(
+        config.web3Provider,
+        config.znsHubAddress
+      );
+      const domainContract = await hub.getRegistrarForDomain(tokenId);
+
+      const nftContract = await getERC721Contract(
+        config.web3Provider,
+        domainContract
+      );
+
+      const seller = await nftContract.ownerOf(tokenId);
+      const signerAddress = await signer.getAddress();
+
+      if (signerAddress !== seller)
+        throw Error("Cannot cancel buy now of a domain that is not yours");
+
+      const tx = await contract
+        .connect(signer)
+        .setBuyPrice(ethers.BigNumber.from("0"), tokenId);
+      return tx;
+    },
+  };
+
+  return instance;
+};

package/src/subgraph/actions/index.ts

@@ -0,0 +1,4 @@
+export * from "./listSales";
+export * from "./listBuyNowSales";
+export * from "./listAllSales";
+export * from "./listAllBuyNowListings";

package/src/subgraph/actions/listAllBuyNowListings.ts

@@ -0,0 +1,69 @@
+import { ApolloClient } from "@apollo/client/core";
+import {
+  ListAllBuyNowListingsQueryOptions,
+  TokenBuyNowListingsDto,
+} from "../types";
+import { TokenBuyNowListing, TokenBuyNowListingCollection } from "../../types";
+import * as queries from "../queries";
+import { getLogger } from "../../utilities";
+
+const logger = getLogger("subgraph:actions:listAllSales");
+
+export const listAllBuyNowListings = async <T>(
+  apolloClient: ApolloClient<T>,
+  wildToken: string
+): Promise<TokenBuyNowListingCollection> => {
+  const collection: TokenBuyNowListingCollection = {};
+
+  const options: ListAllBuyNowListingsQueryOptions = {
+    count: 1000,
+    skipCount: 0,
+  };
+
+  let allListingsLength = 0;
+  /* eslint-disable-next-line no-constant-condition */
+  while (true) {
+    logger.trace(
+      `Querying for ${options.count} buy now listings starting at ${options.skipCount}`
+    );
+
+    const queryResult = await apolloClient.query<TokenBuyNowListingsDto>({
+      query: queries.getBuyNowTokenListings,
+      variables: {
+        ...options,
+      },
+    });
+
+    if (queryResult.error) {
+      throw queryResult.error;
+    }
+
+    const listings: TokenBuyNowListing[] = queryResult.data.buyNowListings.map(
+      (e) => {
+        const listing: TokenBuyNowListing = {
+          tokenId: e.id,
+          amount: e.amount,
+          paymentToken: e.paymentToken ?? wildToken,
+        };
+        return listing;
+      }
+    );
+
+    for (const listing of listings) {
+      if (!collection[listing.tokenId]) {
+        collection[listing.tokenId] = [];
+      }
+      if (listing.amount !== "0") {
+        collection[listing.tokenId].push(listing);
+        allListingsLength++;
+      }
+    }
+
+    if (listings.length < options.count) {
+      break;
+    }
+  }
+
+  logger.trace(`Found ${allListingsLength} buy now listings`);
+  return collection;
+};

package/src/subgraph/actions/listAllSales.ts

@@ -0,0 +1,57 @@
+import { ApolloClient } from "@apollo/client/core";
+import { ListAllSalesQueryOptions } from "../types";
+import { getLogger } from "../../utilities";
+import { TokenSaleCollection } from "../../types";
+import * as queries from "../queries";
+import * as helpers from "../helpers";
+
+const logger = getLogger("subgraph:actions:listAllSales");
+
+export const listAllSales = async <T>(
+  apolloClient: ApolloClient<T>,
+  wildToken: string
+): Promise<TokenSaleCollection> => {
+  const collection: TokenSaleCollection = {};
+  const options: ListAllSalesQueryOptions = {
+    count: 1000,
+    skipCount: 0,
+  };
+
+  // eslint-disable-next-line no-constant-condition
+  let allSalesLength = 0;
+  /* eslint-disable-next-line no-constant-condition */
+  while (true) {
+    logger.trace(
+      `Querying for ${options.count} sales starting at ${options.skipCount}`
+    );
+
+    const sales = await helpers.listSales(
+      apolloClient,
+      queries.getAllTokenSales,
+      options,
+      wildToken
+    );
+
+    for (const sale of sales) {
+      if (!collection[sale.tokenId]) {
+        collection[sale.tokenId] = [];
+      }
+
+      collection[sale.tokenId].push(sale);
+      allSalesLength++;
+    }
+
+    /**
+     * We will only get back up to `queryCount` # of sales
+     * So if we get that many there's probably more sales we need
+     * to fetch. If we got back less, we can stop querying
+     */
+    if (sales.length < options.count) {
+      break;
+    }
+    options.skipCount += sales.length;
+  }
+
+  logger.trace(`Found ${allSalesLength} sales for all domains`);
+  return collection;
+};

package/src/subgraph/actions/listBuyNowSales.ts

@@ -0,0 +1,44 @@
+import { ApolloClient } from "@apollo/client/core";
+import { TokenBuyNowSalesDto } from "../types";
+import * as queries from "../queries";
+import { TokenBuy } from "../../types";
+import { getLogger } from "../../utilities";
+
+const logger = getLogger("subgraph:actions:listBuyNowSales");
+
+export const listBuyNowSales = async <T>(
+  apolloClient: ApolloClient<T>,
+  contractAddress: string,
+  tokenId: string,
+  wildToken: string
+): Promise<TokenBuy[]> => {
+  logger.trace(`Querying "buy now" sales for domain with ID ${tokenId}`);
+  const queryResult = await apolloClient.query<TokenBuyNowSalesDto>({
+    query: queries.getBuyNowTokenSales,
+    variables: {
+      contractAddress: contractAddress.toLowerCase(),
+      tokenId,
+    },
+  });
+
+  if (queryResult.error) {
+    throw queryResult.error;
+  }
+
+  const buys: TokenBuy[] = queryResult.data.domainTokenSolds.map((e) => {
+    const buy: TokenBuy = {
+      tokenId: e.tokenId,
+      contract: e.contractAddress,
+      amount: e.amount,
+      seller: e.seller.id,
+      buyer: e.buyer.id,
+      timestamp: e.timestamp,
+      paymentToken: e.paymentToken ?? wildToken,
+      topLevelDomainId: e.topLevelDomainId,
+    };
+    return buy;
+  });
+
+  logger.trace(`Found ${buys.length} buy now sales`);
+  return buys;
+};

package/src/subgraph/actions/listSales.ts

@@ -0,0 +1,33 @@
+import { ApolloClient } from "@apollo/client/core";
+import { ListSalesQueryOptions } from "../types";
+import * as queries from "../queries";
+import { TokenSale } from "../../types";
+import { getLogger } from "../../utilities";
+
+const logger = getLogger("subgraph:actions:listSales");
+
+import * as helpers from "../helpers";
+
+export const listSales = async <T>(
+  apolloClient: ApolloClient<T>,
+  contract: string,
+  tokenId: string,
+  wildToken: string
+): Promise<TokenSale[]> => {
+  logger.trace(`Querying sales for domain with ID ${tokenId}`);
+
+  const options: ListSalesQueryOptions = {
+    contract: contract.toLowerCase(),
+    tokenId,
+  };
+
+  const sales = await helpers.listSales(
+    apolloClient,
+    queries.getTokenSalesForNftQuery,
+    options,
+    wildToken
+  );
+
+  logger.trace(`Found ${sales.length} sales`);
+  return sales;
+};