@net-protocol/cli 0.1.47 → 0.2.0

package/dist/cli/index.mjs

@@ -1641,8 +1641,8 @@ function registerStorageCommand(program2) {
       console.log(chalk4.blue(`\u{1F4C1} Reading file: ${options.file}`));
       console.log(chalk4.blue(`\u{1F517} Using relay API: ${options.apiUrl}`));
       const result = await uploadFileWithRelay(uploadRelayOptions);
-      const { privateKeyToAccount: privateKeyToAccount28 } = await import('viem/accounts');
-      const userAccount = privateKeyToAccount28(commonOptions.privateKey);
+      const { privateKeyToAccount: privateKeyToAccount32 } = await import('viem/accounts');
+      const userAccount = privateKeyToAccount32(commonOptions.privateKey);
       const storageUrl2 = generateStorageUrl(
         userAccount.address,
         commonOptions.chainId,
@@ -4795,7 +4795,8 @@ async function executeCreateErc20Listing(options) {
       tokenAddress: options.tokenAddress,
       tokenAmount,
       priceWei,
-      offerer: account.address
+      offerer: account.address,
+      targetFulfiller: options.targetFulfiller
     });
     const rpcUrls = getChainRpcUrls({
       chainId: commonOptions.chainId,
@@ -4879,7 +4880,8 @@ async function executeKeylessMode3(options) {
       tokenAddress: options.tokenAddress,
       tokenAmount,
       priceWei,
-      offerer: options.offerer
+      offerer: options.offerer,
+      targetFulfiller: options.targetFulfiller
     });
     const output = {
       eip712: {
@@ -5487,6 +5489,386 @@ async function executeEncodeOnly10(options) {
     );
   }
 }
+function createWallet(privateKey, chainId, rpcUrl) {
+  const account = privateKeyToAccount(privateKey);
+  const rpcUrls = getChainRpcUrls({
+    chainId,
+    rpcUrl
+  });
+  return createWalletClient({
+    account,
+    transport: http(rpcUrls[0]),
+    dataSuffix: getBaseDataSuffix(chainId)
+  });
+}
+async function executeTransaction(walletClient, txConfig) {
+  const hash = await walletClient.writeContract({
+    address: txConfig.to,
+    abi: txConfig.abi,
+    functionName: txConfig.functionName,
+    args: txConfig.args,
+    value: txConfig.value,
+    chain: null
+  });
+  return hash;
+}
+
+// src/commands/bazaar/cancel-listing.ts
+async function executeCancelListing(options) {
+  if (options.encodeOnly) {
+    await executeEncodeOnly11(options);
+    return;
+  }
+  const commonOptions = parseCommonOptions(
+    {
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    },
+    true
+  );
+  const account = privateKeyToAccount(commonOptions.privateKey);
+  const bazaarClient = new BazaarClient({
+    chainId: commonOptions.chainId,
+    rpcUrl: commonOptions.rpcUrl
+  });
+  try {
+    console.log(chalk4.blue("Fetching listing..."));
+    const listings = await bazaarClient.getListings({
+      nftAddress: options.nftAddress,
+      maker: account.address,
+      includeExpired: true
+    });
+    const listing = listings.find(
+      (l) => l.orderHash.toLowerCase() === options.orderHash.toLowerCase()
+    );
+    if (!listing) {
+      exitWithError(
+        `Listing with order hash ${options.orderHash} not found for maker ${account.address}`
+      );
+    }
+    const cancelTx = bazaarClient.prepareCancelListing(listing);
+    const walletClient = createWallet(
+      commonOptions.privateKey,
+      commonOptions.chainId,
+      commonOptions.rpcUrl
+    );
+    console.log(chalk4.blue("Sending cancel transaction..."));
+    const hash = await executeTransaction(walletClient, cancelTx);
+    console.log(
+      chalk4.green(
+        `Listing cancelled successfully!
+  Transaction: ${hash}
+  NFT: ${listing.nftAddress} #${listing.tokenId}`
+      )
+    );
+  } catch (error) {
+    exitWithError(
+      `Failed to cancel listing: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeEncodeOnly11(options) {
+  if (!options.maker) {
+    exitWithError("--maker is required when using --encode-only without --private-key");
+  }
+  const readOnlyOptions = parseReadOnlyOptions({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const makerAddress = options.maker;
+  const bazaarClient = new BazaarClient({
+    chainId: readOnlyOptions.chainId,
+    rpcUrl: readOnlyOptions.rpcUrl
+  });
+  try {
+    const listings = await bazaarClient.getListings({
+      nftAddress: options.nftAddress,
+      maker: makerAddress,
+      includeExpired: true
+    });
+    const listing = listings.find(
+      (l) => l.orderHash.toLowerCase() === options.orderHash.toLowerCase()
+    );
+    if (!listing) {
+      exitWithError(
+        `Listing with order hash ${options.orderHash} not found for maker ${makerAddress}`
+      );
+    }
+    const cancelTx = bazaarClient.prepareCancelListing(listing);
+    console.log(JSON.stringify(encodeTransaction(cancelTx, readOnlyOptions.chainId), null, 2));
+  } catch (error) {
+    exitWithError(
+      `Failed to encode cancel listing: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeCancelOffer(options) {
+  if (options.encodeOnly) {
+    await executeEncodeOnly12(options);
+    return;
+  }
+  const commonOptions = parseCommonOptions(
+    {
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    },
+    true
+  );
+  const account = privateKeyToAccount(commonOptions.privateKey);
+  const bazaarClient = new BazaarClient({
+    chainId: commonOptions.chainId,
+    rpcUrl: commonOptions.rpcUrl
+  });
+  try {
+    console.log(chalk4.blue("Fetching collection offer..."));
+    const offers = await bazaarClient.getCollectionOffers({
+      nftAddress: options.nftAddress,
+      maker: account.address
+    });
+    const offer = offers.find(
+      (o) => o.orderHash.toLowerCase() === options.orderHash.toLowerCase()
+    );
+    if (!offer) {
+      exitWithError(
+        `Offer with order hash ${options.orderHash} not found for maker ${account.address}`
+      );
+    }
+    const cancelTx = bazaarClient.prepareCancelCollectionOffer(offer);
+    const walletClient = createWallet(
+      commonOptions.privateKey,
+      commonOptions.chainId,
+      commonOptions.rpcUrl
+    );
+    console.log(chalk4.blue("Sending cancel transaction..."));
+    const hash = await executeTransaction(walletClient, cancelTx);
+    console.log(
+      chalk4.green(
+        `Offer cancelled successfully!
+  Transaction: ${hash}
+  NFT: ${offer.nftAddress}
+  Price: ${offer.price} ${offer.currency.toUpperCase()}`
+      )
+    );
+  } catch (error) {
+    exitWithError(
+      `Failed to cancel offer: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeEncodeOnly12(options) {
+  if (!options.maker) {
+    exitWithError("--maker is required when using --encode-only without --private-key");
+  }
+  const readOnlyOptions = parseReadOnlyOptions({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const makerAddress = options.maker;
+  const bazaarClient = new BazaarClient({
+    chainId: readOnlyOptions.chainId,
+    rpcUrl: readOnlyOptions.rpcUrl
+  });
+  try {
+    const offers = await bazaarClient.getCollectionOffers({
+      nftAddress: options.nftAddress,
+      maker: makerAddress
+    });
+    const offer = offers.find(
+      (o) => o.orderHash.toLowerCase() === options.orderHash.toLowerCase()
+    );
+    if (!offer) {
+      exitWithError(
+        `Offer with order hash ${options.orderHash} not found for maker ${makerAddress}`
+      );
+    }
+    const cancelTx = bazaarClient.prepareCancelCollectionOffer(offer);
+    console.log(JSON.stringify(encodeTransaction(cancelTx, readOnlyOptions.chainId), null, 2));
+  } catch (error) {
+    exitWithError(
+      `Failed to encode cancel offer: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeCancelErc20Listing(options) {
+  if (options.encodeOnly) {
+    await executeEncodeOnly13(options);
+    return;
+  }
+  const commonOptions = parseCommonOptions(
+    {
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    },
+    true
+  );
+  const account = privateKeyToAccount(commonOptions.privateKey);
+  const bazaarClient = new BazaarClient({
+    chainId: commonOptions.chainId,
+    rpcUrl: commonOptions.rpcUrl
+  });
+  try {
+    console.log(chalk4.blue("Fetching ERC20 listing..."));
+    const listings = await bazaarClient.getErc20Listings({
+      tokenAddress: options.tokenAddress,
+      maker: account.address,
+      includeExpired: true
+    });
+    const listing = listings.find(
+      (l) => l.orderHash.toLowerCase() === options.orderHash.toLowerCase()
+    );
+    if (!listing) {
+      exitWithError(
+        `ERC20 listing with order hash ${options.orderHash} not found for maker ${account.address}`
+      );
+    }
+    const cancelTx = bazaarClient.prepareCancelErc20Listing(listing);
+    const walletClient = createWallet(
+      commonOptions.privateKey,
+      commonOptions.chainId,
+      commonOptions.rpcUrl
+    );
+    console.log(chalk4.blue("Sending cancel transaction..."));
+    const hash = await executeTransaction(walletClient, cancelTx);
+    console.log(
+      chalk4.green(
+        `ERC20 listing cancelled successfully!
+  Transaction: ${hash}
+  Token: ${listing.tokenAddress}
+  Amount: ${listing.tokenAmount.toString()}`
+      )
+    );
+  } catch (error) {
+    exitWithError(
+      `Failed to cancel ERC20 listing: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeEncodeOnly13(options) {
+  if (!options.maker) {
+    exitWithError("--maker is required when using --encode-only without --private-key");
+  }
+  const readOnlyOptions = parseReadOnlyOptions({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const makerAddress = options.maker;
+  const bazaarClient = new BazaarClient({
+    chainId: readOnlyOptions.chainId,
+    rpcUrl: readOnlyOptions.rpcUrl
+  });
+  try {
+    const listings = await bazaarClient.getErc20Listings({
+      tokenAddress: options.tokenAddress,
+      maker: makerAddress,
+      includeExpired: true
+    });
+    const listing = listings.find(
+      (l) => l.orderHash.toLowerCase() === options.orderHash.toLowerCase()
+    );
+    if (!listing) {
+      exitWithError(
+        `ERC20 listing with order hash ${options.orderHash} not found for maker ${makerAddress}`
+      );
+    }
+    const cancelTx = bazaarClient.prepareCancelErc20Listing(listing);
+    console.log(JSON.stringify(encodeTransaction(cancelTx, readOnlyOptions.chainId), null, 2));
+  } catch (error) {
+    exitWithError(
+      `Failed to encode cancel ERC20 listing: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeCancelErc20Offer(options) {
+  if (options.encodeOnly) {
+    await executeEncodeOnly14(options);
+    return;
+  }
+  const commonOptions = parseCommonOptions(
+    {
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    },
+    true
+  );
+  const account = privateKeyToAccount(commonOptions.privateKey);
+  const bazaarClient = new BazaarClient({
+    chainId: commonOptions.chainId,
+    rpcUrl: commonOptions.rpcUrl
+  });
+  try {
+    console.log(chalk4.blue("Fetching ERC20 offer..."));
+    const offers = await bazaarClient.getErc20Offers({
+      tokenAddress: options.tokenAddress,
+      maker: account.address
+    });
+    const offer = offers.find(
+      (o) => o.orderHash.toLowerCase() === options.orderHash.toLowerCase()
+    );
+    if (!offer) {
+      exitWithError(
+        `ERC20 offer with order hash ${options.orderHash} not found for maker ${account.address}`
+      );
+    }
+    const cancelTx = bazaarClient.prepareCancelErc20Offer(offer);
+    const walletClient = createWallet(
+      commonOptions.privateKey,
+      commonOptions.chainId,
+      commonOptions.rpcUrl
+    );
+    console.log(chalk4.blue("Sending cancel transaction..."));
+    const hash = await executeTransaction(walletClient, cancelTx);
+    console.log(
+      chalk4.green(
+        `ERC20 offer cancelled successfully!
+  Transaction: ${hash}
+  Token: ${offer.tokenAddress}
+  Amount: ${offer.tokenAmount.toString()}`
+      )
+    );
+  } catch (error) {
+    exitWithError(
+      `Failed to cancel ERC20 offer: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function executeEncodeOnly14(options) {
+  if (!options.maker) {
+    exitWithError("--maker is required when using --encode-only without --private-key");
+  }
+  const readOnlyOptions = parseReadOnlyOptions({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const makerAddress = options.maker;
+  const bazaarClient = new BazaarClient({
+    chainId: readOnlyOptions.chainId,
+    rpcUrl: readOnlyOptions.rpcUrl
+  });
+  try {
+    const offers = await bazaarClient.getErc20Offers({
+      tokenAddress: options.tokenAddress,
+      maker: makerAddress
+    });
+    const offer = offers.find(
+      (o) => o.orderHash.toLowerCase() === options.orderHash.toLowerCase()
+    );
+    if (!offer) {
+      exitWithError(
+        `ERC20 offer with order hash ${options.orderHash} not found for maker ${makerAddress}`
+      );
+    }
+    const cancelTx = bazaarClient.prepareCancelErc20Offer(offer);
+    console.log(JSON.stringify(encodeTransaction(cancelTx, readOnlyOptions.chainId), null, 2));
+  } catch (error) {
+    exitWithError(
+      `Failed to encode cancel ERC20 offer: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
 
 // src/commands/bazaar/index.ts
 var chainIdOption = [
@@ -5620,11 +6002,12 @@ function registerBazaarCommand(program2) {
       json: options.json
     });
   });
-  const createErc20ListingCommand = new Command("create-erc20-listing").description("Create an ERC-20 token listing (with --private-key: full flow; without: output EIP-712 data)").requiredOption("--token-address <address>", "ERC-20 token contract address").requiredOption("--token-amount <amount>", "Token amount in raw units (bigint string)").requiredOption("--price <eth>", "Total price in ETH for the token amount").option("--offerer <address>", "Offerer address (required without --private-key)").option(...privateKeyOption).option(...chainIdOption).option(...rpcUrlOption).action(async (options) => {
+  const createErc20ListingCommand = new Command("create-erc20-listing").description("Create an ERC-20 token listing (with --private-key: full flow; without: output EIP-712 data)").requiredOption("--token-address <address>", "ERC-20 token contract address").requiredOption("--token-amount <amount>", "Token amount in raw units (bigint string)").requiredOption("--price <eth>", "Total price in ETH for the token amount").option("--target-fulfiller <address>", "Make a private listing for this address").option("--offerer <address>", "Offerer address (required without --private-key)").option(...privateKeyOption).option(...chainIdOption).option(...rpcUrlOption).action(async (options) => {
     await executeCreateErc20Listing({
       tokenAddress: options.tokenAddress,
       tokenAmount: options.tokenAmount,
       price: options.price,
+      targetFulfiller: options.targetFulfiller,
       offerer: options.offerer,
       privateKey: options.privateKey,
       chainId: options.chainId,
@@ -5684,6 +6067,50 @@ function registerBazaarCommand(program2) {
       encodeOnly: options.encodeOnly
     });
   });
+  const cancelListingCommand = new Command("cancel-listing").description("Cancel an NFT listing you created").requiredOption("--order-hash <hash>", "Order hash of the listing to cancel").requiredOption("--nft-address <address>", "NFT contract address").option("--maker <address>", "Maker address (required with --encode-only)").option(...privateKeyOption).option(...chainIdOption).option(...rpcUrlOption).option("--encode-only", "Output transaction data as JSON instead of executing").action(async (options) => {
+    await executeCancelListing({
+      orderHash: options.orderHash,
+      nftAddress: options.nftAddress,
+      maker: options.maker,
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      encodeOnly: options.encodeOnly
+    });
+  });
+  const cancelOfferCommand = new Command("cancel-offer").description("Cancel a collection offer you created").requiredOption("--order-hash <hash>", "Order hash of the offer to cancel").requiredOption("--nft-address <address>", "NFT contract address").option("--maker <address>", "Maker address (required with --encode-only)").option(...privateKeyOption).option(...chainIdOption).option(...rpcUrlOption).option("--encode-only", "Output transaction data as JSON instead of executing").action(async (options) => {
+    await executeCancelOffer({
+      orderHash: options.orderHash,
+      nftAddress: options.nftAddress,
+      maker: options.maker,
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      encodeOnly: options.encodeOnly
+    });
+  });
+  const cancelErc20ListingCommand = new Command("cancel-erc20-listing").description("Cancel an ERC-20 listing you created").requiredOption("--order-hash <hash>", "Order hash of the listing to cancel").requiredOption("--token-address <address>", "ERC-20 token contract address").option("--maker <address>", "Maker address (required with --encode-only)").option(...privateKeyOption).option(...chainIdOption).option(...rpcUrlOption).option("--encode-only", "Output transaction data as JSON instead of executing").action(async (options) => {
+    await executeCancelErc20Listing({
+      orderHash: options.orderHash,
+      tokenAddress: options.tokenAddress,
+      maker: options.maker,
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      encodeOnly: options.encodeOnly
+    });
+  });
+  const cancelErc20OfferCommand = new Command("cancel-erc20-offer").description("Cancel an ERC-20 offer you created").requiredOption("--order-hash <hash>", "Order hash of the offer to cancel").requiredOption("--token-address <address>", "ERC-20 token contract address").option("--maker <address>", "Maker address (required with --encode-only)").option(...privateKeyOption).option(...chainIdOption).option(...rpcUrlOption).option("--encode-only", "Output transaction data as JSON instead of executing").action(async (options) => {
+    await executeCancelErc20Offer({
+      orderHash: options.orderHash,
+      tokenAddress: options.tokenAddress,
+      maker: options.maker,
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      encodeOnly: options.encodeOnly
+    });
+  });
   bazaarCommand.addCommand(listListingsCommand);
   bazaarCommand.addCommand(listOffersCommand);
   bazaarCommand.addCommand(listSalesCommand);
@@ -5702,6 +6129,10 @@ function registerBazaarCommand(program2) {
   bazaarCommand.addCommand(submitErc20OfferCommand);
   bazaarCommand.addCommand(buyErc20ListingCommand);
   bazaarCommand.addCommand(acceptErc20OfferCommand);
+  bazaarCommand.addCommand(cancelListingCommand);
+  bazaarCommand.addCommand(cancelOfferCommand);
+  bazaarCommand.addCommand(cancelErc20ListingCommand);
+  bazaarCommand.addCommand(cancelErc20OfferCommand);
 }
 function truncateAddress(address) {
   if (address.length <= 12) return address;
@@ -6172,29 +6603,6 @@ function registerFeedReadCommand(parent) {
     await executeFeedRead(feed, options);
   });
 }
-function createWallet(privateKey, chainId, rpcUrl) {
-  const account = privateKeyToAccount(privateKey);
-  const rpcUrls = getChainRpcUrls({
-    chainId,
-    rpcUrl
-  });
-  return createWalletClient({
-    account,
-    transport: http(rpcUrls[0]),
-    dataSuffix: getBaseDataSuffix(chainId)
-  });
-}
-async function executeTransaction(walletClient, txConfig) {
-  const hash = await walletClient.writeContract({
-    address: txConfig.to,
-    abi: txConfig.abi,
-    functionName: txConfig.functionName,
-    args: txConfig.args,
-    value: txConfig.value,
-    chain: null
-  });
-  return hash;
-}
 async function getMessageIndicesFromTx(params) {
   const publicClient = getPublicClient({
     chainId: params.chainId,