@fxhash/config 0.0.10 → 0.0.12

package/dist/index.d.ts

@@ -1,14 +1,429 @@
-import { type IEthApis, ethTestnetApis } from "./api/eth.js";
-import { type ITezosApis, tezosTestnetApis, tezosMainnetApis } from "./api/tezos.js";
-import { fxhashDevApis, fxhashPrdApis } from "./api/fxhash.js";
-import { type ITezosContracts, tezosMainnetContracts, tezosTestnetContracts } from "./contracts/tezos.js";
-import { type IEthContracts, ethTestnetContracts } from "./contracts/eth.js";
-import { type GPURenderingConfig } from "./config/gpu.js";
-import { fxhashConfig, prdConfig, devConfig, localConfig, config, setConfig } from "./config.js";
-import { type IFxhashEnvConfig, type IFxhashNetworkConfig, type TBlockchain, type TBlockchainNetwork, type TEnv, type IFxhashConfig } from "./types.js";
-export { ethTestnetApis, tezosTestnetApis, tezosMainnetApis, fxhashDevApis, fxhashPrdApis, tezosTestnetContracts, tezosMainnetContracts, ethTestnetContracts, fxhashConfig, devConfig, prdConfig, localConfig, config, setConfig, type IEthApis, type ITezosApis, type ITezosContracts, type IEthContracts, type IFxhashEnvConfig, type IFxhashNetworkConfig, type TBlockchain, type TBlockchainNetwork, type TEnv, type IFxhashConfig, type GPURenderingConfig };
-export * from "./types.js";
-export * from "./helpers.js";
-export * from "./utils/index.js";
-export { isAppMetadataValid } from "./config/metadata.js";
-export default fxhashConfig;
+import { Result } from "@fxhash/utils";
+import { IRichErrorMessages, RichError, RichErrorUnion } from "@fxhash/errors";
+
+//#region src/api/eth.d.ts
+interface IEthApis {
+  rpcs: string[];
+  reservoir: string;
+  safe: string;
+  whitelist: string;
+  alchemy: {
+    rpc: string;
+  };
+}
+declare const ethTestnetApis: IEthApis;
+//#endregion
+//#region src/api/tezos.d.ts
+interface ITezosApis {
+  tzktWebsite: string;
+  tzkt: string;
+  tzktPro: string;
+  rpcs: string[];
+}
+declare const tezosTestnetApis: ITezosApis;
+declare const tezosMainnetApis: ITezosApis;
+//#endregion
+//#region src/api/base.d.ts
+interface IBaseApis {
+  rpcs: string[];
+  reservoir: string;
+  safe: string;
+  whitelist: string;
+  alchemy: {
+    rpc: string;
+  };
+}
+//#endregion
+//#region src/config/algolia.d.ts
+type AlgoliaConfig = {
+  appId: string;
+  enabled: boolean;
+  indexGenerativeTokens: string;
+  indexOffers: string;
+  indexUsers: string;
+  indexArticles: string;
+  indexAccounts: string;
+};
+//#endregion
+//#region src/config/gpu.d.ts
+declare const GPU_VERSIONS: readonly ["v111", "v132"];
+type GPUVersion = (typeof GPU_VERSIONS)[number];
+interface GPURenderingVersionConfig {
+  date: string;
+  version: string;
+  batchArn: string;
+}
+type GPURenderingConfig = Record<GPUVersion, GPURenderingVersionConfig>;
+// Environment configs
+//#endregion
+//#region src/contracts/base.d.ts
+interface IBaseContracts {
+  multicall3: `0x${string}`;
+  seaport_zone: `0x${string}`;
+  issuer_factory_v1: `0x${string}`;
+  fixed_price_minter_v1: `0x${string}`;
+  dutch_auction_minter_v1: `0x${string}`;
+  mint_ticket_factory_v1: `0x${string}`;
+  ticket_redeemer_v1: `0x${string}`;
+  ipfs_renderer_v1: `0x${string}`;
+  onchfs_renderer_v1: `0x${string}`;
+  randomizer_v1: `0x${string}`;
+  role_registry_v1: `0x${string}`;
+  contract_registry_v1: `0x${string}`;
+  gen_art_token_impl_v1: `0x${string}`;
+  mint_ticket_impl_v1: `0x${string}`;
+  onchfs_file_system: `0x${string}`;
+  onchfs_content_store: `0x${string}`;
+  seaport: `0x${string}`;
+  fxhashTeamSafeAddress: `0x${string}`;
+  signerSafe: `0x${string}`;
+  moderationSafe: `0x${string}`;
+  farcaster_frame_fixed_price_minter_v1: `0x${string}`;
+  fx_token: `0x${string}`;
+  fx_airdrop: `0x${string}`;
+  fx_tez_airdrop: `0x${string}`;
+  fx_token_launchpad: `0x${string}`;
+  fx_project_factory: `0x${string}`;
+}
+//#endregion
+//#region src/contracts/eth.d.ts
+interface IEthContracts {
+  multicall3: `0x${string}`;
+  seaport_zone: `0x${string}`;
+  issuer_factory_v1: `0x${string}`;
+  fixed_price_minter_v1: `0x${string}`;
+  dutch_auction_minter_v1: `0x${string}`;
+  mint_ticket_factory_v1: `0x${string}`;
+  ticket_redeemer_v1: `0x${string}`;
+  ipfs_renderer_v1: `0x${string}`;
+  onchfs_renderer_v1: `0x${string}`;
+  randomizer_v1: `0x${string}`;
+  role_registry_v1: `0x${string}`;
+  contract_registry_v1: `0x${string}`;
+  gen_art_token_impl_v1: `0x${string}`;
+  mint_ticket_impl_v1: `0x${string}`;
+  onchfs_file_system: `0x${string}`;
+  onchfs_content_store: `0x${string}`;
+  seaport: `0x${string}`;
+  fxhashTeamSafeAddress: `0x${string}`;
+  signerSafe: `0x${string}`;
+  moderationSafe: `0x${string}`;
+  farcaster_frame_fixed_price_minter_v1: `0x${string}`;
+  fx_token: `0x${string}`;
+}
+declare const ethTestnetContracts: IEthContracts;
+/**
+* TODO
+* -----------------------------------------------------------------------------
+* Put the actual addresses.
+*/
+//#endregion
+//#region src/contracts/tezos.d.ts
+interface ITezosContracts {
+  allowed_mint: string;
+  allowed_mint_issuer: string;
+  allowed_mint_issuer_v3: string;
+  allowed_mint_v3: string;
+  articles: string;
+  card_proxy: string;
+  collaboration_factory: string;
+  consumable_database: string;
+  cycles: string;
+  gentk_v1: string;
+  gentk_v1_data: string;
+  gentk_v2: string;
+  gentk_v3: string;
+  issuer_tickets: string;
+  issuer_v0: string;
+  issuer_v1: string;
+  issuer_v2: string;
+  issuer_v3: string;
+  marketplace_v1: string;
+  marketplace_v2: string;
+  marketplace_v3: string;
+  moderation_articles: string;
+  moderation_team: string;
+  moderation_token: string;
+  moderation_token_v3: string;
+  moderation_user: string;
+  pricing_dutch_auction: string;
+  pricing_dutch_auction_v3: string;
+  pricing_fixed: string;
+  pricing_fixed_v3: string;
+  randomizer: string;
+  randomizer_v2: string;
+  token_moderation: string;
+  treasury: string;
+  user_moderation: string;
+  user_register: string;
+  onchfs_files: string;
+}
+// The Tezos Smart Contracts addresses on testnet
+declare const tezosTestnetContracts: ITezosContracts;
+// The Tezos Smart Contracts on mainnet
+declare const tezosMainnetContracts: ITezosContracts;
+//#endregion
+//#region src/types.d.ts
+interface IFxhashApis {
+  website: string;
+  docs: string;
+  main: string;
+  hasura: string;
+  hasuraGql: string;
+  file: string;
+  fileInternal: string;
+  walletInternal: string;
+  fsEmulator: string;
+  extract: string;
+  extractInternal: string;
+  media: string;
+  ethMetadata: string;
+  ipfsInternal: string;
+  ipfsGateway: string;
+  ipfsGatewaySafe: string;
+  ipfsGatewayInternal: string;
+  onchfsProxy: string;
+  opensea: string;
+  authority: {
+    api: string;
+  };
+  capture: {
+    lambdas: {
+      small: string;
+      medium: string;
+      large: string;
+    };
+    proxy: {
+      ipfs: string;
+      onchfs: string;
+    };
+  };
+  events: {
+    liveBackend: string;
+  };
+  indexer: {
+    tez: string;
+    eth: string;
+    base: string;
+  };
+}
+/**
+* A mapping of blockchains in their "human-readable" format with their proper
+* blockchain identifier.
+*/
+declare const BlockchainIdentifiers: {
+  readonly TezosGhostnet: "tezos:NetXnHfVqm9iesp";
+  readonly TezosMainnet: "tezos:NetXdQprcVkpaWU";
+  readonly EthereumMainnet: "eip155:1";
+  readonly EthereumGoerli: "eip155:5";
+  readonly EthereumSepolia: "eip155:11155111";
+  readonly BaseSepolia: "eip155:84532";
+  readonly BaseMainnet: "eip155:8453";
+};
+/**
+* An union of all the blockchains supported by fxhash, defined by their chain
+* identifier. Can be used to facilitate typescript auto-completion with string
+* when enums aren't as good.
+*/
+type BlockchainIdentifier = (typeof BlockchainIdentifiers)[keyof typeof BlockchainIdentifiers];
+// the variations supported by the config
+type TBlockchain = "tez" | "eth" | "base";
+type TBlockchainNetwork = "testnet" | "mainnet";
+type TEnv = "dev" | "prd" | "local" | "localDocker";
+type TEnvName = "development" | "production" | "local" | "localDocker";
+interface IFxhashNetworkConfig {
+  network: string;
+  chainId: BlockchainIdentifier;
+  ethFeeReceiver: `0x${string}`;
+  wertRelayer: string;
+  fxhashFees: {
+    primary: number;
+    secondary: number;
+  };
+  royaltyBasisPoint: number;
+  splitBasisPoint: number;
+}
+/**
+* Meta info about the application. Can be used by wallets to scope the
+* application making requests for instance.
+*/
+interface IAppMetadata {
+  /**
+  * Application name. Will be displayed by wallets when a request is made
+  * (signing a message, sending a transaction)
+  */
+  name: string;
+  /**
+  * A short sentence (<25 words) describing the app. Might be used by wallets
+  * to display extra info about your app.
+  */
+  description: string;
+  /**
+  * **IMPORTANT**: This should match the URL in which the JS context making
+  * requests to wallets will be executed. **If doesn't match execution
+  * context domain, wallets may display a red warning.
+  */
+  url: string;
+  /**
+  * URL to your application icon. Recommended: PNG 256x256
+  * May be used by wallet apps in their UI when users interact with your app.
+  */
+  icon?: string;
+}
+interface IFxhashEnvConfig {
+  envName: TEnvName;
+  metadata: IAppMetadata;
+  gtMinPrice: string;
+  walletConnectId: string;
+  splitsApiKey: string;
+  projectLockTime: number;
+  referrerShare: number;
+  cloudflareTurnstileSiteKey: string;
+  cloudflareTurnstileSiteKeyV2: string;
+  syndicateProjectId: string;
+  awsS3Bucket: string;
+  awsS3Region: string;
+  openTelemetryTarget: string;
+  algolia: AlgoliaConfig;
+  gpu: GPURenderingConfig;
+  authJwtPublicKey: string;
+}
+type TBlockchainContacts = { [B in TBlockchain]: {
+  tez: ITezosContracts;
+  eth: IEthContracts;
+  base: IBaseContracts;
+}[B] };
+type TBlockchainApis = { [B in TBlockchain]: {
+  tez: ITezosApis;
+  eth: IEthApis;
+  base: IBaseApis;
+}[B] };
+type TNetworkBlockchainConfig = { [B in TBlockchain]: {
+  tez: IFxhashNetworkConfig;
+  eth: IFxhashNetworkConfig;
+  base: IFxhashNetworkConfig;
+}[B] };
+type IFxhashConfig = {
+  networks: { [N in TBlockchainNetwork]: { [B in TBlockchain]: {
+    contracts: TBlockchainContacts[B];
+    config: TNetworkBlockchainConfig[B];
+    apis: TBlockchainApis[B];
+  } } };
+  envs: { [K in TEnv]: {
+    apis: IFxhashApis;
+    config: IFxhashEnvConfig;
+  } };
+};
+type IFxhashConfigSingleEnv = { [B in TBlockchain]: {
+  contracts: TBlockchainContacts[B];
+  config: TNetworkBlockchainConfig[B];
+  apis: TBlockchainApis[B];
+} } & {
+  apis: IFxhashApis;
+  config: IFxhashEnvConfig;
+};
+//#endregion
+//#region src/api/fxhash.d.ts
+// list of APIs dev leverages
+declare const fxhashDevApis: IFxhashApis;
+// list of APIs for when fxhash is ran locally
+// The ports must correspond to the ports the services are running on
+// defined in the root docker compose file of the monorepo
+
+// list of APIs prod leverages
+declare const fxhashPrdApis: IFxhashApis;
+/**
+* Given some env, returns the associated APIs config.
+*/
+//#endregion
+//#region src/config.d.ts
+/**
+* --------------------------------------------------------
+*/
+declare const fxhashConfig: IFxhashConfig;
+declare const localConfig: IFxhashConfigSingleEnv;
+declare const devConfig: IFxhashConfigSingleEnv;
+declare const prdConfig: IFxhashConfigSingleEnv;
+declare let config: IFxhashConfigSingleEnv;
+declare function setConfig(userConfig: Partial<IFxhashConfigSingleEnv>): IFxhashConfigSingleEnv;
+//#endregion
+//#region src/helpers.d.ts
+declare function getDockerInternalUrl(url: string): string;
+declare const isProd: boolean;
+declare const isLocal: boolean;
+declare const isDockerLocal: boolean;
+declare function getEnv(): TEnv;
+//#endregion
+//#region src/utils/cid.d.ts
+/**
+* Returns the CID or a resource, whether it's already a CID or an ipfs://<CID> or onchfs://<CID> resource
+* @param resource either a CID or an ipfs://<CID> or onchfs://<CID> string
+*/
+declare function cidFromUriOrCid(resource: string): string;
+//#endregion
+//#region src/utils/ipfs.d.ts
+declare enum EGatewayIpfs {
+  FXHASH = "FXHASH",
+  FXHASH_SAFE = "FXHASH_SAFE",
+  IPFSIO = "IPFSIO",
+}
+declare const ipfsRegex: RegExp;
+/**
+* Given a gateway enum, outputs the http url root of the gateway
+*/
+declare function ipfsGatewayRoot(gateway: EGatewayIpfs): string;
+/**
+* Returns the CID or a resource, whether it's already a CID or an ipfs://<CID> resource
+* @param resource either a CID or a ipfs://<CID> string
+*/
+declare function ipfsCidFromUriOrCid(resource: string): string;
+/**
+* Given a CID or ipfs://<CID>, returns an URL to a gateway pointing to the resource
+* @param resource the resource input, either a CID or ipfs://<CID>
+* @param gateway the gateway URL to use for the resource
+*/
+declare function ipfsGatewayUrl(resource: string | null | undefined, gateway?: EGatewayIpfs): string;
+/**
+* given a URI (either ipfs://<CID>, onchfs://<CID> or temp://<CID>),
+* returns the URL to the resource
+*/
+declare function proxyUrl(uri: string): string;
+//#endregion
+//#region src/utils/onchfs.d.ts
+declare const onchfsRegex: RegExp;
+/**
+* Returns the CID or a resource, whether it's already a CID or an onchfs://<CID> resource
+* @param resource either a CID or a onchfs://<CID> string
+*/
+declare function onchfsCidFromUriOrCid(resource: string): string;
+//#endregion
+//#region src/utils/contracts.d.ts
+declare const tezosContractPrefixesByContractAddress: Record<string, string>;
+declare function getObjktIdFromContract(contract: string, id: string): string;
+//#endregion
+//#region src/errors/metadata.d.ts
+declare class AppMetadataInvalidTypeError extends RichError {
+  name: "AppMetadataInvalidTypeError";
+  messages: {
+    dev: string;
+  };
+}
+declare class AppMetadataMissingPropertiesError extends RichError {
+  name: "AppMetadataMissingPropertiesError";
+  constructor(messages: IRichErrorMessages);
+  constructor(properties: string[]);
+}
+declare const AppMetadataErrors: (typeof AppMetadataInvalidTypeError | typeof AppMetadataMissingPropertiesError)[];
+type AppMetadataError = RichErrorUnion<typeof AppMetadataErrors>;
+//#endregion
+//#region src/config/metadata.d.ts
+/**
+* Test whether some value is a valid {@link IAppMetadata} interface. If not,
+* the issue causing it to be invalid is returned as a failure.
+* @param value Any value which should be tested for being valid App Metadata
+* @returns A Result with void success or failure with the issue
+*/
+declare function isAppMetadataValid(value: any): Result<void, AppMetadataError>;
+//#endregion
+export { BlockchainIdentifier, BlockchainIdentifiers, EGatewayIpfs, GPURenderingConfig, IAppMetadata, IEthApis, IEthContracts, IFxhashApis, IFxhashConfig, IFxhashConfigSingleEnv, IFxhashEnvConfig, IFxhashNetworkConfig, ITezosApis, ITezosContracts, TBlockchain, TBlockchainNetwork, TEnv, TEnvName, cidFromUriOrCid, config, fxhashConfig as default, fxhashConfig, devConfig, ethTestnetApis, ethTestnetContracts, fxhashDevApis, fxhashPrdApis, getDockerInternalUrl, getEnv, getObjktIdFromContract, ipfsCidFromUriOrCid, ipfsGatewayRoot, ipfsGatewayUrl, ipfsRegex, isAppMetadataValid, isDockerLocal, isLocal, isProd, localConfig, onchfsCidFromUriOrCid, onchfsRegex, prdConfig, proxyUrl, setConfig, tezosContractPrefixesByContractAddress, tezosMainnetApis, tezosMainnetContracts, tezosTestnetApis, tezosTestnetContracts };
+//# sourceMappingURL=index.d.ts.map