@zero-tech/zauction-sdk 0.2.10 → 0.2.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zero-tech/zauction-sdk",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "repository": "git@github.com:zer0-os/zAuction-SDK.git",
@@ -10,7 +10,8 @@
     "yarn": ">=1.15.2"
   },
   "files": [
-    "lib/"
+    "lib/",
+    "src/"
   ],
   "scripts": {
     "build": "tsc --build --verbose ./tsconfig.build.json",

package/src/actions/acceptBid.ts

@@ -0,0 +1,167 @@
+import { ethers } from "ethers";
+import {
+  getERC721Contract,
+  getZAuctionContract,
+  getZAuctionV1Contract,
+  getZnsHubContract,
+} from "../contracts";
+import { IERC721, IZNSHub, ZAuction, ZAuctionV1 } from "../contracts/types";
+import { Bid, Config } from "../types";
+import { getLogger } from "../utilities";
+
+const logger = getLogger("actions:acceptBid");
+
+const verifyAccount = async (
+  zAuction: ZAuction | ZAuctionV1,
+  data: string,
+  signedMessage: string,
+  bidder: string
+): Promise<void> => {
+  const unsignedMessage = await zAuction.toEthSignedMessageHash(
+    ethers.utils.arrayify(data)
+  );
+
+  const recoveredAccount = await zAuction.recover(
+    unsignedMessage,
+    signedMessage
+  );
+
+  if (recoveredAccount !== bidder) {
+    throw Error("Recovered incorrect account");
+  }
+};
+
+// Accept a bid for a domain, supporting legacy bids
+export const acceptBid = async (
+  bid: Bid,
+  signer: ethers.Signer,
+  config: Config
+): Promise<ethers.ContractTransaction> => {
+  logger.trace(
+    `Calling to accept a bid by user ${bid.bidder} with bidNonce of ${bid.bidNonce}`
+  );
+
+  // If not explicitly v2 bid, then assume v1
+  const isVersion2 = bid.version === "2.0";
+
+  // route to legacy if version 1.0
+  const zAuctionAddress = isVersion2
+    ? config.zAuctionAddress
+    : config.zAuctionLegacyAddress;
+
+  const hub: IZNSHub = await getZnsHubContract(signer, config.znsHubAddress);
+  const domainContract = await hub.getRegistrarForDomain(bid.tokenId);
+  const nftContract: IERC721 = await getERC721Contract(signer, domainContract);
+
+  const owner = await nftContract.ownerOf(bid.tokenId);
+  const signerAddress = await signer.getAddress();
+
+  if (owner !== signerAddress) {
+    throw Error("Cannot accept a bid for a domain that is not yours");
+  }
+  if (owner === bid.bidder) {
+    throw Error("Cannot sell to self");
+  }
+
+  if (isVersion2) {
+    const zAuction: ZAuction = await getZAuctionContract(
+      signer,
+      zAuctionAddress
+    );
+
+    if (bid.bidToken) {
+      // v2.1 bid
+      logger.trace(
+        `v2.1 Bid: Payment token for domain ${bid.tokenId} is ${bid.bidToken}`
+      );
+
+      const data = await zAuction.createBidV2(
+        bid.bidNonce,
+        bid.amount,
+        bid.tokenId,
+        "0",
+        bid.startBlock,
+        bid.expireBlock,
+        bid.bidToken
+      );
+
+      await verifyAccount(zAuction, data, bid.signedMessage, bid.bidder);
+
+      const tx = await zAuction.connect(signer).acceptBidV2(
+        bid.signedMessage,
+        bid.bidNonce,
+        bid.bidder,
+        bid.amount,
+        bid.tokenId,
+        "0", // minimum bid as string
+        bid.startBlock,
+        bid.expireBlock,
+        bid.bidToken
+      );
+
+      return tx;
+    }
+    // v2.0 bid
+    logger.trace(
+      `v2.0 Bid: Payment token for domain ${bid.tokenId} is ${config.wildTokenAddress}`
+    );
+    const data = await zAuction.createBid(
+      bid.bidNonce,
+      bid.amount,
+      bid.contract,
+      bid.tokenId,
+      "0",
+      bid.startBlock,
+      bid.expireBlock
+    );
+
+    await verifyAccount(zAuction, data, bid.signedMessage, bid.bidder);
+
+    const tx = await zAuction.connect(signer).acceptBid(
+      bid.signedMessage,
+      bid.bidNonce,
+      bid.bidder,
+      bid.amount,
+      bid.tokenId,
+      "0", // minimum bid
+      bid.startBlock,
+      bid.expireBlock
+    );
+    return tx;
+  }
+  //v1 legacy bid
+  const zAuctionV1: ZAuctionV1 = await getZAuctionV1Contract(
+    signer,
+    zAuctionAddress
+  );
+
+  logger.trace(
+    `v1.0 Bid: Payment token for domain ${bid.tokenId} is ${config.wildTokenAddress}`
+  );
+  const data = await zAuctionV1.createBid(
+    bid.bidNonce,
+    bid.amount,
+    bid.contract,
+    bid.tokenId,
+    "0",
+    bid.startBlock,
+    bid.expireBlock
+  );
+
+  await verifyAccount(zAuctionV1, data, bid.signedMessage, bid.bidder);
+
+  // For any v1 bid this will always return the default registrar
+  // const registrar = await hub.getRegistrarForDomain(bid.tokenId);
+  const tx = await zAuctionV1.connect(signer).acceptBid(
+    bid.signedMessage,
+    bid.bidNonce,
+    bid.bidder,
+    bid.amount,
+    bid.contract,
+    bid.tokenId,
+    "0", // minimum bid as string
+    bid.startBlock,
+    bid.expireBlock
+  );
+  return tx;
+};

package/src/actions/approveDomainTransfer.ts

@@ -0,0 +1,25 @@
+import { ethers } from "ethers";
+import { getERC721Contract } from "../contracts";
+
+import { getLogger } from "../utilities";
+
+const logger = getLogger("actions:approveDomainTransfer");
+
+// Approve zAuction to transfer domains on behalf of the signer
+export const approveDomainTransfer = async (
+  domainContractAddress: string,
+  zAuctionAddress: string,
+  signer: ethers.Signer
+): Promise<ethers.ContractTransaction> => {
+  const signerAddress = await signer.getAddress();
+  const nftContract = await getERC721Contract(signer, domainContractAddress);
+
+  const tx = await nftContract
+    .connect(signer)
+    .setApprovalForAll(zAuctionAddress, true);
+
+  logger.trace(
+    `User ${signerAddress} has approved zAuction to transfer domains from ${domainContractAddress}`
+  );
+  return tx;
+};

package/src/actions/approveSpender.ts

@@ -0,0 +1,27 @@
+import { ethers } from "ethers";
+import { getERC20Contract } from "../contracts";
+import { IERC20 } from "../contracts/types";
+import { getLogger } from "../utilities";
+
+const logger = getLogger("actions:approveSpender");
+
+// Approve zAuction to spend ERC20 tokens on behalf of the signer
+export const approveSpender = async (
+  paymentTokenAddress: string,
+  zAuctionAddress: string,
+  signer: ethers.Signer
+): Promise<ethers.ContractTransaction> => {
+  const signerAddress = await signer.getAddress();
+
+  const paymentToken: IERC20 = await getERC20Contract(
+    signer,
+    paymentTokenAddress
+  );
+  const tx = await paymentToken
+    .connect(signer)
+    .approve(zAuctionAddress, ethers.constants.MaxUint256);
+  logger.trace(
+    `User ${signerAddress} has approved zAuction to spend ${paymentToken}`
+  );
+  return tx;
+};

package/src/actions/buyNow.ts

@@ -0,0 +1,109 @@
+import { ethers } from "ethers";
+import {
+  getERC721Contract,
+  getZAuctionContract,
+  getZnsHubContract,
+} from "../contracts";
+import { ZAuction } from "../contracts/types";
+import { BuyNowParams, Config, BuyNowListing } from "../types";
+import { getPaymentTokenAllowance } from "./getPaymentTokenAllowance";
+import { isZAuctionApprovedNftTransfer } from "./isZAuctionApproved";
+import { getLogger } from "../utilities";
+
+const logger = getLogger("actions:buyNow");
+
+// Perform an immediate buy, supporting legacy domain listings
+export const buyNow = async (
+  params: BuyNowParams,
+  signer: ethers.Signer,
+  config: Config
+): Promise<ethers.ContractTransaction> => {
+  const buyer = await signer.getAddress();
+
+  logger.trace(
+    `Calling from user ${buyer} for domain ${params.tokenId} to buy now`
+  );
+  const hub = await getZnsHubContract(signer, config.znsHubAddress);
+  const tokenContract = await hub.getRegistrarForDomain(params.tokenId);
+
+  const nftContract = await getERC721Contract(signer, tokenContract);
+
+  const seller = await nftContract.ownerOf(params.tokenId);
+
+  const isApproved = await isZAuctionApprovedNftTransfer(
+    seller,
+    config.zAuctionAddress,
+    nftContract
+  );
+
+  if (!isApproved) {
+    throw Error("Seller did not approve zAuction to transfer NFT");
+  }
+
+  if (seller === buyer) {
+    throw Error("Cannot sell a domain to yourself");
+  }
+
+  const zAuction: ZAuction = await getZAuctionContract(
+    signer,
+    config.zAuctionAddress
+  );
+
+  const listing: BuyNowListing = await zAuction.priceInfo(params.tokenId);
+
+  if (listing.price.eq("0")) {
+    throw Error("Domain is not for sale");
+  }
+  if (!listing.price.eq(params.amount)) {
+    throw Error("Incorrect buyNow price given");
+  }
+
+  if (
+    !listing.paymentToken ||
+    listing.paymentToken === ethers.constants.AddressZero
+  ) {
+    logger.trace(
+      `Payment token for domain ${params.tokenId} is ${config.wildTokenAddress}`
+    );
+    // If no bidToken exists it is not a v2.1 listing, use WILD
+    const allowance = await getPaymentTokenAllowance(
+      buyer,
+      config.wildTokenAddress,
+      config.web3Provider,
+      config.zAuctionAddress
+    );
+
+    // Ensure buyer has approved zAuction to transfer tokens on their behalf
+    if (allowance.lt(params.amount)) {
+      throw Error("zAuction is not approved to transfer this many tokens");
+    }
+
+    const tx = await zAuction
+      .connect(signer)
+      .buyNow(params.amount, params.tokenId);
+
+    return tx;
+  }
+
+  logger.trace(
+    `Payment token for domain ${params.tokenId} is ${listing.paymentToken}`
+  );
+
+  const allowance = await getPaymentTokenAllowance(
+    buyer,
+    listing.paymentToken,
+    config.web3Provider,
+    config.zAuctionAddress
+  );
+
+  // Ensure buyer has approved zAuction to transfer tokens on their behalf
+  if (allowance.lt(params.amount)) {
+    throw Error("zAuction is not approved to transfer this many tokens");
+  }
+
+  const tx = await zAuction
+    .connect(signer)
+    .buyNowV2(params.amount, params.tokenId);
+
+  return tx;
+};

package/src/actions/cancelBid.ts

@@ -0,0 +1,37 @@
+import { ethers } from "ethers";
+import { ApiClient } from "../api";
+import { getZAuctionContract } from "../contracts";
+import { Bid } from "../types";
+import { getLogger } from "../utilities";
+
+const logger = getLogger("actions:cancelBid");
+
+// Cancel a bid for a domain, supporting legacy bids
+export const cancelBid = async (
+  bid: Bid,
+  cancelOnChain: boolean,
+  apiClient: ApiClient,
+  zAuctionAddress: string,
+  signer: ethers.Signer
+): Promise<ethers.ContractTransaction | void> => {
+  logger.trace(
+    `Calling to cancel a bid by user ${bid.bidder} with bid nonce of ${bid.bidNonce}`
+  );
+  const encodedCancelMessage = await apiClient.encodeCancelBid(
+    bid.signedMessage
+  );
+  const signedCancelMessage = await signer.signMessage(encodedCancelMessage);
+
+  // Always cancel the bid through the API
+  await apiClient.submitCancelBid(signedCancelMessage, bid.signedMessage);
+
+  // If enabled, also cancel the bid with the zAuction smart contract
+  if (cancelOnChain) {
+    const zAuction = await getZAuctionContract(signer, zAuctionAddress);
+
+    const account = await signer.getAddress();
+
+    const tx = await zAuction.connect(signer).cancelBid(account, bid.bidNonce);
+    return tx;
+  }
+};

package/src/actions/getBuyNowListing.ts

@@ -0,0 +1,65 @@
+import { ethers } from "ethers";
+import {
+  getERC721Contract,
+  getZAuctionContract,
+  getZnsHubContract,
+} from "../contracts";
+import { BuyNowListing, Config } from "../types";
+import { Maybe, getLogger } from "../utilities";
+
+const logger = getLogger("actions:getBuyNowListing");
+
+export const getBuyNowListing = async (
+  tokenId: string,
+  config: Config
+): Promise<Maybe<BuyNowListing>> => {
+  if (!tokenId || tokenId === ethers.constants.HashZero) {
+    throw Error("Must provide a valid tokenId");
+  }
+
+  const contract = await getZAuctionContract(
+    config.web3Provider,
+    config.zAuctionAddress
+  );
+
+  const hub = await getZnsHubContract(
+    config.web3Provider,
+    config.znsHubAddress
+  );
+
+  const registrarAddress = await hub.getRegistrarForDomain(tokenId);
+
+  const tokenContract = await getERC721Contract(
+    config.web3Provider,
+    registrarAddress
+  );
+
+  const owner = await tokenContract.ownerOf(tokenId);
+  const listing: BuyNowListing = await contract.priceInfo(tokenId);
+
+  if (listing.holder !== owner) {
+    logger.trace(
+      `Domain with ID ${tokenId} has changed owners since this buyNow listing was created so it is invalid`
+    );
+    return undefined;
+  }
+
+  if (listing.price.eq("0")) {
+    logger.trace(
+      `Domain with ID ${tokenId} is currently not listed for buyNow`
+    );
+    return undefined;
+  }
+
+  if (listing.paymentToken === ethers.constants.AddressZero) {
+    // Object is readonly, must make a new listing with payment token info
+    const newListing: BuyNowListing = {
+      holder: listing.holder,
+      price: listing.price,
+      paymentToken: config.wildTokenAddress,
+    };
+    return newListing;
+  }
+
+  return listing;
+};

package/src/actions/getPaymentTokenAllowance.ts

@@ -0,0 +1,30 @@
+import { ethers } from "ethers";
+import { getERC20Contract } from "../contracts";
+import { IERC20 } from "../contracts/types";
+import { getLogger } from "../utilities";
+
+const logger = getLogger("actions:getPaymentTokenAllowance");
+
+// Return the amount the given account has allowed zAuction to spend on its behalf
+export const getPaymentTokenAllowance = async (
+  account: string,
+  paymentTokenAddress: string,
+  provider: ethers.providers.Provider | ethers.Signer,
+  zAuctionAddress: string
+): Promise<ethers.BigNumber> => {
+  logger.trace(
+    `Calling to get allowance for user ${account} with payment token ${paymentTokenAddress}`
+  );
+  const paymentToken: IERC20 = await getERC20Contract(
+    provider,
+    paymentTokenAddress
+  );
+  const allowance = await paymentToken.allowance(account, zAuctionAddress);
+
+  logger.trace(
+    `User ${account} has allowance of ${ethers.utils
+      .formatEther(allowance)
+      .toString()} for payment token ${paymentToken}`
+  );
+  return allowance;
+};

package/src/actions/index.ts

@@ -0,0 +1,11 @@
+export * from "./placeBid";
+export * from "./isZAuctionApproved";
+export * from "./acceptBid";
+export * from "./cancelBid";
+export * from "./buyNow";
+export * from "./approveSpender";
+export * from "./approveDomainTransfer";
+export * from "./getPaymentTokenAllowance";
+export * from "./getBuyNowListing";
+export * from "./setNetworkPaymentToken";
+export * from "./setBuyNowPrice";

package/src/actions/isZAuctionApproved.ts

@@ -0,0 +1,20 @@
+import { IERC721 } from "../contracts/types";
+import { getLogger } from "../utilities";
+
+const logger = getLogger("actions:isZAuctionApprovedNftTransfer");
+
+// Check whether or not zAuction is approved to transfer NFTs for the user
+export const isZAuctionApprovedNftTransfer = async (
+  account: string,
+  zAuctionAddress: string,
+  nftContract: IERC721
+): Promise<boolean> => {
+  const isApproved = await nftContract.isApprovedForAll(
+    account,
+    zAuctionAddress
+  );
+  logger.trace(
+    `User ${account} has approved zAuction to transfer NFTs: ${isApproved}`
+  );
+  return isApproved;
+};

package/src/actions/placeBid.ts

@@ -0,0 +1,102 @@
+import { ethers } from "ethers";
+import { BidParameters, SignableBid, SignedBid } from "../api/types";
+import { getZAuctionContract, getZnsHubContract } from "../contracts";
+
+import {
+  PlaceBidStatus,
+  PlaceBidStatusCallback,
+  NewBidParameters,
+  Config,
+} from "../types";
+import { Maybe } from "../utilities";
+import { getLogger } from "../utilities";
+
+const logger = getLogger("actions:placeBid");
+
+type SignMessageFunction = (
+  message: string | ethers.utils.Bytes
+) => Promise<string>;
+type EncodeBidFunction = (bidParams: BidParameters) => Promise<SignableBid>;
+type SubmitBidFunction = (signedBid: SignedBid) => Promise<void>;
+
+export interface PlaceBidActionParameters {
+  bid: NewBidParameters;
+  config: Config;
+  bidder: string;
+  encodeBid: EncodeBidFunction;
+  signMessage: SignMessageFunction;
+  submitBid: SubmitBidFunction;
+  statusCallback?: PlaceBidStatusCallback;
+}
+
+export const placeBid = async (
+  params: PlaceBidActionParameters
+): Promise<void> => {
+  params.statusCallback ? params.statusCallback(PlaceBidStatus.Encoding) : null;
+
+  const contract = await getZAuctionContract(
+    params.config.web3Provider,
+    params.config.zAuctionAddress
+  );
+  const paymentToken = await contract.getPaymentTokenForDomain(
+    params.bid.tokenId
+  );
+  logger.trace(
+    `Calling to place a bid by user ${params.bidder} for ${params.bid.bidAmount} of ERC20 token ${paymentToken} on domain ${params.bid.tokenId}`
+  );
+
+  const hub = await getZnsHubContract(
+    params.config.web3Provider,
+    params.config.znsHubAddress
+  );
+  const registrar = await hub.getRegistrarForDomain(params.bid.tokenId);
+
+  let signableBid: Maybe<SignableBid>;
+
+  const bidParams: BidParameters = {
+    bidder: params.bidder,
+    tokenId: params.bid.tokenId,
+    contract: registrar,
+    amount: params.bid.bidAmount,
+    startBlock: params.bid.startBlock ?? "0",
+    expireBlock: params.bid.expireBlock ?? "9999999999",
+    bidToken: paymentToken,
+  };
+  try {
+    signableBid = await params.encodeBid(bidParams);
+  } catch (e) {
+    throw Error(`Failed to encode bid: ${e}`);
+  }
+
+  params.statusCallback ? params.statusCallback(PlaceBidStatus.Signing) : null;
+
+  let signedBidMessage: Maybe<string>;
+  try {
+    signedBidMessage = await params.signMessage(
+      ethers.utils.arrayify(signableBid.message)
+    );
+  } catch (e) {
+    throw Error(`Failed to sign bid message: ${e}`);
+  }
+
+  params.statusCallback
+    ? params.statusCallback(PlaceBidStatus.Submitting)
+    : null;
+
+  try {
+    await params.submitBid({
+      bid: signableBid.bid,
+      signedMessage: signedBidMessage,
+    } as SignedBid);
+  } catch (e) {
+    throw Error(`Failed to submit bid: ${e}`);
+  }
+
+  logger.trace(
+    `Bid with bidNonce of ${signableBid.bid.bidNonce} submitted successfully`
+  );
+
+  params.statusCallback
+    ? params.statusCallback(PlaceBidStatus.Completed)
+    : null;
+};

package/src/actions/setBuyNowPrice.ts

@@ -0,0 +1,56 @@
+import { ethers } from "ethers";
+import {
+  getERC721Contract,
+  getZAuctionContract,
+  getZnsHubContract,
+} from "../contracts";
+import { IZNSHub } from "../contracts/types";
+import { BuyNowParams } from "../types";
+
+import { isZAuctionApprovedNftTransfer } from "./isZAuctionApproved";
+
+export const setBuyNowPrice = async (
+  params: BuyNowParams,
+  signer: ethers.Signer,
+  znsHubAddress: string,
+  zAuctionAddress: string
+): Promise<ethers.ContractTransaction> => {
+  const hub: IZNSHub = await getZnsHubContract(signer, znsHubAddress);
+  const domainContract = await hub.getRegistrarForDomain(params.tokenId);
+
+  const nftContract = await getERC721Contract(signer, domainContract);
+
+  const owner = await nftContract.ownerOf(params.tokenId);
+  const givenSeller = await signer.getAddress();
+
+  if (givenSeller !== owner) {
+    throw Error("Cannot set the price of a domain that is not yours");
+  }
+
+  // Seller must have approved zAuction to transfer their NFT(s)
+  // before being able to set a buy price
+  const isApproved = await isZAuctionApprovedNftTransfer(
+    owner,
+    zAuctionAddress,
+    nftContract
+  );
+
+  if (!isApproved) {
+    throw Error("Seller did not approve zAuction to transfer NFT");
+  }
+
+  const contract = await getZAuctionContract(signer, zAuctionAddress);
+
+  const listing = await contract.priceInfo(params.tokenId);
+
+  if (listing.price.eq(params.amount)) {
+    throw Error(
+      "Unable to set price if a listing with that price already exists"
+    );
+  }
+
+  const tx = await contract
+    .connect(signer)
+    .setBuyPrice(params.amount, params.tokenId);
+  return tx;
+};