@zero-tech/zauction-sdk 0.2.10 → 0.2.12

package/src/actions/setNetworkPaymentToken.ts

@@ -0,0 +1,46 @@
+import { ethers } from "ethers";
+import { getZAuctionContract, getZnsHubContract } from "../contracts";
+import { Config } from "../types";
+import { getLogger } from "../utilities";
+
+const logger = getLogger("sdk:actions:setNetworkPaymentToken");
+
+export const setNetworkPaymentToken = async (
+  networkId: string,
+  paymentToken: string,
+  signer: ethers.Signer,
+  config: Config
+): Promise<ethers.ContractTransaction> => {
+  logger.trace(
+    `Calling to set network payment token for ${networkId} with ${paymentToken}`
+  );
+  const contract = await getZAuctionContract(
+    config.web3Provider,
+    config.zAuctionAddress
+  );
+  const hub = await getZnsHubContract(
+    config.web3Provider,
+    config.znsHubAddress
+  );
+  const parent = await hub.parentOf(networkId);
+
+  if (!parent.eq(ethers.constants.HashZero)) {
+    throw Error("Can only set network payment tokens on network domains");
+  }
+  const zAuctionOwner = await contract.owner();
+  const signerAddress = await signer.getAddress();
+
+  if (signerAddress !== zAuctionOwner) {
+    throw Error(
+      "Cannot set a network's token for zAuction if you are not the owner"
+    );
+  }
+
+  const tx = await contract
+    .connect(signer)
+    .setNetworkToken(networkId, paymentToken);
+  logger.trace(
+    `Call to setNetwnetwork payment token for ${networkId} with ${paymentToken}`
+  );
+  return tx;
+};

package/src/api/actions/encodeBid.ts

@@ -0,0 +1,44 @@
+import { BidMessage, BidParameters, SignableBid } from "../types";
+import { makeApiCall } from "./helpers";
+import { getLogger } from "../../utilities";
+
+const logger = getLogger("api:actions:encodeBid");
+
+interface EncodeBidDto {
+  payload: string;
+  bidNonce: string;
+  nftId: string;
+}
+
+export const encodeBid = async (
+  apiUrl: string,
+  bidParams: BidParameters
+): Promise<SignableBid> => {
+  const uri = `${apiUrl}/bid`;
+
+  logger.trace(
+    `Encoding bid at ${uri} by ${bidParams.bidder} for amount ${bidParams.amount} of ERC20 token ${bidParams.bidToken}`
+  );
+
+  const response = await makeApiCall<EncodeBidDto>(uri, "POST", {
+    bidAmount: bidParams.amount,
+    tokenId: bidParams.tokenId,
+    contractAddress: bidParams.contract,
+    minimumBid: "0",
+    startBlock: bidParams.startBlock,
+    expireBlock: bidParams.expireBlock,
+    bidToken: bidParams.bidToken,
+  });
+
+  const bidToSign: SignableBid = {
+    bid: {
+      bidNonce: response.bidNonce,
+      ...bidParams,
+    } as BidMessage,
+    message: response.payload,
+  };
+  logger.trace(
+    `Created bid to sign ${bidToSign.message} with bid nonce ${bidToSign.bid.bidNonce}`
+  );
+  return bidToSign;
+};

package/src/api/actions/encodeCancelMessage.ts

@@ -0,0 +1,24 @@
+import { makeApiCall } from "./helpers";
+import { getLogger } from "../../utilities";
+
+const logger = getLogger("api:actions:encodeCancelMessage");
+
+interface EncodeCancelBidDto {
+  hashedCancelMessage: string;
+}
+
+export const encodeCancelMessage = async (
+  apiUrl: string,
+  signedBidMessage: string
+): Promise<string> => {
+  const uri = `${apiUrl}/bid/cancel/encode`;
+  logger.trace(
+    `Calling to encode a cancel message at ${uri} for bid with a signed message of ${signedBidMessage}`
+  );
+  const response = await makeApiCall<EncodeCancelBidDto>(uri, "POST", {
+    bidMessageSignature: signedBidMessage,
+  });
+
+  logger.trace(`Created message ${response.hashedCancelMessage} for signing`);
+  return response.hashedCancelMessage;
+};

package/src/api/actions/helpers.ts

@@ -0,0 +1,61 @@
+import fetch from "cross-fetch";
+import { Bid } from "../../types";
+import { BidDto } from "../types";
+
+export const makeApiCall = async <T>(
+  url: string,
+  method: "GET" | "POST",
+  body?: string | Record<string, unknown>,
+  softFail?: boolean,
+  softFailMessage?: string
+): Promise<T> => {
+  const headers: Record<string, string> = {};
+
+  if (body) {
+    if (typeof body !== "string") {
+      body = JSON.stringify(body);
+      headers["Content-Type"] = "application/json";
+      headers["Access-Control-Allow-Origin"] = "*";
+    }
+  }
+
+  const res = await fetch(url, {
+    method,
+    body,
+    headers,
+  });
+
+  if (res.status !== 200 && !softFail) {
+    throw Error(`Request failed with code ${res.status}: ${await res.text()}`);
+  }
+
+  if (softFail) {
+    const returnedBody = await res.json();
+    returnedBody["softFailMessage"] = softFailMessage;
+    return returnedBody as T;
+  } else {
+    const returnedBody = await res.json();
+    return returnedBody as T;
+  }
+};
+
+export const convertBidDtoToBid = (
+  bid: BidDto,
+  wildTokenAddress: string
+): Bid => {
+  const localBid: Bid = {
+    bidNonce: bid.bidNonce,
+    bidder: bid.account,
+    bidToken: bid.bidToken ?? wildTokenAddress,
+    contract: bid.contractAddress,
+    tokenId: bid.tokenId,
+    amount: bid.bidAmount,
+    startBlock: bid.startBlock,
+    expireBlock: bid.expireBlock,
+    signedMessage: bid.signedMessage,
+    timestamp: bid.date.toString(),
+    version: bid.version,
+  };
+
+  return localBid;
+};

package/src/api/actions/index.ts

@@ -0,0 +1,6 @@
+export * from "./listBidsForTokens";
+export * from "./listBidsForAccount";
+export * from "./encodeBid";
+export * from "./submitBid";
+export * from "./encodeCancelMessage";
+export * from "./submitCancelMessage";

package/src/api/actions/listBidsForAccount.ts

@@ -0,0 +1,24 @@
+import { Bid } from "../../types";
+import { BidDto } from "../types";
+import { convertBidDtoToBid, makeApiCall } from "./helpers";
+import { getLogger } from "../../utilities";
+
+const logger = getLogger("api:actions:listBidsForAccount");
+
+type AccountBidsDto = BidDto[];
+
+export const listBidsForAccount = async (
+  apiUrl: string,
+  account: string,
+  wildTokenAddress: string
+): Promise<Bid[]> => {
+  const uri = `${apiUrl}/bids/accounts/${account}`;
+  logger.trace(`Calling ${uri} to get bids for account ${account}`);
+  const response = await makeApiCall<AccountBidsDto>(uri, "GET");
+
+  const bids: Bid[] = response.map((e) =>
+    convertBidDtoToBid(e, wildTokenAddress)
+  );
+  logger.trace(`Found ${bids.length} bids created by $${account}`);
+  return bids;
+};

package/src/api/actions/listBidsForTokens.ts

@@ -0,0 +1,39 @@
+import { TokenBidCollection, TokenBidFilter } from "../../types";
+import { BidDto } from "../types";
+import { convertBidDtoToBid, makeApiCall } from "./helpers";
+
+import { getLogger } from "../../utilities";
+
+const logger = getLogger("api:actions:listBidsForTokens");
+
+interface BidsBulkDto {
+  [tokenId: string]: BidDto[];
+}
+
+export const listBidsForTokens = async (
+  apiUrl: string,
+  wildTokenAddress: string,
+  tokenIds: string[],
+  filter?: TokenBidFilter
+): Promise<TokenBidCollection> => {
+  const bidCollection: TokenBidCollection = {};
+  let uri = `${apiUrl}/bids/list`;
+  uri = filter ? uri.concat(`?filter=${filter}`) : uri;
+  logger.trace(`Calling ${uri} to get bids for ${tokenIds.length} domains`);
+  const response = await makeApiCall<BidsBulkDto>(uri, "POST", {
+    tokenIds,
+  });
+
+  let totalBidsForDomains = 0;
+  for (const [tokenId, bids] of Object.entries(response)) {
+    bidCollection[tokenId] = bids.map((e) =>
+      convertBidDtoToBid(e, wildTokenAddress)
+    );
+    totalBidsForDomains += bids.length;
+  }
+  logger.trace(
+    `Found ${totalBidsForDomains} bids for $${tokenIds.length} domains`
+  );
+
+  return bidCollection;
+};

package/src/api/actions/submitBid.ts

@@ -0,0 +1,28 @@
+import { SignedBid } from "../types";
+import { makeApiCall } from "./helpers";
+import { getLogger } from "../../utilities";
+
+const logger = getLogger("api:actions:submitBid");
+
+export const submitBid = async (
+  apiUrl: string,
+  signedBid: SignedBid
+): Promise<void> => {
+  const uri = `${apiUrl}/bids`;
+  logger.trace(
+    `Calling ${uri} to submit bid with bid nonce ${signedBid.bid.bidNonce}}`
+  );
+
+  await makeApiCall(uri, "POST", {
+    account: signedBid.bid.bidder,
+    bidNonce: signedBid.bid.bidNonce,
+    tokenId: signedBid.bid.tokenId,
+    contractAddress: signedBid.bid.contract,
+    bidAmount: signedBid.bid.amount,
+    signedMessage: signedBid.signedMessage,
+    minimumBid: "0",
+    startBlock: signedBid.bid.startBlock,
+    expireBlock: signedBid.bid.expireBlock,
+    bidToken: signedBid.bid.bidToken,
+  });
+};

package/src/api/actions/submitCancelMessage.ts

@@ -0,0 +1,30 @@
+import { makeApiCall } from "./helpers";
+import { getLogger } from "../../utilities";
+
+const logger = getLogger("api:actions:submitBid");
+
+export const submitCancelMessage = async (
+  apiUrl: string,
+  signedCancelMessage: string,
+  signedBidMessage: string
+): Promise<void> => {
+  const uri = `${apiUrl}/bid/cancel`;
+  logger.trace(
+    `Calling ${uri} to submit cancelled bid with signed message${signedCancelMessage}}`
+  );
+
+  const softFailMessage =
+    "Already cancelled in the API but allowing execution to continue to cancel in the contract as well";
+
+  // Soft fail if the bid isn't found in the API
+  await makeApiCall(
+    uri,
+    "POST",
+    {
+      cancelMessageSignature: signedCancelMessage,
+      bidMessageSignature: signedBidMessage,
+    },
+    true,
+    softFailMessage
+  );
+};

package/src/api/client.ts

@@ -0,0 +1,78 @@
+import { TokenBidCollection, TokenBidFilter } from "../types";
+import * as actions from "./actions";
+import { Bid, BidParameters, SignableBid, SignedBid } from "./types";
+import { getLogger } from "../utilities";
+
+export interface ApiClient {
+  encodeBid: (bidParams: BidParameters) => Promise<SignableBid>;
+  submitBid: (signedBid: SignedBid) => Promise<void>;
+  encodeCancelBid: (signedBidMessage: string) => Promise<string>;
+  submitCancelBid: (
+    cancelMessageSignature: string,
+    bidMessageSignature: string
+  ) => Promise<void>;
+  listBidsForTokens: (
+    tokenIds: string[],
+    wildTokenAddress: string,
+    filter?: TokenBidFilter
+  ) => Promise<TokenBidCollection>;
+  listBidsByAccount: (
+    account: string,
+    wildTokenAddress: string
+  ) => Promise<Bid[]>;
+}
+
+export const createClient = (apiUri: string): ApiClient => {
+  const logger = getLogger("api:client");
+  const apiClient: ApiClient = {
+    encodeBid: async (bidParams: BidParameters): Promise<SignableBid> => {
+      logger.debug(`Encode bid with params ${bidParams}`);
+      return actions.encodeBid(apiUri, bidParams);
+    },
+    submitBid: (signedBid: SignedBid): Promise<void> => {
+      logger.debug(`Submit bid with signed message ${signedBid.signedMessage}`);
+      return actions.submitBid(apiUri, signedBid);
+    },
+    encodeCancelBid: async (signedBidMessage: string): Promise<string> => {
+      logger.debug(
+        `Encode to cancel a bid with signed message ${signedBidMessage}}`
+      );
+      return actions.encodeCancelMessage(apiUri, signedBidMessage);
+    },
+    submitCancelBid: async (
+      signedCancelMessage: string,
+      signedBidMessage: string
+    ): Promise<void> => {
+      logger.debug(
+        `Submit cancelled bid with signed message ${signedCancelMessage}`
+      );
+      actions.submitCancelMessage(
+        apiUri,
+        signedCancelMessage,
+        signedBidMessage
+      );
+    },
+    listBidsForTokens: (
+      tokenIds: string[],
+      wildTokenAddress: string,
+      filter?: TokenBidFilter
+    ): Promise<TokenBidCollection> => {
+      logger.debug(`List bids for domains ${tokenIds}`);
+      return actions.listBidsForTokens(
+        apiUri,
+        wildTokenAddress,
+        tokenIds,
+        filter
+      );
+    },
+    listBidsByAccount: (
+      account: string,
+      wildTokenAddress: string
+    ): Promise<Bid[]> => {
+      logger.debug(`List bids by account ${account}`);
+      return actions.listBidsForAccount(apiUri, account, wildTokenAddress);
+    },
+  };
+
+  return apiClient;
+};

package/src/api/index.ts

@@ -0,0 +1 @@
+export * from "./client";

package/src/api/types.ts

@@ -0,0 +1,47 @@
+export interface BidParamsDto {
+  account: string;
+  bidNonce: string;
+  bidAmount: string;
+  minimumBid: string;
+  contractAddress: string;
+  startBlock: string;
+  expireBlock: string;
+  tokenId: string;
+  bidToken?: string;
+}
+
+export interface BidDto extends BidParamsDto {
+  date: number;
+  signedMessage: string;
+  version: "1.0" | "2.0";
+}
+
+export interface BidParameters {
+  bidder: string;
+  contract: string;
+  tokenId: string;
+  amount: string;
+  startBlock: string;
+  expireBlock: string;
+  bidToken: string;
+}
+
+export interface BidMessage extends BidParameters {
+  bidNonce: string;
+}
+
+export interface SignableBid {
+  bid: BidMessage;
+  message: string;
+}
+
+export interface SignedBid {
+  bid: BidMessage;
+  signedMessage: string;
+}
+
+export interface Bid extends BidMessage {
+  signedMessage: string;
+  timestamp: string;
+  version: "1.0" | "2.0";
+}

package/src/contracts/index.ts

@@ -0,0 +1,53 @@
+import { ethers } from "ethers";
+import {
+  IERC20,
+  IERC20__factory,
+  IERC721,
+  IERC721__factory,
+  IZNSHub,
+  IZNSHub__factory,
+  ZAuction,
+  ZAuctionV1,
+  ZAuctionV1__factory,
+  ZAuction__factory,
+} from "./types";
+
+export const getZAuctionContract = async (
+  web3Provider: ethers.providers.Provider | ethers.Signer,
+  address: string
+): Promise<ZAuction> => {
+  const contract = ZAuction__factory.connect(address, web3Provider);
+  return contract;
+};
+
+export const getZAuctionV1Contract = async (
+  web3Provider: ethers.providers.Provider | ethers.Signer,
+  address: string // to change on new deployment
+): Promise<ZAuctionV1> => {
+  const contract = ZAuctionV1__factory.connect(address, web3Provider);
+  return contract;
+};
+
+export const getERC20Contract = async (
+  web3Provider: ethers.providers.Provider | ethers.Signer,
+  address: string
+): Promise<IERC20> => {
+  const contract = IERC20__factory.connect(address, web3Provider);
+  return contract;
+};
+
+export const getERC721Contract = async (
+  web3Provider: ethers.providers.Provider | ethers.Signer,
+  address: string
+): Promise<IERC721> => {
+  const contract = IERC721__factory.connect(address, web3Provider);
+  return contract;
+};
+
+export const getZnsHubContract = async (
+  web3Provider: ethers.providers.Provider | ethers.Signer,
+  address: string
+): Promise<IZNSHub> => {
+  const contract = IZNSHub__factory.connect(address, web3Provider);
+  return contract;
+};