@rareprotocol/rare-cli 0.4.1 → 1.0.0

package/dist/addresses-BE3luaB3.d.ts

@@ -0,0 +1,87 @@
+import { Address, Chain } from 'viem';
+
+declare const supportedChains: readonly ["mainnet", "sepolia", "base", "base-sepolia"];
+type SupportedChain = (typeof supportedChains)[number];
+declare const viemChains: Record<SupportedChain, Chain>;
+declare const chainIds: Record<SupportedChain, number>;
+declare const defaultRpcUrls: Partial<Record<SupportedChain, string>>;
+type CanonicalV4Pool = {
+    currency0: Address;
+    currency1: Address;
+    fee: number;
+    tickSpacing: number;
+    hooks: Address;
+    poolId?: `0x${string}`;
+};
+type ContractAddresses = {
+    factory: Address;
+    auction: Address;
+    sovereignFactory?: Address;
+    lazySovereignFactory?: Address;
+    rareMinter?: Address;
+    lazyBatchMintFactory?: Address;
+    batchListing?: Address;
+    batchOfferCreator?: Address;
+    batchAuctionHouse?: Address;
+    marketplaceSettings?: Address;
+    erc20ApprovalManager?: Address;
+    erc721ApprovalManager?: Address;
+    liquidFactory?: Address;
+    swapRouter?: Address;
+    v4Quoter?: Address;
+};
+type CanonicalV4Pools = {
+    rareEthPool?: CanonicalV4Pool;
+    usdcEthPool?: CanonicalV4Pool;
+};
+declare const contractAddresses: Partial<Record<SupportedChain, ContractAddresses>>;
+declare const canonicalV4Pools: Partial<Record<SupportedChain, CanonicalV4Pools>>;
+declare const currencyNames: readonly ["eth", "rare", "usdc"];
+type CurrencyName = (typeof currencyNames)[number];
+type CurrencyInput = CurrencyName | Uppercase<CurrencyName> | Address;
+type CurrencyInfo = {
+    name: CurrencyName;
+    symbol: Uppercase<CurrencyName>;
+    chain: SupportedChain;
+    chainId: number;
+    address: Address;
+    decimals: number;
+    isNative: boolean;
+};
+type CustomCurrencyInfo = {
+    name: null;
+    symbol: null;
+    chain: SupportedChain;
+    chainId: number;
+    address: Address;
+    decimals: null;
+    isNative: false;
+};
+type ResolvedCurrency = CurrencyInfo | CustomCurrencyInfo;
+type CurrencyResolveResult = {
+    isValid: true;
+    currency: ResolvedCurrency;
+} | {
+    isValid: false;
+    error: 'unknown_currency' | 'unavailable_currency';
+    errorMessage: string;
+};
+declare const ETH_ADDRESS: Address;
+declare const PUBLIC_LISTING_TARGET: Address;
+declare function listCurrencies(chain: SupportedChain): CurrencyInfo[];
+declare function resolveCurrencyInfo(input: string, chain: SupportedChain): CurrencyResolveResult;
+declare function resolveCurrency(input: string, chain: SupportedChain): Address;
+declare function getContractAddresses(chain: SupportedChain): ContractAddresses;
+declare function getBatchListingAddress(chain: SupportedChain): Address;
+declare function getErc721ApprovalManagerAddress(chain: SupportedChain): Address;
+declare function getCanonicalV4Pools(chain: SupportedChain): CanonicalV4Pools;
+declare function getRareMinterAddress(chain: SupportedChain): Address;
+declare function isSupportedChain(value: string): value is SupportedChain;
+declare function getLiquidFactoryAddress(chain: SupportedChain): Address;
+declare function getSwapRouterAddress(chain: SupportedChain): Address;
+declare function getV4QuoterAddress(chain: SupportedChain): Address;
+declare function getCanonicalRareEthPool(chain: SupportedChain): CanonicalV4Pool;
+declare function getCanonicalUsdcEthPool(chain: SupportedChain): CanonicalV4Pool;
+declare function requireContractAddress(chain: SupportedChain, contractName: keyof ContractAddresses): Address;
+
+export { resolveCurrencyInfo as A, supportedChains as B, type CurrencyInput as C, viemChains as D, ETH_ADDRESS as E, PUBLIC_LISTING_TARGET as P, type ResolvedCurrency as R, type SupportedChain as S, type CurrencyInfo as a, type CurrencyName as b, type CustomCurrencyInfo as c, type CanonicalV4Pool as d, type CanonicalV4Pools as e, type ContractAddresses as f, type CurrencyResolveResult as g, canonicalV4Pools as h, chainIds as i, contractAddresses as j, currencyNames as k, defaultRpcUrls as l, getBatchListingAddress as m, getCanonicalRareEthPool as n, getCanonicalUsdcEthPool as o, getCanonicalV4Pools as p, getContractAddresses as q, getErc721ApprovalManagerAddress as r, getLiquidFactoryAddress as s, getRareMinterAddress as t, getSwapRouterAddress as u, getV4QuoterAddress as v, isSupportedChain as w, listCurrencies as x, requireContractAddress as y, resolveCurrency as z };

package/dist/batch-listing-Cu5Hoqxs.d.ts

@@ -0,0 +1,183 @@
+import { Hash, TransactionReceipt, WalletClient, Hex, Address } from 'viem';
+import { a as CurrencyInfo, c as CustomCurrencyInfo, C as CurrencyInput } from './addresses-BE3luaB3.js';
+
+type IntegerInput = bigint | number | string;
+type AmountInput = bigint | number | string;
+type TimestampInput = IntegerInput | Date;
+type WalletAccount = NonNullable<WalletClient['account']>;
+
+type ResolvedCurrencyWithDecimals = CurrencyInfo | (Omit<CustomCurrencyInfo, 'decimals'> & {
+    decimals: number;
+});
+type TransactionResult = {
+    txHash: Hash;
+    receipt: TransactionReceipt;
+};
+
+type BatchTokenListInputFormat = 'csv' | 'json';
+type BatchToken = {
+    contractAddress: Address;
+    tokenId: string;
+    chainId?: number;
+};
+type BatchTokenTreeEntry = BatchToken & {
+    leaf: Hex;
+    proof: Hex[];
+};
+type BatchTokenListArtifact = {
+    version: 1;
+    type: 'rare-batch-token-list';
+    root: Hex;
+    count: number;
+    chainId?: number;
+    tokens: BatchToken[];
+    entries: BatchTokenTreeEntry[];
+};
+type BatchTokenProofArtifact = {
+    version: 1;
+    type: 'rare-batch-token-proof';
+    root: Hex;
+    contractAddress: Address;
+    tokenId: string;
+    chainId?: number;
+    leaf: Hex;
+    proof: Hex[];
+    valid: boolean;
+};
+type BuildBatchTokenTreeParams = {
+    content: string;
+    format?: BatchTokenListInputFormat;
+    sourceName?: string;
+    chainId?: IntegerInput;
+};
+type BatchTokenProofParams = {
+    artifact: BatchTokenListArtifact;
+    contractAddress: Address;
+    tokenId: IntegerInput;
+    chainId?: IntegerInput;
+};
+type BatchTokenProofVerifyParams = {
+    root: Hex;
+    contractAddress: Address;
+    tokenId: IntegerInput;
+    proof: readonly Hex[];
+};
+type UtilsTreeArtifact = BatchTokenListArtifact;
+type UtilsTreeProofArtifact = BatchTokenProofArtifact;
+type BuildUtilsTreeParams = BuildBatchTokenTreeParams;
+type UtilsTreeProofParams = BatchTokenProofParams;
+type UtilsTreeProofVerifyParams = BatchTokenProofVerifyParams;
+
+type BatchListingTokenEntry = {
+    contract: Address;
+    tokenId: IntegerInput;
+};
+type BatchListingRootArtifact = {
+    root: `0x${string}`;
+    currency: Address;
+    amount: string;
+    splitAddresses: Address[];
+    splitRatios: number[];
+    tokens: {
+        contract: Address;
+        tokenId: string;
+    }[];
+    allowList?: {
+        root: `0x${string}`;
+        addresses: Address[];
+        endTimestamp?: string;
+    };
+};
+type BatchListingProofArtifact = {
+    root: `0x${string}`;
+    contract: Address;
+    tokenId: string;
+    proof: `0x${string}`[];
+    allowListProof?: `0x${string}`[];
+    allowListAddress?: Address;
+};
+type UtilsMerkleTokenEntry = BatchListingTokenEntry;
+type UtilsMerkleRootArtifact = BatchListingRootArtifact;
+type UtilsMerkleProofArtifact = BatchListingProofArtifact;
+type UtilsMerkleProofParams = {
+    artifact: UtilsMerkleRootArtifact;
+    contract: Address;
+    tokenId: IntegerInput;
+    buyer?: Address;
+};
+type BatchListingCreateParams = {
+    artifact: BatchListingRootArtifact;
+    autoApprove?: boolean;
+};
+type BatchListingCreateResult = {
+    root: `0x${string}`;
+    approvalTxHashes?: Hash[];
+} & TransactionResult;
+type BatchListingCancelParams = {
+    root?: `0x${string}`;
+    artifact?: BatchListingRootArtifact;
+    contract?: Address;
+    tokenId?: IntegerInput;
+};
+type BatchListingCancelResult = {
+    root: `0x${string}`;
+} & TransactionResult;
+type BatchListingBuyParams = {
+    proofArtifact?: BatchListingProofArtifact;
+    root?: `0x${string}`;
+    contract?: Address;
+    tokenId?: IntegerInput;
+    creator: Address;
+    currency: CurrencyInput;
+    price: AmountInput;
+    autoApprove?: boolean;
+};
+type BatchListingBuyResult = TransactionResult & {
+    approvalTxHash?: Hash;
+};
+type BatchListingSetAllowListParams = {
+    root?: `0x${string}`;
+    artifact?: BatchListingRootArtifact;
+    contract?: Address;
+    tokenId?: IntegerInput;
+    allowListRoot?: `0x${string}`;
+    endTime?: TimestampInput;
+};
+type BatchListingSetAllowListResult = {
+    root: `0x${string}`;
+    allowListRoot: `0x${string}`;
+    endTime: bigint;
+} & TransactionResult;
+type BatchListingStatusParams = {
+    root?: `0x${string}`;
+    creator: Address;
+    contract?: Address;
+    tokenId?: IntegerInput;
+    proof?: `0x${string}`[];
+};
+type BatchListingStatus = {
+    root: `0x${string}`;
+    seller: Address;
+    currencyAddress: Address;
+    amount: bigint;
+    splitRecipients: Address[];
+    splitRatios: number[];
+    nonce: bigint;
+    isEth: boolean;
+    hasListing: boolean;
+    allowList?: {
+        root: `0x${string}`;
+        endTimestamp: bigint;
+    };
+    tokenInRoot?: boolean;
+    tokenNonce?: bigint;
+};
+type BatchListingNamespace = {
+    create: (params: BatchListingCreateParams) => Promise<BatchListingCreateResult>;
+    cancel: (params: BatchListingCancelParams) => Promise<BatchListingCancelResult>;
+    buy: (params: BatchListingBuyParams) => Promise<BatchListingBuyResult>;
+    setAllowlist: (params: BatchListingSetAllowListParams) => Promise<BatchListingSetAllowListResult>;
+    status: (params: BatchListingStatusParams) => Promise<BatchListingStatus>;
+};
+
+export type { AmountInput as A, BatchTokenListArtifact as B, IntegerInput as I, ResolvedCurrencyWithDecimals as R, TimestampInput as T, UtilsTreeArtifact as U, WalletAccount as W, TransactionResult as a, BatchTokenProofArtifact as b, BatchListingNamespace as c, BuildUtilsTreeParams as d, UtilsTreeProofParams as e, UtilsTreeProofArtifact as f, UtilsTreeProofVerifyParams as g, UtilsMerkleProofParams as h, UtilsMerkleProofArtifact as i, BatchListingBuyParams as j, BatchListingBuyResult as k, BatchListingCancelParams as l, BatchListingCancelResult as m, BatchListingCreateParams as n, BatchListingCreateResult as o, BatchListingProofArtifact as p, BatchListingRootArtifact as q, BatchListingSetAllowListParams as r, BatchListingSetAllowListResult as s, BatchListingStatus as t, BatchListingStatusParams as u, BatchListingTokenEntry as v, UtilsMerkleRootArtifact as w, UtilsMerkleTokenEntry as x };