@rareprotocol/rare-cli 0.3.0 → 0.4.1

package/README.md

@@ -1,6 +1,6 @@
 # RARE Protocol CLI
 
-Command-line tool for the [RARE Protocol](https://superrare.com) on Ethereum. Deploy NFT contracts, mint tokens, run auctions, and search the network — all from your terminal.
+Command-line tool for the [RARE Protocol](https://superrare.com) on Ethereum. Deploy NFT contracts, mint tokens, run auctions, create offers and listings, and search the network — all from your terminal.
 
 ## Install
 
@@ -149,6 +149,56 @@ rare auction cancel --contract 0x... --token-id 1
 rare auction status --contract 0x... --token-id 1
 ```
 
+### Offers
+
+```bash
+# Create an offer on a token
+rare offer create --contract 0x... --token-id 1 --amount 0.5
+
+# Create an offer with ERC20 currency
+rare offer create --contract 0x... --token-id 1 --amount 100 --currency usdc
+
+# Accept an offer on a token you own
+rare offer accept --contract 0x... --token-id 1 --amount 0.5
+
+# Cancel your offer
+rare offer cancel --contract 0x... --token-id 1
+
+# Check offer status (read-only)
+rare offer status --contract 0x... --token-id 1
+```
+
+### Listings
+
+```bash
+# List a token for sale at a fixed price
+rare listing create --contract 0x... --token-id 1 --price 1.0
+
+# List with ERC20 currency or a targeted buyer
+rare listing create --contract 0x... --token-id 1 --price 100 --currency rare --target 0x...buyer
+
+# Buy a listed token
+rare listing buy --contract 0x... --token-id 1 --amount 1.0
+
+# Cancel a listing
+rare listing cancel --contract 0x... --token-id 1
+
+# Check listing status (read-only)
+rare listing status --contract 0x... --token-id 1
+```
+
+### Currencies
+
+All marketplace commands (`auction`, `offer`, `listing`) accept `--currency` to specify a payment token. Named currencies (`eth`, `usdc`, `rare`) are resolved per-chain automatically. You can also pass any ERC20 address directly.
+
+ERC20 allowances are auto-approved when needed for bids, offers, and purchases.
+
+```bash
+# List supported currencies and their addresses
+rare currencies
+rare currencies --chain mainnet
+```
+
 ### Search
 
 ```bash

package/dist/client.d.ts

@@ -137,6 +137,72 @@ interface AuctionStatus {
     endTime: bigint | null;
     status: 'PENDING' | 'RUNNING' | 'ENDED';
 }
+interface OfferCreateParams {
+    contract: Address;
+    tokenId: IntegerInput;
+    currency?: Address;
+    amount: AmountInput;
+    convertible?: boolean;
+}
+interface OfferCancelParams {
+    contract: Address;
+    tokenId: IntegerInput;
+    currency?: Address;
+}
+interface OfferAcceptParams {
+    contract: Address;
+    tokenId: IntegerInput;
+    currency?: Address;
+    amount: AmountInput;
+    splitAddresses?: Address[];
+    splitRatios?: number[];
+}
+interface OfferStatusParams {
+    contract: Address;
+    tokenId: IntegerInput;
+    currency?: Address;
+}
+interface OfferStatus {
+    buyer: Address;
+    amount: bigint;
+    timestamp: bigint;
+    marketplaceFee: number;
+    convertible: boolean;
+    hasOffer: boolean;
+}
+interface ListingCreateParams {
+    contract: Address;
+    tokenId: IntegerInput;
+    currency?: Address;
+    price: AmountInput;
+    target?: Address;
+    splitAddresses?: Address[];
+    splitRatios?: number[];
+    autoApprove?: boolean;
+}
+interface ListingCancelParams {
+    contract: Address;
+    tokenId: IntegerInput;
+    target?: Address;
+}
+interface ListingBuyParams {
+    contract: Address;
+    tokenId: IntegerInput;
+    currency?: Address;
+    amount: AmountInput;
+}
+interface ListingStatusParams {
+    contract: Address;
+    tokenId: IntegerInput;
+    target?: Address;
+}
+interface ListingStatus {
+    seller: Address;
+    currencyAddress: Address;
+    amount: bigint;
+    hasListing: boolean;
+    isEth: boolean;
+}
 interface TokenContractInfo {
     contract: Address;
     chain: SupportedChain;
@@ -172,6 +238,20 @@ interface RareClient {
         cancel(params: AuctionCancelParams): Promise<TransactionResult>;
         getStatus(params: AuctionStatusParams): Promise<AuctionStatus>;
     };
+    offer: {
+        create(params: OfferCreateParams): Promise<TransactionResult>;
+        cancel(params: OfferCancelParams): Promise<TransactionResult>;
+        accept(params: OfferAcceptParams): Promise<TransactionResult>;
+        getStatus(params: OfferStatusParams): Promise<OfferStatus>;
+    };
+    listing: {
+        create(params: ListingCreateParams): Promise<TransactionResult & {
+            approvalTxHash?: Hash;
+        }>;
+        cancel(params: ListingCancelParams): Promise<TransactionResult>;
+        buy(params: ListingBuyParams): Promise<TransactionResult>;
+        getStatus(params: ListingStatusParams): Promise<ListingStatus>;
+    };
     search: {
         nfts(params?: NftSearchParams): Promise<SearchPageResponse>;
         collections(params?: CollectionSearchParams): Promise<SearchPageResponse>;

package/dist/client.js

@@ -1,7 +1,9 @@
 // src/sdk/client.ts
 import {
+  erc20Abi,
   parseEther,
-  parseEventLogs
+  parseEventLogs,
+  maxUint256
 } from "viem";
 
 // src/contracts/addresses.ts
@@ -42,6 +44,28 @@ var contractAddresses = {
     auction: "0x1f0c946f0ee87acb268d50ede6c9b4d010af65d2"
   }
 };
+var ETH_ADDRESS = "0x0000000000000000000000000000000000000000";
+var currencyAddresses = {
+  eth: {
+    mainnet: ETH_ADDRESS,
+    sepolia: ETH_ADDRESS,
+    base: ETH_ADDRESS,
+    "base-sepolia": ETH_ADDRESS
+  },
+  rare: {
+    mainnet: "0xba5BDe662c17e2aDFF1075610382B9B691296350",
+    sepolia: "0x197FaeF3f59eC80113e773Bb6206a17d183F97CB",
+    base: "0x691077c8e8de54ea84efd454630439f99bd8c92f",
+    "base-sepolia": "0x8b21bC8571d11F7AdB705ad8F6f6BD1deb79cE01"
+  },
+  usdc: {
+    mainnet: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    sepolia: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
+    base: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    "base-sepolia": "0x036CbD53842c5426634e7929541eC2318f3dCF7e"
+  }
+};
+var currencyNames = Object.keys(currencyAddresses);
 function getContractAddresses(chain) {
   const addresses = contractAddresses[chain];
   if (!addresses) {
@@ -2720,7 +2744,7 @@ async function searchCollections(params = {}) {
 }
 
 // src/sdk/client.ts
-var ETH_ADDRESS = "0x0000000000000000000000000000000000000000";
+var ETH_ADDRESS2 = "0x0000000000000000000000000000000000000000";
 var approvalAbi = [
   {
     inputs: [{ name: "owner", type: "address" }, { name: "operator", type: "address" }],
@@ -2737,6 +2761,15 @@ var approvalAbi = [
     type: "function"
   }
 ];
+var marketplaceSettingsAbi = [
+  {
+    inputs: [{ name: "_amount", type: "uint256" }],
+    name: "calculateMarketplaceFee",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
 function resolveChainFromPublicClient(publicClient) {
   const chainId = publicClient.chain?.id;
   if (!chainId) {
@@ -2888,7 +2921,7 @@ function createRareClient(config) {
       async create(params) {
         const { walletClient, account, accountAddress } = requireWallet(config);
         const nftAddress = params.contract;
-        const currency = params.currency ?? ETH_ADDRESS;
+        const currency = params.currency ?? ETH_ADDRESS2;
         const tokenId = toInteger(params.tokenId, "tokenId");
         const startingPrice = toWei(params.startingPrice);
         const duration = toInteger(params.duration, "duration");
@@ -2945,10 +2978,55 @@ function createRareClient(config) {
         };
       },
       async bid(params) {
-        const { walletClient, account } = requireWallet(config);
-        const currency = params.currency ?? ETH_ADDRESS;
+        const { walletClient, account, accountAddress } = requireWallet(config);
+        const currency = params.currency ?? ETH_ADDRESS2;
         const amount = toWei(params.amount);
-        const isEth = currency === ETH_ADDRESS;
+        const isEth = currency === ETH_ADDRESS2;
+        let value = 0n;
+        if (isEth) {
+          const settingsAddress = await publicClient.readContract({
+            address: addresses.auction,
+            abi: auctionAbi,
+            functionName: "marketplaceSettings"
+          });
+          const fee = await publicClient.readContract({
+            address: settingsAddress,
+            abi: marketplaceSettingsAbi,
+            functionName: "calculateMarketplaceFee",
+            args: [amount]
+          });
+          value = amount + fee;
+        } else {
+          try {
+            const allowance = await publicClient.readContract({
+              address: currency,
+              abi: erc20Abi,
+              functionName: "allowance",
+              args: [accountAddress, addresses.auction]
+            });
+            if (BigInt(allowance) < amount) {
+              const approveTx = await walletClient.writeContract({
+                address: currency,
+                abi: erc20Abi,
+                functionName: "approve",
+                args: [addresses.auction, maxUint256],
+                account,
+                chain: void 0
+              });
+              await publicClient.waitForTransactionReceipt({ hash: approveTx });
+            }
+          } catch {
+            const approveTx = await walletClient.writeContract({
+              address: currency,
+              abi: erc20Abi,
+              functionName: "approve",
+              args: [addresses.auction, maxUint256],
+              account,
+              chain: void 0
+            });
+            await publicClient.waitForTransactionReceipt({ hash: approveTx });
+          }
+        }
         const txHash = await walletClient.writeContract({
           address: addresses.auction,
           abi: auctionAbi,
@@ -2956,7 +3034,7 @@ function createRareClient(config) {
           args: [params.contract, toInteger(params.tokenId, "tokenId"), currency, amount],
           account,
           chain: void 0,
-          value: isEth ? amount : 0n
+          value
         });
         const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
         return { txHash, receipt };
@@ -3022,13 +3100,249 @@ function createRareClient(config) {
           auctionType,
           splitAddresses: [...splitAddresses],
           splitRatios: [...splitRatios],
-          isEth: currency === ETH_ADDRESS,
+          isEth: currency === ETH_ADDRESS2,
           started,
           endTime,
           status
         };
       }
     },
+    offer: {
+      async create(params) {
+        const { walletClient, account, accountAddress } = requireWallet(config);
+        const currency = params.currency ?? ETH_ADDRESS2;
+        const amount = toWei(params.amount);
+        const isEth = currency === ETH_ADDRESS2;
+        const convertible = params.convertible ?? false;
+        let value = 0n;
+        if (isEth) {
+          const settingsAddress = await publicClient.readContract({
+            address: addresses.auction,
+            abi: auctionAbi,
+            functionName: "marketplaceSettings"
+          });
+          const fee = await publicClient.readContract({
+            address: settingsAddress,
+            abi: marketplaceSettingsAbi,
+            functionName: "calculateMarketplaceFee",
+            args: [amount]
+          });
+          value = amount + fee;
+        } else {
+          try {
+            const allowance = await publicClient.readContract({
+              address: currency,
+              abi: erc20Abi,
+              functionName: "allowance",
+              args: [accountAddress, addresses.auction]
+            });
+            if (BigInt(allowance) < amount) {
+              const approveTx = await walletClient.writeContract({
+                address: currency,
+                abi: erc20Abi,
+                functionName: "approve",
+                args: [addresses.auction, maxUint256],
+                account,
+                chain: void 0
+              });
+              await publicClient.waitForTransactionReceipt({ hash: approveTx });
+            }
+          } catch {
+            const approveTx = await walletClient.writeContract({
+              address: currency,
+              abi: erc20Abi,
+              functionName: "approve",
+              args: [addresses.auction, maxUint256],
+              account,
+              chain: void 0
+            });
+            await publicClient.waitForTransactionReceipt({ hash: approveTx });
+          }
+        }
+        const txHash = await walletClient.writeContract({
+          address: addresses.auction,
+          abi: auctionAbi,
+          functionName: "offer",
+          args: [params.contract, toInteger(params.tokenId, "tokenId"), currency, amount, convertible],
+          account,
+          chain: void 0,
+          value
+        });
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        return { txHash, receipt };
+      },
+      async cancel(params) {
+        const { walletClient, account } = requireWallet(config);
+        const currency = params.currency ?? ETH_ADDRESS2;
+        const txHash = await walletClient.writeContract({
+          address: addresses.auction,
+          abi: auctionAbi,
+          functionName: "cancelOffer",
+          args: [params.contract, toInteger(params.tokenId, "tokenId"), currency],
+          account,
+          chain: void 0
+        });
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        return { txHash, receipt };
+      },
+      async accept(params) {
+        const { walletClient, account, accountAddress } = requireWallet(config);
+        const currency = params.currency ?? ETH_ADDRESS2;
+        const amount = toWei(params.amount);
+        const splitAddresses = params.splitAddresses ?? [accountAddress];
+        const splitRatios = params.splitRatios ?? [100];
+        const txHash = await walletClient.writeContract({
+          address: addresses.auction,
+          abi: auctionAbi,
+          functionName: "acceptOffer",
+          args: [params.contract, toInteger(params.tokenId, "tokenId"), currency, amount, splitAddresses, splitRatios],
+          account,
+          chain: void 0
+        });
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        return { txHash, receipt };
+      },
+      async getStatus(params) {
+        const currency = params.currency ?? ETH_ADDRESS2;
+        const [buyer, amount, timestamp, marketplaceFee, convertible] = await publicClient.readContract({
+          address: addresses.auction,
+          abi: auctionAbi,
+          functionName: "tokenCurrentOffers",
+          args: [params.contract, toInteger(params.tokenId, "tokenId"), currency]
+        });
+        const hasOffer = amount > 0n;
+        return { buyer, amount, timestamp, marketplaceFee, convertible, hasOffer };
+      }
+    },
+    listing: {
+      async create(params) {
+        const { walletClient, account, accountAddress } = requireWallet(config);
+        const currency = params.currency ?? ETH_ADDRESS2;
+        const price = toWei(params.price);
+        const target = params.target ?? ETH_ADDRESS2;
+        const splitAddresses = params.splitAddresses ?? [accountAddress];
+        const splitRatios = params.splitRatios ?? [100];
+        const nftAddress = params.contract;
+        let approvalTxHash;
+        if (params.autoApprove !== false) {
+          const isApproved = await publicClient.readContract({
+            address: nftAddress,
+            abi: approvalAbi,
+            functionName: "isApprovedForAll",
+            args: [accountAddress, addresses.auction]
+          });
+          if (!isApproved) {
+            approvalTxHash = await walletClient.writeContract({
+              address: nftAddress,
+              abi: approvalAbi,
+              functionName: "setApprovalForAll",
+              args: [addresses.auction, true],
+              account,
+              chain: void 0
+            });
+            await publicClient.waitForTransactionReceipt({ hash: approvalTxHash });
+          }
+        }
+        const txHash = await walletClient.writeContract({
+          address: addresses.auction,
+          abi: auctionAbi,
+          functionName: "setSalePrice",
+          args: [nftAddress, toInteger(params.tokenId, "tokenId"), currency, price, target, splitAddresses, splitRatios],
+          account,
+          chain: void 0
+        });
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        return { txHash, receipt, approvalTxHash };
+      },
+      async cancel(params) {
+        const { walletClient, account } = requireWallet(config);
+        const target = params.target ?? ETH_ADDRESS2;
+        const txHash = await walletClient.writeContract({
+          address: addresses.auction,
+          abi: auctionAbi,
+          functionName: "removeSalePrice",
+          args: [params.contract, toInteger(params.tokenId, "tokenId"), target],
+          account,
+          chain: void 0
+        });
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        return { txHash, receipt };
+      },
+      async buy(params) {
+        const { walletClient, account, accountAddress } = requireWallet(config);
+        const currency = params.currency ?? ETH_ADDRESS2;
+        const amount = toWei(params.amount);
+        const isEth = currency === ETH_ADDRESS2;
+        let value = 0n;
+        if (isEth) {
+          const settingsAddress = await publicClient.readContract({
+            address: addresses.auction,
+            abi: auctionAbi,
+            functionName: "marketplaceSettings"
+          });
+          const fee = await publicClient.readContract({
+            address: settingsAddress,
+            abi: marketplaceSettingsAbi,
+            functionName: "calculateMarketplaceFee",
+            args: [amount]
+          });
+          value = amount + fee;
+        } else {
+          try {
+            const allowance = await publicClient.readContract({
+              address: currency,
+              abi: erc20Abi,
+              functionName: "allowance",
+              args: [accountAddress, addresses.auction]
+            });
+            if (BigInt(allowance) < amount) {
+              const approveTx = await walletClient.writeContract({
+                address: currency,
+                abi: erc20Abi,
+                functionName: "approve",
+                args: [addresses.auction, maxUint256],
+                account,
+                chain: void 0
+              });
+              await publicClient.waitForTransactionReceipt({ hash: approveTx });
+            }
+          } catch {
+            const approveTx = await walletClient.writeContract({
+              address: currency,
+              abi: erc20Abi,
+              functionName: "approve",
+              args: [addresses.auction, maxUint256],
+              account,
+              chain: void 0
+            });
+            await publicClient.waitForTransactionReceipt({ hash: approveTx });
+          }
+        }
+        const txHash = await walletClient.writeContract({
+          address: addresses.auction,
+          abi: auctionAbi,
+          functionName: "buy",
+          args: [params.contract, toInteger(params.tokenId, "tokenId"), currency, amount],
+          account,
+          chain: void 0,
+          value
+        });
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        return { txHash, receipt };
+      },
+      async getStatus(params) {
+        const target = params.target ?? ETH_ADDRESS2;
+        const [seller, currencyAddress, amount] = await publicClient.readContract({
+          address: addresses.auction,
+          abi: auctionAbi,
+          functionName: "tokenSalePrices",
+          args: [params.contract, toInteger(params.tokenId, "tokenId"), target]
+        });
+        const hasListing = amount > 0n;
+        const isEth = currencyAddress === ETH_ADDRESS2;
+        return { seller, currencyAddress, amount, hasListing, isEth };
+      }
+    },
     search: {
       async nfts(params = {}) {
         const requestParams = params.chainIds ? params : { ...params, chainIds: [chainId] };

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command10 } from "commander";
+import { Command as Command13 } from "commander";
 
 // src/commands/configure.ts
 import { Command } from "commander";
@@ -55,6 +55,42 @@ var contractAddresses = {
     auction: "0x1f0c946f0ee87acb268d50ede6c9b4d010af65d2"
   }
 };
+var ETH_ADDRESS = "0x0000000000000000000000000000000000000000";
+var currencyAddresses = {
+  eth: {
+    mainnet: ETH_ADDRESS,
+    sepolia: ETH_ADDRESS,
+    base: ETH_ADDRESS,
+    "base-sepolia": ETH_ADDRESS
+  },
+  rare: {
+    mainnet: "0xba5BDe662c17e2aDFF1075610382B9B691296350",
+    sepolia: "0x197FaeF3f59eC80113e773Bb6206a17d183F97CB",
+    base: "0x691077c8e8de54ea84efd454630439f99bd8c92f",
+    "base-sepolia": "0x8b21bC8571d11F7AdB705ad8F6f6BD1deb79cE01"
+  },
+  usdc: {
+    mainnet: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    sepolia: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
+    base: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    "base-sepolia": "0x036CbD53842c5426634e7929541eC2318f3dCF7e"
+  }
+};
+var currencyNames = Object.keys(currencyAddresses);
+function resolveCurrency(input, chain) {
+  const lower = input.toLowerCase();
+  if (lower in currencyAddresses) {
+    const addr = currencyAddresses[lower][chain];
+    if (!addr) {
+      throw new Error(`Currency "${lower}" is not available on "${chain}".`);
+    }
+    return addr;
+  }
+  if (input.startsWith("0x")) {
+    return input;
+  }
+  throw new Error(`Unknown currency "${input}". Supported: ${currencyNames.join(", ")} or a 0x address.`);
+}
 function getContractAddresses(chain) {
   const addresses = contractAddresses[chain];
   if (!addresses) {
@@ -220,8 +256,10 @@ function getWalletClient(chain) {
 
 // src/sdk/client.ts
 import {
+  erc20Abi,
   parseEther,
-  parseEventLogs
+  parseEventLogs,
+  maxUint256
 } from "viem";
 
 // src/contracts/abis/factory.ts
@@ -2889,7 +2927,7 @@ async function searchCollections(params = {}) {
 }
 
 // src/sdk/client.ts
-var ETH_ADDRESS = "0x0000000000000000000000000000000000000000";
+var ETH_ADDRESS2 = "0x0000000000000000000000000000000000000000";
 var approvalAbi = [
   {
     inputs: [{ name: "owner", type: "address" }, { name: "operator", type: "address" }],
@@ -2906,6 +2944,15 @@ var approvalAbi = [
     type: "function"
   }
 ];
+var marketplaceSettingsAbi = [
+  {
+    inputs: [{ name: "_amount", type: "uint256" }],
+    name: "calculateMarketplaceFee",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
 function resolveChainFromPublicClient(publicClient) {
   const chainId = publicClient.chain?.id;
   if (!chainId) {
@@ -3057,7 +3104,7 @@ function createRareClient(config) {
       async create(params) {
         const { walletClient, account, accountAddress } = requireWallet(config);
         const nftAddress = params.contract;
-        const currency = params.currency ?? ETH_ADDRESS;
+        const currency = params.currency ?? ETH_ADDRESS2;
         const tokenId = toInteger(params.tokenId, "tokenId");
         const startingPrice = toWei(params.startingPrice);
         const duration = toInteger(params.duration, "duration");
@@ -3114,10 +3161,55 @@ function createRareClient(config) {
         };
       },
       async bid(params) {
-        const { walletClient, account } = requireWallet(config);
-        const currency = params.currency ?? ETH_ADDRESS;
+        const { walletClient, account, accountAddress } = requireWallet(config);
+        const currency = params.currency ?? ETH_ADDRESS2;
         const amount = toWei(params.amount);
-        const isEth = currency === ETH_ADDRESS;
+        const isEth = currency === ETH_ADDRESS2;
+        let value = 0n;
+        if (isEth) {
+          const settingsAddress = await publicClient.readContract({
+            address: addresses.auction,
+            abi: auctionAbi,
+            functionName: "marketplaceSettings"
+          });
+          const fee = await publicClient.readContract({
+            address: settingsAddress,
+            abi: marketplaceSettingsAbi,
+            functionName: "calculateMarketplaceFee",
+            args: [amount]
+          });
+          value = amount + fee;
+        } else {
+          try {
+            const allowance = await publicClient.readContract({
+              address: currency,
+              abi: erc20Abi,
+              functionName: "allowance",
+              args: [accountAddress, addresses.auction]
+            });
+            if (BigInt(allowance) < amount) {
+              const approveTx = await walletClient.writeContract({
+                address: currency,
+                abi: erc20Abi,
+                functionName: "approve",
+                args: [addresses.auction, maxUint256],
+                account,
+                chain: void 0
+              });
+              await publicClient.waitForTransactionReceipt({ hash: approveTx });
+            }
+          } catch {
+            const approveTx = await walletClient.writeContract({
+              address: currency,
+              abi: erc20Abi,
+              functionName: "approve",
+              args: [addresses.auction, maxUint256],
+              account,
+              chain: void 0
+            });
+            await publicClient.waitForTransactionReceipt({ hash: approveTx });
+          }
+        }
         const txHash = await walletClient.writeContract({
           address: addresses.auction,
           abi: auctionAbi,
@@ -3125,7 +3217,7 @@ function createRareClient(config) {
           args: [params.contract, toInteger(params.tokenId, "tokenId"), currency, amount],
           account,
           chain: void 0,
-          value: isEth ? amount : 0n
+          value
         });
         const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
         return { txHash, receipt };
@@ -3191,13 +3283,249 @@ function createRareClient(config) {
           auctionType,
           splitAddresses: [...splitAddresses],
           splitRatios: [...splitRatios],
-          isEth: currency === ETH_ADDRESS,
+          isEth: currency === ETH_ADDRESS2,
           started,
           endTime,
           status
         };
       }
     },
+    offer: {
+      async create(params) {
+        const { walletClient, account, accountAddress } = requireWallet(config);
+        const currency = params.currency ?? ETH_ADDRESS2;
+        const amount = toWei(params.amount);
+        const isEth = currency === ETH_ADDRESS2;
+        const convertible = params.convertible ?? false;
+        let value = 0n;
+        if (isEth) {
+          const settingsAddress = await publicClient.readContract({
+            address: addresses.auction,
+            abi: auctionAbi,
+            functionName: "marketplaceSettings"
+          });
+          const fee = await publicClient.readContract({
+            address: settingsAddress,
+            abi: marketplaceSettingsAbi,
+            functionName: "calculateMarketplaceFee",
+            args: [amount]
+          });
+          value = amount + fee;
+        } else {
+          try {
+            const allowance = await publicClient.readContract({
+              address: currency,
+              abi: erc20Abi,
+              functionName: "allowance",
+              args: [accountAddress, addresses.auction]
+            });
+            if (BigInt(allowance) < amount) {
+              const approveTx = await walletClient.writeContract({
+                address: currency,
+                abi: erc20Abi,
+                functionName: "approve",
+                args: [addresses.auction, maxUint256],
+                account,
+                chain: void 0
+              });
+              await publicClient.waitForTransactionReceipt({ hash: approveTx });
+            }
+          } catch {
+            const approveTx = await walletClient.writeContract({
+              address: currency,
+              abi: erc20Abi,
+              functionName: "approve",
+              args: [addresses.auction, maxUint256],
+              account,
+              chain: void 0
+            });
+            await publicClient.waitForTransactionReceipt({ hash: approveTx });
+          }
+        }
+        const txHash = await walletClient.writeContract({
+          address: addresses.auction,
+          abi: auctionAbi,
+          functionName: "offer",
+          args: [params.contract, toInteger(params.tokenId, "tokenId"), currency, amount, convertible],
+          account,
+          chain: void 0,
+          value
+        });
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        return { txHash, receipt };
+      },
+      async cancel(params) {
+        const { walletClient, account } = requireWallet(config);
+        const currency = params.currency ?? ETH_ADDRESS2;
+        const txHash = await walletClient.writeContract({
+          address: addresses.auction,
+          abi: auctionAbi,
+          functionName: "cancelOffer",
+          args: [params.contract, toInteger(params.tokenId, "tokenId"), currency],
+          account,
+          chain: void 0
+        });
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        return { txHash, receipt };
+      },
+      async accept(params) {
+        const { walletClient, account, accountAddress } = requireWallet(config);
+        const currency = params.currency ?? ETH_ADDRESS2;
+        const amount = toWei(params.amount);
+        const splitAddresses = params.splitAddresses ?? [accountAddress];
+        const splitRatios = params.splitRatios ?? [100];
+        const txHash = await walletClient.writeContract({
+          address: addresses.auction,
+          abi: auctionAbi,
+          functionName: "acceptOffer",
+          args: [params.contract, toInteger(params.tokenId, "tokenId"), currency, amount, splitAddresses, splitRatios],
+          account,
+          chain: void 0
+        });
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        return { txHash, receipt };
+      },
+      async getStatus(params) {
+        const currency = params.currency ?? ETH_ADDRESS2;
+        const [buyer, amount, timestamp, marketplaceFee, convertible] = await publicClient.readContract({
+          address: addresses.auction,
+          abi: auctionAbi,
+          functionName: "tokenCurrentOffers",
+          args: [params.contract, toInteger(params.tokenId, "tokenId"), currency]
+        });
+        const hasOffer = amount > 0n;
+        return { buyer, amount, timestamp, marketplaceFee, convertible, hasOffer };
+      }
+    },
+    listing: {
+      async create(params) {
+        const { walletClient, account, accountAddress } = requireWallet(config);
+        const currency = params.currency ?? ETH_ADDRESS2;
+        const price = toWei(params.price);
+        const target = params.target ?? ETH_ADDRESS2;
+        const splitAddresses = params.splitAddresses ?? [accountAddress];
+        const splitRatios = params.splitRatios ?? [100];
+        const nftAddress = params.contract;
+        let approvalTxHash;
+        if (params.autoApprove !== false) {
+          const isApproved = await publicClient.readContract({
+            address: nftAddress,
+            abi: approvalAbi,
+            functionName: "isApprovedForAll",
+            args: [accountAddress, addresses.auction]
+          });
+          if (!isApproved) {
+            approvalTxHash = await walletClient.writeContract({
+              address: nftAddress,
+              abi: approvalAbi,
+              functionName: "setApprovalForAll",
+              args: [addresses.auction, true],
+              account,
+              chain: void 0
+            });
+            await publicClient.waitForTransactionReceipt({ hash: approvalTxHash });
+          }
+        }
+        const txHash = await walletClient.writeContract({
+          address: addresses.auction,
+          abi: auctionAbi,
+          functionName: "setSalePrice",
+          args: [nftAddress, toInteger(params.tokenId, "tokenId"), currency, price, target, splitAddresses, splitRatios],
+          account,
+          chain: void 0
+        });
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        return { txHash, receipt, approvalTxHash };
+      },
+      async cancel(params) {
+        const { walletClient, account } = requireWallet(config);
+        const target = params.target ?? ETH_ADDRESS2;
+        const txHash = await walletClient.writeContract({
+          address: addresses.auction,
+          abi: auctionAbi,
+          functionName: "removeSalePrice",
+          args: [params.contract, toInteger(params.tokenId, "tokenId"), target],
+          account,
+          chain: void 0
+        });
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        return { txHash, receipt };
+      },
+      async buy(params) {
+        const { walletClient, account, accountAddress } = requireWallet(config);
+        const currency = params.currency ?? ETH_ADDRESS2;
+        const amount = toWei(params.amount);
+        const isEth = currency === ETH_ADDRESS2;
+        let value = 0n;
+        if (isEth) {
+          const settingsAddress = await publicClient.readContract({
+            address: addresses.auction,
+            abi: auctionAbi,
+            functionName: "marketplaceSettings"
+          });
+          const fee = await publicClient.readContract({
+            address: settingsAddress,
+            abi: marketplaceSettingsAbi,
+            functionName: "calculateMarketplaceFee",
+            args: [amount]
+          });
+          value = amount + fee;
+        } else {
+          try {
+            const allowance = await publicClient.readContract({
+              address: currency,
+              abi: erc20Abi,
+              functionName: "allowance",
+              args: [accountAddress, addresses.auction]
+            });
+            if (BigInt(allowance) < amount) {
+              const approveTx = await walletClient.writeContract({
+                address: currency,
+                abi: erc20Abi,
+                functionName: "approve",
+                args: [addresses.auction, maxUint256],
+                account,
+                chain: void 0
+              });
+              await publicClient.waitForTransactionReceipt({ hash: approveTx });
+            }
+          } catch {
+            const approveTx = await walletClient.writeContract({
+              address: currency,
+              abi: erc20Abi,
+              functionName: "approve",
+              args: [addresses.auction, maxUint256],
+              account,
+              chain: void 0
+            });
+            await publicClient.waitForTransactionReceipt({ hash: approveTx });
+          }
+        }
+        const txHash = await walletClient.writeContract({
+          address: addresses.auction,
+          abi: auctionAbi,
+          functionName: "buy",
+          args: [params.contract, toInteger(params.tokenId, "tokenId"), currency, amount],
+          account,
+          chain: void 0,
+          value
+        });
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        return { txHash, receipt };
+      },
+      async getStatus(params) {
+        const target = params.target ?? ETH_ADDRESS2;
+        const [seller, currencyAddress, amount] = await publicClient.readContract({
+          address: addresses.auction,
+          abi: auctionAbi,
+          functionName: "tokenSalePrices",
+          args: [params.contract, toInteger(params.tokenId, "tokenId"), target]
+        });
+        const hasListing = amount > 0n;
+        const isEth = currencyAddress === ETH_ADDRESS2;
+        return { seller, currencyAddress, amount, hasListing, isEth };
+      }
+    },
     search: {
       async nfts(params = {}) {
         const requestParams = params.chainIds ? params : { ...params, chainIds: [chainId] };
@@ -3593,23 +3921,23 @@ function printContractError(error) {
 }
 
 // src/commands/auction.ts
-var ETH_ADDRESS2 = "0x0000000000000000000000000000000000000000";
+var ETH_ADDRESS3 = "0x0000000000000000000000000000000000000000";
 function auctionCommand() {
   const cmd = new Command4("auction");
   cmd.description("Auction subcommands (create, bid, settle, cancel, status)");
-  cmd.command("create").description("Configure and start an auction").requiredOption("--contract <address>", "NFT contract address").requiredOption("--token-id <id>", "token ID to auction").requiredOption("--starting-price <amount>", "starting price in ETH (or token units)").requiredOption("--duration <seconds>", "auction duration in seconds").option("--currency <address>", "ERC20 currency address (defaults to ETH)").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action(async (opts) => {
+  cmd.command("create").description("Configure and start an auction").requiredOption("--contract <address>", "NFT contract address").requiredOption("--token-id <id>", "token ID to auction").requiredOption("--starting-price <amount>", "starting price in ETH (or token units)").requiredOption("--duration <seconds>", "auction duration in seconds").option("--currency <currency>", "currency: eth, usdc, rare, or ERC20 address (defaults to eth)").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action(async (opts) => {
     const chain = getActiveChain(opts.chain);
     const { client } = getWalletClient(chain);
     const publicClient = getPublicClient(chain);
     const rare = createRareClient({ publicClient, walletClient: client });
-    const currency = opts.currency ?? ETH_ADDRESS2;
+    const currency = opts.currency ? resolveCurrency(opts.currency, chain) : ETH_ADDRESS3;
     console.log(`Creating auction on ${chain}...`);
     console.log(`  Auction contract: ${rare.contracts.auction}`);
     console.log(`  NFT contract: ${opts.contract}`);
     console.log(`  Token ID: ${opts.tokenId}`);
     console.log(`  Starting price: ${opts.startingPrice} ETH`);
     console.log(`  Duration: ${opts.duration} seconds`);
-    console.log(`  Currency: ${currency === ETH_ADDRESS2 ? "ETH" : currency}`);
+    console.log(`  Currency: ${currency === ETH_ADDRESS3 ? "ETH" : currency}`);
     try {
       const result = await rare.auction.create({
         contract: opts.contract,
@@ -3628,13 +3956,13 @@ Transaction sent: ${result.txHash}`);
       printContractError(error);
     }
   });
-  cmd.command("bid").description("Place a bid on an auction").requiredOption("--contract <address>", "NFT contract address").requiredOption("--token-id <id>", "token ID").requiredOption("--amount <amount>", "bid amount in ETH (or token units)").option("--currency <address>", "ERC20 currency address (defaults to ETH)").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action(async (opts) => {
+  cmd.command("bid").description("Place a bid on an auction").requiredOption("--contract <address>", "NFT contract address").requiredOption("--token-id <id>", "token ID").requiredOption("--amount <amount>", "bid amount in ETH (or token units)").option("--currency <currency>", "currency: eth, usdc, rare, or ERC20 address (defaults to eth)").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action(async (opts) => {
     const chain = getActiveChain(opts.chain);
     const { client } = getWalletClient(chain);
     const publicClient = getPublicClient(chain);
     const rare = createRareClient({ publicClient, walletClient: client });
-    const currency = opts.currency ?? ETH_ADDRESS2;
-    const isEth = currency === ETH_ADDRESS2;
+    const currency = opts.currency ? resolveCurrency(opts.currency, chain) : ETH_ADDRESS3;
+    const isEth = currency === ETH_ADDRESS3;
     console.log(`Placing bid on ${chain}...`);
     console.log(`  Auction contract: ${rare.contracts.auction}`);
     console.log(`  NFT contract: ${opts.contract}`);
@@ -3981,9 +4309,236 @@ Contract imported successfully.`);
   return cmd;
 }
 
+// src/commands/offer.ts
+import { Command as Command10 } from "commander";
+import { formatEther as formatEther2 } from "viem";
+var ETH_ADDRESS4 = "0x0000000000000000000000000000000000000000";
+function offerCommand() {
+  const cmd = new Command10("offer");
+  cmd.description("Offer subcommands (create, cancel, accept, status)");
+  cmd.command("create").description("Create an offer on a token").requiredOption("--contract <address>", "NFT contract address").requiredOption("--token-id <id>", "token ID").requiredOption("--amount <amount>", "offer amount in ETH (or token units)").option("--currency <currency>", "currency: eth, usdc, rare, or ERC20 address (defaults to eth)").option("--convertible", "mark offer as convertible").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action(async (opts) => {
+    const chain = getActiveChain(opts.chain);
+    const { client } = getWalletClient(chain);
+    const publicClient = getPublicClient(chain);
+    const rare = createRareClient({ publicClient, walletClient: client });
+    const currency = opts.currency ? resolveCurrency(opts.currency, chain) : ETH_ADDRESS4;
+    const isEth = currency === ETH_ADDRESS4;
+    console.log(`Creating offer on ${chain}...`);
+    console.log(`  Marketplace contract: ${rare.contracts.auction}`);
+    console.log(`  NFT contract: ${opts.contract}`);
+    console.log(`  Token ID: ${opts.tokenId}`);
+    console.log(`  Amount: ${opts.amount} ${isEth ? "ETH" : currency}`);
+    console.log(`  Convertible: ${opts.convertible ? "yes" : "no"}`);
+    try {
+      const result = await rare.offer.create({
+        contract: opts.contract,
+        tokenId: opts.tokenId,
+        amount: opts.amount,
+        currency,
+        convertible: opts.convertible ?? false
+      });
+      console.log(`
+Transaction sent: ${result.txHash}`);
+      console.log(`Offer created! Block: ${result.receipt.blockNumber}`);
+    } catch (error) {
+      printContractError(error);
+    }
+  });
+  cmd.command("cancel").description("Cancel an existing offer").requiredOption("--contract <address>", "NFT contract address").requiredOption("--token-id <id>", "token ID").option("--currency <currency>", "currency: eth, usdc, rare, or ERC20 address (defaults to eth)").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action(async (opts) => {
+    const chain = getActiveChain(opts.chain);
+    const { client } = getWalletClient(chain);
+    const publicClient = getPublicClient(chain);
+    const rare = createRareClient({ publicClient, walletClient: client });
+    const currency = opts.currency ? resolveCurrency(opts.currency, chain) : ETH_ADDRESS4;
+    console.log(`Cancelling offer on ${chain}...`);
+    try {
+      const result = await rare.offer.cancel({
+        contract: opts.contract,
+        tokenId: opts.tokenId,
+        currency
+      });
+      console.log(`Transaction sent: ${result.txHash}`);
+      console.log(`Offer cancelled! Block: ${result.receipt.blockNumber}`);
+    } catch (error) {
+      printContractError(error);
+    }
+  });
+  cmd.command("accept").description("Accept an offer on a token you own").requiredOption("--contract <address>", "NFT contract address").requiredOption("--token-id <id>", "token ID").requiredOption("--amount <amount>", "offer amount to accept in ETH (or token units)").option("--currency <currency>", "currency: eth, usdc, rare, or ERC20 address (defaults to eth)").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action(async (opts) => {
+    const chain = getActiveChain(opts.chain);
+    const { client } = getWalletClient(chain);
+    const publicClient = getPublicClient(chain);
+    const rare = createRareClient({ publicClient, walletClient: client });
+    const currency = opts.currency ? resolveCurrency(opts.currency, chain) : ETH_ADDRESS4;
+    const isEth = currency === ETH_ADDRESS4;
+    console.log(`Accepting offer on ${chain}...`);
+    console.log(`  NFT contract: ${opts.contract}`);
+    console.log(`  Token ID: ${opts.tokenId}`);
+    console.log(`  Amount: ${opts.amount} ${isEth ? "ETH" : currency}`);
+    try {
+      const result = await rare.offer.accept({
+        contract: opts.contract,
+        tokenId: opts.tokenId,
+        amount: opts.amount,
+        currency
+      });
+      console.log(`
+Transaction sent: ${result.txHash}`);
+      console.log(`Offer accepted! Block: ${result.receipt.blockNumber}`);
+    } catch (error) {
+      printContractError(error);
+    }
+  });
+  cmd.command("status").description("Get current offer details (read-only)").requiredOption("--contract <address>", "NFT contract address").requiredOption("--token-id <id>", "token ID").option("--currency <currency>", "currency: eth, usdc, rare, or ERC20 address (defaults to eth)").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action(async (opts) => {
+    const chain = getActiveChain(opts.chain);
+    const publicClient = getPublicClient(chain);
+    const rare = createRareClient({ publicClient });
+    const currency = opts.currency ? resolveCurrency(opts.currency, chain) : ETH_ADDRESS4;
+    const isEth = currency === ETH_ADDRESS4;
+    const result = await rare.offer.getStatus({
+      contract: opts.contract,
+      tokenId: opts.tokenId,
+      currency
+    });
+    console.log("\nOffer Details:");
+    if (!result.hasOffer) {
+      console.log("  No active offer found.");
+    } else {
+      console.log(`  Buyer:           ${result.buyer}`);
+      console.log(`  Amount:          ${formatEther2(result.amount)} ${isEth ? "ETH" : currency}`);
+      console.log(`  Timestamp:       ${new Date(Number(result.timestamp) * 1e3).toISOString()}`);
+      console.log(`  Marketplace fee: ${result.marketplaceFee}%`);
+      console.log(`  Convertible:     ${result.convertible ? "yes" : "no"}`);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/listing.ts
+import { Command as Command11 } from "commander";
+import { formatEther as formatEther3 } from "viem";
+var ETH_ADDRESS5 = "0x0000000000000000000000000000000000000000";
+function listingCommand() {
+  const cmd = new Command11("listing");
+  cmd.description("Listing subcommands (create, cancel, buy, status)");
+  cmd.command("create").description("Create a listing (set sale price) for a token").requiredOption("--contract <address>", "NFT contract address").requiredOption("--token-id <id>", "token ID").requiredOption("--price <amount>", "listing price in ETH (or token units)").option("--currency <currency>", "currency: eth, usdc, rare, or ERC20 address (defaults to eth)").option("--target <address>", "target buyer address (defaults to public listing)").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action(async (opts) => {
+    const chain = getActiveChain(opts.chain);
+    const { client } = getWalletClient(chain);
+    const publicClient = getPublicClient(chain);
+    const rare = createRareClient({ publicClient, walletClient: client });
+    const currency = opts.currency ? resolveCurrency(opts.currency, chain) : ETH_ADDRESS5;
+    const isEth = currency === ETH_ADDRESS5;
+    const target = opts.target ?? ETH_ADDRESS5;
+    console.log(`Creating listing on ${chain}...`);
+    console.log(`  Marketplace contract: ${rare.contracts.auction}`);
+    console.log(`  NFT contract: ${opts.contract}`);
+    console.log(`  Token ID: ${opts.tokenId}`);
+    console.log(`  Price: ${opts.price} ${isEth ? "ETH" : currency}`);
+    console.log(`  Target: ${target === ETH_ADDRESS5 ? "public" : target}`);
+    try {
+      const result = await rare.listing.create({
+        contract: opts.contract,
+        tokenId: opts.tokenId,
+        price: opts.price,
+        currency,
+        target
+      });
+      if (result.approvalTxHash) {
+        console.log(`Approval tx sent: ${result.approvalTxHash}`);
+      }
+      console.log(`
+Transaction sent: ${result.txHash}`);
+      console.log(`Listing created! Block: ${result.receipt.blockNumber}`);
+    } catch (error) {
+      printContractError(error);
+    }
+  });
+  cmd.command("cancel").description("Cancel a listing (remove sale price)").requiredOption("--contract <address>", "NFT contract address").requiredOption("--token-id <id>", "token ID").option("--target <address>", "target buyer address (defaults to public listing)").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action(async (opts) => {
+    const chain = getActiveChain(opts.chain);
+    const { client } = getWalletClient(chain);
+    const publicClient = getPublicClient(chain);
+    const rare = createRareClient({ publicClient, walletClient: client });
+    const target = opts.target ?? ETH_ADDRESS5;
+    console.log(`Cancelling listing on ${chain}...`);
+    try {
+      const result = await rare.listing.cancel({
+        contract: opts.contract,
+        tokenId: opts.tokenId,
+        target
+      });
+      console.log(`Transaction sent: ${result.txHash}`);
+      console.log(`Listing cancelled! Block: ${result.receipt.blockNumber}`);
+    } catch (error) {
+      printContractError(error);
+    }
+  });
+  cmd.command("buy").description("Buy a listed token").requiredOption("--contract <address>", "NFT contract address").requiredOption("--token-id <id>", "token ID").requiredOption("--amount <amount>", "purchase amount in ETH (or token units)").option("--currency <currency>", "currency: eth, usdc, rare, or ERC20 address (defaults to eth)").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action(async (opts) => {
+    const chain = getActiveChain(opts.chain);
+    const { client } = getWalletClient(chain);
+    const publicClient = getPublicClient(chain);
+    const rare = createRareClient({ publicClient, walletClient: client });
+    const currency = opts.currency ? resolveCurrency(opts.currency, chain) : ETH_ADDRESS5;
+    const isEth = currency === ETH_ADDRESS5;
+    console.log(`Buying token on ${chain}...`);
+    console.log(`  Marketplace contract: ${rare.contracts.auction}`);
+    console.log(`  NFT contract: ${opts.contract}`);
+    console.log(`  Token ID: ${opts.tokenId}`);
+    console.log(`  Amount: ${opts.amount} ${isEth ? "ETH" : currency}`);
+    try {
+      const result = await rare.listing.buy({
+        contract: opts.contract,
+        tokenId: opts.tokenId,
+        amount: opts.amount,
+        currency
+      });
+      console.log(`
+Transaction sent: ${result.txHash}`);
+      console.log(`Token purchased! Block: ${result.receipt.blockNumber}`);
+    } catch (error) {
+      printContractError(error);
+    }
+  });
+  cmd.command("status").description("Get listing details (read-only)").requiredOption("--contract <address>", "NFT contract address").requiredOption("--token-id <id>", "token ID").option("--target <address>", "target buyer address (defaults to public listing)").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action(async (opts) => {
+    const chain = getActiveChain(opts.chain);
+    const publicClient = getPublicClient(chain);
+    const rare = createRareClient({ publicClient });
+    const target = opts.target ?? ETH_ADDRESS5;
+    const result = await rare.listing.getStatus({
+      contract: opts.contract,
+      tokenId: opts.tokenId,
+      target
+    });
+    console.log("\nListing Details:");
+    if (!result.hasListing) {
+      console.log("  No active listing found.");
+    } else {
+      console.log(`  Seller:   ${result.seller}`);
+      console.log(`  Amount:   ${formatEther3(result.amount)} ${result.isEth ? "ETH" : result.currencyAddress}`);
+      console.log(`  Currency: ${result.isEth ? "ETH" : result.currencyAddress}`);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/currencies.ts
+import { Command as Command12 } from "commander";
+function currenciesCommand() {
+  const cmd = new Command12("currencies");
+  cmd.description("List supported currencies and their addresses").option("--chain <chain>", "chain to use (mainnet, sepolia, base, base-sepolia)").action((opts) => {
+    const chain = getActiveChain(opts.chain);
+    console.log(`
+Supported currencies on ${chain}:
+`);
+    for (const name of currencyNames) {
+      const address = resolveCurrency(name, chain);
+      console.log(`  ${name.toUpperCase().padEnd(6)} ${address}`);
+    }
+  });
+  return cmd;
+}
+
 // src/index.ts
-var program = new Command10();
-program.name("rare").description("CLI tool for interacting with the RARE protocol smart contracts").version("0.3.0");
+var program = new Command13();
+program.name("rare").description("CLI tool for interacting with the RARE protocol smart contracts").version("0.4.1");
 program.addCommand(configureCommand());
 program.addCommand(deployCommand());
 program.addCommand(mintCommand());
@@ -3993,6 +4548,9 @@ program.addCommand(walletCommand());
 program.addCommand(searchCommand());
 program.addCommand(listCollectionsCommand());
 program.addCommand(importCommand());
+program.addCommand(offerCommand());
+program.addCommand(listingCommand());
+program.addCommand(currenciesCommand());
 program.parseAsync(process.argv).catch((err) => {
   console.error("Error:", err.message ?? err);
   process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rareprotocol/rare-cli",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "CLI tool for interacting with the RARE protocol smart contracts",
   "type": "module",
   "license": "MIT",