schema.graphql

type Project @entity {
  "Unique identifier made up of contract address and project id"
  id: ID!

  "ID of the project on the contract"
  projectId: BigInt!

  "Determines if the project should be visible to the public"
  active: Boolean!

  "Address to split primary sales with the artist"
  additionalPayee: Bytes

  "Percentage of artist's share of primary sales that goes to additional payee"
  additionalPayeePercentage: BigInt

  "Address to split Secondary sales with the artist"
  additionalPayeeSecondarySalesAddress: Bytes

  "Percentage of artist's share of secondary sales that goes to additional payee"
  additionalPayeeSecondarySalesPercentage: BigInt

  "Address that receives secondary sales platform royalties (null for pre-V3 contracts, check Royalty Registry)"
  enginePlatformProviderSecondarySalesAddress: Bytes

  "Basis points of secondary sales allocated to the platform (null for pre-V3 contracts, check Royalty Registry)"
  enginePlatformProviderSecondarySalesBPS: BigInt

  "Address that receives secondary sales render provider royalties (null for pre-V3 contracts, check Royalty Registry)"
  renderProviderSecondarySalesAddress: Bytes

  "Basis points of secondary sales allocated to the render provider (null for pre-V3 contracts, check Royalty Registry)"
  renderProviderSecondarySalesBPS: BigInt

  "Artist that created the project"
  artist: Account!

  "Wallet address of the artist"
  artistAddress: Bytes!

  "Artist name"
  artistName: String

  baseIpfsUri: String
  baseUri: String

  "A project is complete when it has reached its maximum invocations"
  complete: Boolean!

  "Timestamp at which a project was completed"
  completedAt: BigInt

  "ERC-20 contract address if the project is purchasable via ERC-20"
  currencyAddress: Bytes

  "Currency symbol for ERC-20"
  currencySymbol: String

  "Number of decimals used to get a currency's display representation (i.e. 18 for ETH)"
  currencyDecimals: Int

  "Artist description of the project"
  description: String

  "Is the project dynamic or a static image"
  dynamic: Boolean!

  "Number of times the project has been invoked - number of tokens of the project"
  invocations: BigInt!

  ipfsHash: String

  "License for the project"
  license: String

  "For V3 and-on, this field is null, and projects lock 4 weeks after `completedAt`. Once the project is locked its script may never be updated again."
  locked: Boolean

  "Maximum number of invocations allowed for the project. Note that minter contracts may additionally limit a project's maxInvocations on a specific minter."
  maxInvocations: BigInt!

  "Project name"
  name: String

  "Purchases paused"
  paused: Boolean!

  pricePerTokenInWei: BigInt!

  "Artist/additional payee royalty percentage"
  royaltyPercentage: BigInt

  "The full script composed of scripts"
  script: String

  "Parts of the project script"
  scripts: [ProjectScript!] @derivedFrom(field: "project")

  "The number of scripts stored on-chain"
  scriptCount: BigInt!

  "The number of external asset dependencies stored on-chain"
  externalAssetDependencyCount: BigInt!

  "Once the project's external asset dependencies are locked they may never be modified again"
  externalAssetDependenciesLocked: Boolean!

  "Extra information about the script and rendering options"
  scriptJSON: String

  "Script type and version (see `scriptJSON` if null)"
  scriptTypeAndVersion: String

  "Script type and version override (override set on dependency registry)"
  scriptTypeAndVersionOverride: String

  "Aspect ratio of the project (see `scriptJSON` if null)"
  aspectRatio: String

  "Tokens of the project"
  tokens: [Token!] @derivedFrom(field: "project")

  "Does the project actually use the hash string"
  useHashString: Boolean!

  "Does the project use media from ipfs"
  useIpfs: Boolean

  "Artist or project website"
  website: String

  "Proposed Artist addresses and payment split percentages"
  proposedArtistAddressesAndSplits: ProposedArtistAddressesAndSplit

  "ERC-2981 royalty splitter address, used on v3.2 and-on"
  erc2981SplitterAddress: Bytes

  "The active royalty splitter contract, used on v3.2 and-on"
  erc2981SplitterContract: RoyaltySplitterContract

  "Accounts that own tokens of the project"
  owners: [AccountProject!] @derivedFrom(field: "project")

  "Receipts for this project, only on minters with settlement"
  receipts: [Receipt!] @derivedFrom(field: "project")

  createdAt: BigInt!
  updatedAt: BigInt!
  activatedAt: BigInt
  scriptUpdatedAt: BigInt
  contract: Contract!

  "Minter configuration for this project (not implemented prior to minter filters)"
  minterConfiguration: ProjectMinterConfiguration

  "Lookup table to get the Sale history of the project"
  saleLookupTables: [SaleLookupTable!]! @derivedFrom(field: "project")

  externalAssetDependencies: [ProjectExternalAssetDependency!]!
    @derivedFrom(field: "project")
}

type ProjectScript @entity {
  id: ID!
  index: BigInt!
  project: Project!
  script: String!
}

type ProposedArtistAddressesAndSplit @entity {
  "Unique identifier made up of contract address and project id"
  id: ID!

  "Proposed artist address"
  artistAddress: Bytes!

  "Proposed artist additional payee address for primary sales"
  additionalPayeePrimarySalesAddress: Bytes!

  "Proposed artist additional payee percentage for primary sales"
  additionalPayeePrimarySalesPercentage: BigInt!

  "Proposed artist additional payee address for secondary sales"
  additionalPayeeSecondarySalesAddress: Bytes!

  "Proposed artist additional payee percentage for secondary sales"
  additionalPayeeSecondarySalesPercentage: BigInt!

  "Project associated with this proposed artist addresses and splits"
  project: Project!

  createdAt: BigInt!
}

type CoreRegistry @entity {
  """
  Unique identifier made up of the Core Registry's contract address (legacy name was Engine Registry).
  Note: For legacy MinterFilters, this is a dummy ID, equal to the address of the single core contract
  associated with the minter filter.
  """
  id: ID!

  "All core contracts that are registered on this CoreRegistry, when this is most recent Core Registry to add the contract"
  registeredContracts: [Contract!] @derivedFrom(field: "registeredOn")

  "Latest dependency registry to use this Core Registry"
  dependencyRegistry: DependencyRegistry
}

enum CoreType {
  "First Art Blocks flagship core"
  GenArt721CoreV0
  "Second Art Blocks flagship core"
  GenArt721CoreV1
  "Art Blocks Engine & Partner cores"
  GenArt721CoreV2
  "Third Art Blocks flagship core"
  GenArt721CoreV3
  "V3 Derivative - Art Blocks Engine core"
  GenArt721CoreV3_Engine
  "V3 Derivative - Art Blocks Engine Flex core"
  GenArt721CoreV3_Engine_Flex
}

enum MinterFilterType {
  "IMinterFilterV0, no minterFilterType function"
  MinterFilterV0
  "IMinterFilterV0, added minterFilterType function"
  MinterFilterV1
  "IMinterFilterV1 includes minterFilterType function"
  MinterFilterV2
  "unknown minter filter type"
  UNKNOWN
}

type Contract @entity {
  "Unique identifier made up of the contract address"
  id: ID!

  admin: Bytes!

  "Core contract type"
  type: CoreType!

  "Core contract version (populated on V3 and-on)"
  coreVersion: String

  "Address that receives primary sales platform fees"
  renderProviderAddress: Bytes!

  "Percentage of primary sales allocated to the platform"
  renderProviderPercentage: BigInt!

  "Address that receives primary sales platform fees, only for V3_Engine contracts"
  enginePlatformProviderAddress: Bytes

  "Percentage of primary sales allocated to the platform, only for V3_Engine contracts"
  enginePlatformProviderPercentage: BigInt

  "Default address that receives secondary sales render provider royalties when adding new projects (null for pre-V3 contracts)"
  defaultRenderProviderSecondarySalesAddress: Bytes

  "Default basis points of secondary sales allocated to the render provider when adding new projects (null for pre-V3 contracts)"
  defaultRenderProviderSecondarySalesBPS: BigInt

  "Default address that receives secondary sales platform provider royalties when adding new projects (null for pre-V3 contracts)"
  defaultEnginePlatformProviderSecondarySalesAddress: Bytes

  "Default basis points of secondary sales allocated to the platform provider when adding new projects (null for pre-V3 contracts)"
  defaultEnginePlatformProviderSecondarySalesBPS: BigInt

  "List of contracts that are allowed to mint, equal to the single minterFilter address for V3 contracts"
  mintWhitelisted: [Bytes!]!

  "Randomizer contract used to generate token hashes"
  randomizerContract: Bytes

  "Curation registry contract address"
  curationRegistry: Bytes

  "Latest Override Allowlisted on Dependency Registry; only populated if allowlisted on a DependencyRegistry instead of the CoreRegistry"
  latestDependencyRegistryOverrideAllowlistedOn: DependencyRegistry

  "On chain pointer to dependency registry contract - not used for any on-chain logic or allowlisting. Null if not populated or set to non-indexed Dependency Registry address."
  dependencyRegistry: DependencyRegistry

  "On chain pointer to on-chain generator contract address - not used for any on-chain logic or allowlisting. Null if not populated on chain."
  onChainGenerator: Bytes

  "Curent royalty split provider contract address, used on v3.2 and-on"
  royaltySplitProvider: Bytes

  nextProjectId: BigInt!

  "List of projects on the contract"
  projects: [Project!] @derivedFrom(field: "contract")

  "List of tokens on the contract"
  tokens: [Token!] @derivedFrom(field: "contract")

  "Accounts whitelisted on the contract"
  whitelisted: [Whitelisting!] @derivedFrom(field: "contract")

  createdAt: BigInt!

  updatedAt: BigInt!

  "Associated minter filter contract, if any"
  minterFilter: MinterFilter

  preferredIPFSGateway: String

  preferredArweaveGateway: String

  "New projects forbidden (can only be true on V3+ contracts)"
  newProjectsForbidden: Boolean!

  "Automatically approve all artist split proposals (used on V3 Engine contracts)"
  autoApproveArtistSplitProposals: Boolean

  "Latest core registry that this contract is registered with, if any (used for indexing purposes)"
  registeredOn: CoreRegistry
}

type Whitelisting @entity {
  id: ID!
  account: Account!
  contract: Contract!
}

type Account @entity {
  id: ID!
  tokens: [Token!] @derivedFrom(field: "owner")

  "Projects the account owns tokens from"
  projectsOwned: [AccountProject!] @derivedFrom(field: "account")

  "Projects the account is listed as artist for"
  projectsCreated: [Project!] @derivedFrom(field: "artist")

  "Receipts for the account, on minters with settlement"
  receipts: [Receipt!] @derivedFrom(field: "account")

  "Contracts the account is whitelisted on"
  whitelistedOn: [Whitelisting!] @derivedFrom(field: "account")
}

type AccountProject @entity {
  id: ID!
  account: Account!
  project: Project!
  count: Int!
}

type Token @entity {
  "Unique identifier made up of contract address and token id"
  id: ID!

  "ID of the token on the contract"
  tokenId: BigInt!

  "Contract the token is on"
  contract: Contract!

  "Invocation number of the project"
  invocation: BigInt!

  "Unique string used as input to the tokens project script"
  hash: Bytes!

  "Current owner of the token"
  owner: Account!

  "Project of the token"
  project: Project!

  uri: String
  createdAt: BigInt!
  updatedAt: BigInt!

  "Transaction hash of token mint"
  transactionHash: Bytes!

  transfers: [Transfer!] @derivedFrom(field: "token")

  "Lookup table to get the Sale history"
  saleLookupTables: [SaleLookupTable!]! @derivedFrom(field: "token")

  "Next available sale id"
  nextSaleId: BigInt!

  primaryPurchaseDetails: PrimaryPurchase
}

type PrimaryPurchase @entity {
  "Unique identifier made up of contract address and token id"
  id: ID!

  token: Token!

  "Transaction hash of token purchase"
  transactionHash: Bytes!

  "Address of the minter used to mint token"
  minterAddress: Bytes

  "Address of currency used to purchase token"
  currencyAddress: Bytes

  "Symbol of currency used to purchase token"
  currencySymbol: String

  "Number of decimals used to get a currency's display representation (i.e. 18 for ETH)"
  currencyDecimals: Int
}

type MinterFilter @entity {
  "Unique identifier made up of minter filter contract address"
  id: ID!

  "Minters allowlisted globally on this MinterFilter"
  minterGlobalAllowlist: [Minter!]!

  """
  Minters allowlisted at a contract-level on this MinterFilter. In general, this allows a core contract to
  extend the global minter allowlist to allow minters that are not globally allowlisted.
  Note: only used for MinterFilterV2+
  """
  minterFilterContractAllowlists: [MinterFilterContractAllowlist!]!
    @derivedFrom(field: "minterFilter")

  "Known minters that are tied to this MinterFilter, but are not necessarily approved on this MinterFilter"
  knownMinters: [Minter!]! @derivedFrom(field: "minterFilter")

  """
  Core contract registry used by this MinterFilter.
  Note that for MinterFilterV0 & MinterFilterV1, a dummy CoreRegistry is created in the subgraph that
  contains a single allowlisted core contract.
  """
  coreRegistry: CoreRegistry!

  """
  Speficies which MinterFilter type this MinterFilter is
  """
  type: MinterFilterType!

  updatedAt: BigInt!
}

type MinterFilterContractAllowlist @entity {
  "Unique identifier made up of {minter filter contract address}-{core contract address}"
  id: ID!

  "MinterFilter contract"
  minterFilter: MinterFilter!

  "Core contract"
  contract: Contract!

  "Minter contract addresses allowed at the contract level (extending global MinterFilter allowlist)"
  minterContractAllowlist: [Minter!]!

  updatedAt: BigInt!
}

type Minter @entity {
  "Unique identifier made up of minter contract address"
  id: ID!

  "Minter type - String if minter returns it's type, empty string otherwise"
  type: String!

  "Associated Minter Filter"
  minterFilter: MinterFilter!

  "Boolean representing if the Mitner is globally allowed on its associated minter filter"
  isGloballyAllowlistedOnMinterFilter: Boolean!

  "Configuration details used by specific minters (json string)"
  extraMinterDetails: String!

  "Receipts for this minter, only for minters with settlement"
  receipts: [Receipt!] @derivedFrom(field: "minter")

  updatedAt: BigInt!
}

type ProjectMinterConfiguration @entity {
  "Unique identifier made up of {minter contract address}-{core contract address}-{project number}"
  id: ID!

  "The associated project"
  project: Project!

  "The associated minter"
  minter: Minter!

  "true if project's token price has been configured on minter"
  priceIsConfigured: Boolean!

  "currency symbol as defined on minter - ETH reserved for ether"
  currencySymbol: String!

  "currency address as defined on minter - address(0) reserved for ether"
  currencyAddress: Bytes!

  "number of decimals used to get a currency's display representation (i.e. 18 for ETH)"
  currencyDecimals: Int!

  "Defines if purchasing token to another is allowed"
  purchaseToDisabled: Boolean!

  "price, or resting price of Duch auction, or minimum bid price in English auction, in wei"
  basePrice: BigInt

  "Configuration details used by specific minter project configurations (json string)"
  extraMinterDetails: String!

  "Maximum number of invocations allowed for the project (on the minter). If less than than a project's maximum invocations defined on a core contract, the minter contract will limit this project's maximum invocations"
  maxInvocations: BigInt
}

enum BidType {
  RAM
  SEA
}

type Bid @entity {
  "Unique identifier: SEA - {minter contract address}-{bidder}-{value}-{token}; RAM - {minter contract address}-{full project ID}-{bidID}"
  id: ID!

  "The bid type (RAM | SEA)"
  bidType: BidType!

  "The associated project"
  project: Project!

  "The associated minter"
  minter: Minter!

  "The token associated with SEA bids or winning RAM bids post-settlement"
  token: Token

  "The associated account"
  bidder: Account!

  "The value of the bid"
  value: BigInt!

  "The slot index of the bid (RAM only)"
  slotIndex: BigInt

  "Indicates the highest bid for SEA; For RAM, true for bids that won post-settlement otherwise false."
  winningBid: Boolean!

  "Indicates bid was removed"
  isRemoved: Boolean

  "Indicates settlement status (RAM only)"
  settled: Boolean

  "Transaction hash that created the bid"
  txHash: Bytes!

  "The timestamp of the bid"
  timestamp: BigInt!

  "The log index of the event triggering bid update"
  logIndex: BigInt!

  updatedAt: BigInt!
}

type Receipt @entity {
  "Unique identifier made up of {minter contract address}-{core contract address}-{project number}-{account address}"
  id: ID!

  "The associated project"
  project: Project!

  "The associated minter"
  minter: Minter!

  "The associated account"
  account: Account!

  "The total net amount posted (sent to settlement contract) for tokens"
  netPosted: BigInt!

  "The total quantity of tokens purchased on the project"
  numPurchased: BigInt!

  updatedAt: BigInt!
}

type SplitAtomicFactory @entity {
  "unique identifier equal to split atomic factory contract address"
  id: ID!

  "type of split atomic factory"
  type: String!

  "implementation contract address for the created EIP-1167 minimal proxy contracts"
  implementation: Bytes!

  "List of split atomic contracts created by this factory"
  splitAtomicContracts: [SplitAtomicContract!]!
    @derivedFrom(field: "splitAtomicFactory")

  "Required split address for this factory"
  requiredSplitAddress: Bytes

  "Required split basis points for this factory"
  requiredSplitBasisPoints: BigInt

  "Boolean representing if the factory is abandoned (can no longer be used to create new contracts)"
  abandoned: Boolean!

  updatedAt: BigInt!
}

type SplitAtomicContract @entity {
  "unique identifier equal to split atomic contract address"
  id: ID!

  "type of split atomic contract"
  type: String!

  "Split atomic factory that created this contract"
  splitAtomicFactory: SplitAtomicFactory!

  "implementation contract address for this EIP-1167 minimal proxy"
  implementation: Bytes!

  "List of split atomic contract splits"
  splits: [SplitAtomicSplit!]! @derivedFrom(field: "splitAtomicContract")

  updatedAt: BigInt!
}

type SplitAtomicSplit @entity {
  "unique identifier equal to split atomic contract address + index"
  id: ID!

  "Split atomic contract that created this split"
  splitAtomicContract: SplitAtomicContract!

  "Index of this split"
  index: BigInt!

  "Address of the recipient of this split"
  recipient: Bytes!

  "Basis points of the split"
  basisPoints: BigInt!
}

type RoyaltySplitterContract @entity {
  "unique identifier equal to royalty splitter's contract address"
  id: ID!

  "split provider contract address that was used to create this contract"
  splitProviderCreator: Bytes!

  "Core contract that this royalty splitter is associated with"
  coreContract: Contract!

  "Total allocation of all recipients on the contract"
  totalAllocation: BigInt!

  "List of split atomic contract splits"
  royaltySplitRecipients: [RoyaltySplitRecipient!]!
    @derivedFrom(field: "royaltySplitterContract")

  createdAt: BigInt!
}

type RoyaltySplitRecipient @entity {
  "unique identifier equal to {royalty splitter contract address}-{recipient address}"
  id: ID!

  "Royalty splitter contract that contains this split recipient"
  royaltySplitterContract: RoyaltySplitterContract!

  "Address of the recipient of this split"
  recipientAddress: Bytes!

  "Allocation of the recipient on the split. Recipient receives allocation / totalAllocation of all funds sent to the splitter"
  allocation: BigInt!
}

enum SaleType {
  Single
  Bundle
}

enum PaymentType {
  Native
  ERC20
  ERC721
  ERC1155
}

enum Exchange {
  "Opensea V1"
  OS_V1
  "Opensea V2"
  OS_V2
  "LooksRare"
  LR_V1
  "Opensea Seaport"
  OS_SP
}

type Payment @entity {
  "Payment id formatted: '{SaleId}-{paymentNumber}' (paymentNumber will be 0 for non-Seaport trades)"
  id: ID!

  "Type of token transferred in this payment"
  paymentType: PaymentType!

  "The address of the token used for the payment"
  paymentToken: Bytes!

  "The price of the sale"
  price: BigInt!

  "The associated sale"
  sale: Sale!

  "The recipient address"
  recipient: Bytes!
}

type Sale @entity {
  "The sale id formated: tokenId - token.nextSaleId (using first token sold for bundles) for Opensea V1/V2, orderHash from sale event for Looksrare and Seaport"
  id: ID!

  "The hash of the transaction"
  txHash: Bytes!

  "The exchange used for this sale"
  exchange: Exchange!

  "The sale type (Single | Bundle)"
  saleType: SaleType!

  "The block number of the sale"
  blockNumber: BigInt!

  "The timestamp of the sale"
  blockTimestamp: BigInt!

  "A raw formated string of the token(s) sold (i.e TokenID1::TokenID2::TokenID3)"
  summaryTokensSold: String!

  "Lookup table to get the list of Tokens sold in this sale"
  saleLookupTables: [SaleLookupTable!]! @derivedFrom(field: "sale")

  "The seller address"
  seller: Bytes!

  "The buyer address"
  buyer: Bytes!

  "List of Payment tokens involved in this sale"
  payments: [Payment!]! @derivedFrom(field: "sale")

  "Private sales are flagged by this boolean"
  isPrivate: Boolean!
}

type SaleLookupTable @entity {
  "Set to `Project Id::Token Id::Sale Id"
  id: ID!

  "The block number of the sale"
  blockNumber: BigInt!

  "Timestamp of the sale"
  timestamp: BigInt!

  "The associated project"
  project: Project!

  "The token sold"
  token: Token!

  "The associated sale"
  sale: Sale!
}

type Transfer @entity(immutable: true) {
  id: ID!

  token: Token!

  to: Bytes!

  from: Bytes!

  transactionHash: Bytes!

  blockHash: Bytes!
  blockNumber: BigInt!
  blockTimestamp: BigInt!
}

type License @entity {
  "Unique identifier made up of licenseType"
  id: ID!
  "Timestamp of last update"
  updatedAt: BigInt!
}

type Dependency @entity {
  "Unique identifier made up of dependency name and version separated by an @ symbol (e.g. p5js@1.0.0)"
  id: ID!
  "License Type of this dependency"
  licenseType: License!
  "Preffered CDN for this dependency"
  preferredCDN: String!
  "Additional CDNs for this dependency"
  additionalCDNs: [DependencyAdditionalCDN!]! @derivedFrom(field: "dependency")
  "Number of additional CDNs for this dependency"
  additionalCDNCount: BigInt!
  "Preffered repository for this dependency"
  preferredRepository: String!
  "Additional repositories for this dependency"
  additionalRepositoryCount: BigInt!
  "Number of additional repositories for this dependency"
  additionalRepositories: [DependencyAdditionalRepository!]!
    @derivedFrom(field: "dependency")
  "List of on-chain scripts that for this dependency"
  scripts: [DependencyScript!]! @derivedFrom(field: "dependency")
  "Number of on-chain scripts for this dependency"
  scriptCount: BigInt!
  "Concatenated string of all scripts for this dependency"
  script: String
  "Reference website for this dependency (e.g. https://p5js.org)"
  website: String!
  "Depenency registry contract that this dependency is registered on"
  dependencyRegistry: DependencyRegistry!
  "Timestamp of last update"
  updatedAt: BigInt!
}

type DependencyRegistry @entity {
  "Unique identifier made up of dependency registry contract address"
  id: Bytes!
  "Core registry that defines the base set of contracts supported by this registry"
  coreRegistry: CoreRegistry
  "List of core contracts that are explicitly allowlisted on this registry, extending those on the CoreRegistry"
  supportedCoreContractsOverride: [Contract!]!
    @derivedFrom(field: "latestDependencyRegistryOverrideAllowlistedOn")
  "List of dependencies that are registered on this registry contract"
  dependencies: [Dependency!] @derivedFrom(field: "dependencyRegistry")
  "Current owner of this contract"
  owner: Bytes!
  "Timestamp of last update"
  updatedAt: BigInt!
}

type DependencyAdditionalCDN @entity {
  "Unique identifier made up of dependency id and index"
  id: ID!
  "Dependency this additional CDN belongs to"
  dependency: Dependency!
  "URL of the CDN"
  cdn: String!
  "Index of this additional CDN"
  index: BigInt!
}

type DependencyAdditionalRepository @entity {
  "Unique identifier made up of dependency id and index"
  id: ID!
  "Dependency this additional repository belongs to"
  dependency: Dependency!
  "URL of the repository"
  repository: String!
  "Index of this additional repository"
  index: BigInt!
}

type DependencyScript @entity {
  "Unique identifier made up of dependency id and index"
  id: ID!
  "Dependency this script belongs to"
  dependency: Dependency!
  "Index of this script"
  index: BigInt!
  "Contents of script"
  script: String!
  "Address of the bytecode storage contract for this script"
  address: Bytes!
}

enum ProjectExternalAssetDependencyType {
  "Asset hosted on IPFS"
  IPFS
  "Asset hosted on Arweave"
  ARWEAVE
  "Asset hosted on chain"
  ONCHAIN
  "Asset defined on the Art Blocks Dependency Registry"
  ART_BLOCKS_DEPENDENCY_REGISTRY
}

type ProjectExternalAssetDependency @entity {
  "Unique identifier made up of projectId-index"
  id: ID!

  "The associated project"
  project: Project!

  "The dependency type"
  dependencyType: ProjectExternalAssetDependencyType!

  "The dependency cid. This will be the CID of the dependency if IPFS or ARWEAVE, empty string of ONCHAIN, or a string representation of the Art Blocks Dependency Registry's `dependencyNameAndVersion` if ART_BLOCKS_DEPENDENCY_REGISTRY."
  cid: String!

  "The dependency index"
  index: BigInt!

  "Address of the bytecode storage contract for this asset if it is of type ONCHAIN"
  bytecodeAddress: Bytes

  "The asset data if it is onchain"
  data: String
}