Merge pull request #579 from liteflow-labs/dev

Release v3.4.3

components/Cart/ItemSummary.tsx

@@ -29,7 +29,7 @@ const CartItemSummary: FC<Props> = ({ chainId, cartItems }) => {
 
   const orderedCartItems = useOrderByKey(
     offerIds,
-    data?.offerOpenSales?.nodes,
+    data?.listings?.nodes,
     (offers) => offers.id,
   )
 

components/Cart/Step/Selection.gql

@@ -1,5 +1,5 @@
 query FetchCartItems($offerIds: [UUID!]!) {
-  offerOpenSales(filter: { id: { in: $offerIds } }) {
+  listings(condition: { ids: $offerIds, status: [ACTIVE, EXPIRED] }) {
     nodes {
       id
       type

components/Cart/Step/Selection.tsx

@@ -53,14 +53,14 @@ const CartStepSelection: FC<Props> = ({ onSubmit }) => {
 
   const offers = useMemo(
     () =>
-      (data?.offerOpenSales?.nodes || []).reduce(
+      (data?.listings?.nodes || []).reduce(
         (prev, x) => ({ ...prev, [x.id]: x }),
         {} as Record<
           string,
-          NonNullable<FetchCartItemsQuery['offerOpenSales']>['nodes'][number]
+          NonNullable<FetchCartItemsQuery['listings']>['nodes'][number]
         >,
       ),
-    [data?.offerOpenSales?.nodes],
+    [data?.listings?.nodes],
   )
 
   const nonExpiredSelectedCartItems = useMemo(

components/Filter/FilterBy/Collection.tsx

@@ -17,11 +17,7 @@ import useTranslation from 'next-translate/useTranslation'
 import { FC, useCallback, useMemo, useState } from 'react'
 import { UseFormReturn } from 'react-hook-form'
 import { concatToQuery } from '../../../concat'
-import {
-  CollectionFilter,
-  StringFilter,
-  useSearchCollectionQuery,
-} from '../../../graphql'
+import { useSearchCollectionQuery } from '../../../graphql'
 import { Filter } from '../../../hooks/useAssetFilterFromQuery'
 import { formatError } from '../../../utils'
 import CollectionListItem from '../../Collection/ListItem'
@@ -53,14 +49,8 @@ const FilterByCollection: FC<Props> = ({
     variables: {
       offset: 0, // the offset change must be done when calling the fetchMore function to concat queries' results
       limit: PAGINATION_LIMIT,
-      filter: {
-        name: {
-          includesInsensitive: filterResult.collectionSearch || '',
-        } as StringFilter,
-        ...(filterResult.chains.length
-          ? { chainId: { in: filterResult.chains } }
-          : {}),
-      } as CollectionFilter,
+      chainIds: filterResult.chains,
+      search: filterResult.collectionSearch || null,
     },
     notifyOnNetworkStatusChange: true,
   })

components/Filter/FilterBy/Trait.tsx

@@ -20,11 +20,7 @@ import SearchInput from 'components/SearchInput'
 import useTranslation from 'next-translate/useTranslation'
 import { FC, useCallback, useState } from 'react'
 import { UseFormReturn } from 'react-hook-form'
-import {
-  CollectionTraitFilter,
-  StringFilter,
-  useFetchCollectionTraitsQuery,
-} from '../../../graphql'
+import { useFetchCollectionTraitsQuery } from '../../../graphql'
 import { Filter } from '../../../hooks/useAssetFilterFromQuery'
 import { formatError } from '../../../utils'
 
@@ -56,11 +52,7 @@ const FilterByTrait: FC<Props> = ({
       chainId: collection.chainId,
       offset: 0, // the offset change must be done when calling the fetchMore function to concat queries' results
       limit: PAGINATION_LIMIT,
-      filter: {
-        type: {
-          includesInsensitive: filterResult.propertySearch || '',
-        } as StringFilter,
-      } as CollectionTraitFilter,
+      search: filterResult.propertySearch || null,
     },
     notifyOnNetworkStatusChange: true,
   })
@@ -199,7 +191,7 @@ const FilterByTrait: FC<Props> = ({
                           defaultValue={
                             filterResult?.traits?.find(
                               (trait) => trait.type === type,
-                            )?.values
+                            )?.values || undefined
                           }
                         >
                           <Stack spacing={1}>

components/History/HistoryList.gql

@@ -4,14 +4,14 @@ query FetchAssetHistory(
   $tokenId: String!
   $limit: Int!
   $offset: Int!
-  $filter: [AssetHistoryAction!]
+  $actions: [AssetHistoryAction!]
 ) {
   assetHistories(
-    filter: {
-      chainId: { equalTo: $chainId }
-      collectionAddress: { equalTo: $collectionAddress }
-      tokenId: { equalTo: $tokenId }
-      action: { in: $filter }
+    condition: {
+      chainId: $chainId
+      collectionAddress: $collectionAddress
+      tokenId: $tokenId
+      actions: $actions
     }
     orderBy: DATE_DESC
     first: $limit

components/History/HistoryList.tsx

@@ -54,7 +54,7 @@ const HistoryList: FC<IProps> = ({ chainId, collectionAddress, tokenId }) => {
       tokenId,
       limit: LIMIT,
       offset,
-      filter,
+      actions: filter,
     },
   })
   const histories = historyData?.assetHistories?.nodes

components/HomeSection/Assets.gql

@@ -1,9 +1,5 @@
 query FetchDefaultAssetIds($limit: Int!) {
-  assets(
-    filter: { quantity: { greaterThan: "0" } }
-    orderBy: CREATED_AT_DESC
-    first: $limit
-  ) {
+  assets(orderBy: CREATED_AT_DESC, first: $limit) {
     nodes {
       chainId
       collectionAddress
@@ -12,11 +8,12 @@ query FetchDefaultAssetIds($limit: Int!) {
   }
 }
 
-query FetchAssets($limit: Int!, $filter: [AssetFilter!]!, $address: Address) {
-  assets(
-    filter: { quantity: { greaterThan: "0" }, and: $filter }
-    first: $limit
-  ) {
+query FetchAssets(
+  $limit: Int!
+  $ids: [AssetIdsCondition!]!
+  $address: Address
+) {
+  assets(condition: { ids: $ids }, first: $limit) {
     nodes {
       chainId
       collectionAddress

components/HomeSection/Assets.tsx

@@ -13,7 +13,6 @@ import useTranslation from 'next-translate/useTranslation'
 import { FC, useMemo } from 'react'
 import invariant from 'ts-invariant'
 import {
-  AssetFilter,
   useFetchAssetsQuery,
   useFetchDefaultAssetIdsQuery,
 } from '../../graphql'
@@ -67,23 +66,21 @@ const AssetsHomeSection: FC<Props> = ({ date }) => {
   const assetsQuery = useFetchAssetsQuery({
     variables: {
       limit: PAGINATION_LIMIT,
-      filter: {
-        or: (assetIds || [])
-          .map((x) => x.split('-'))
-          .map(([chainId, collectionAddress, tokenId]) => {
-            invariant(
-              chainId !== undefined &&
-                collectionAddress !== undefined &&
-                tokenId !== undefined,
-              'invalid collection',
-            )
-            return {
-              collectionAddress: { equalTo: collectionAddress.toLowerCase() },
-              chainId: { equalTo: parseInt(chainId, 10) },
-              tokenId: { equalTo: tokenId },
-            }
-          }),
-      } as AssetFilter,
+      ids: (assetIds || [])
+        .map((x) => x.split('-'))
+        .map(([chainId, collectionAddress, tokenId]) => {
+          invariant(
+            chainId !== undefined &&
+              collectionAddress !== undefined &&
+              tokenId !== undefined,
+            'invalid collection',
+          )
+          return {
+            collectionAddress: collectionAddress.toLowerCase(),
+            chainId: parseInt(chainId, 10),
+            tokenId: tokenId,
+          }
+        }),
       address: address || '',
     },
     skip: assetIds === undefined,

components/HomeSection/Collections.gql

@@ -1,5 +1,9 @@
-query FetchCollections($filter: CollectionFilter!, $limit: Int!) {
-  collections(filter: $filter, first: $limit, orderBy: TOTAL_VOLUME_DESC) {
+query FetchCollections($ids: [CollectionIdsCondition!]!, $limit: Int!) {
+  collections(
+    condition: { ids: $ids }
+    first: $limit
+    orderBy: TOTAL_VOLUME_DESC
+  ) {
     nodes {
       chainId
       address

components/HomeSection/Collections.tsx

@@ -3,11 +3,7 @@ import { useOrderByKey } from 'hooks/useOrderByKey'
 import useTranslation from 'next-translate/useTranslation'
 import { FC } from 'react'
 import invariant from 'ts-invariant'
-import {
-  CollectionFilter,
-  FetchCollectionsQuery,
-  useFetchCollectionsQuery,
-} from '../../graphql'
+import { FetchCollectionsQuery, useFetchCollectionsQuery } from '../../graphql'
 import useEnvironment from '../../hooks/useEnvironment'
 import useHandleQueryError from '../../hooks/useHandleQueryError'
 import HomeGridSection from './Grid'
@@ -19,17 +15,15 @@ const CollectionsHomeSection: FC<Props> = () => {
   const { t } = useTranslation('templates')
   const collectionsQuery = useFetchCollectionsQuery({
     variables: {
-      filter: {
-        or: HOME_COLLECTIONS.map((x) => x.split('-')).map(
-          ([chainId, collectionAddress]) => {
-            invariant(chainId && collectionAddress, 'invalid collection')
-            return {
-              address: { equalTo: collectionAddress.toLowerCase() },
-              chainId: { equalTo: parseInt(chainId, 10) },
-            }
-          },
-        ),
-      } as CollectionFilter,
+      ids: HOME_COLLECTIONS.map((x) => x.split('-')).map(
+        ([chainId, collectionAddress]) => {
+          invariant(chainId && collectionAddress, 'invalid collection')
+          return {
+            address: collectionAddress.toLowerCase(),
+            chainId: parseInt(chainId, 10),
+          }
+        },
+      ),
       limit: PAGINATION_LIMIT,
     },
     skip: !HOME_COLLECTIONS.length,

components/HomeSection/Featured.tsx

@@ -5,11 +5,7 @@ import useEnvironment from '../../hooks/useEnvironment'
 import Slider from '../Slider/Slider'
 import TokenHeader from './FeaturedToken'
 
-type Props = {
-  date: Date
-}
-
-const FeaturedHomeSection: FC<Props> = ({ date }) => {
+const FeaturedHomeSection: FC = () => {
   const { FEATURED_TOKEN } = useEnvironment()
 
   const featuredAssets = useMemo(
@@ -28,12 +24,11 @@ const FeaturedHomeSection: FC<Props> = ({ date }) => {
               chainId={parseInt(chainId, 10)}
               collectionAddress={collectionAddress.toLowerCase()}
               tokenId={tokenId}
-              date={date}
             />
           )
         },
       ),
-    [FEATURED_TOKEN, date],
+    [FEATURED_TOKEN],
   )
 
   if (FEATURED_TOKEN.length === 0) return null

components/HomeSection/FeaturedToken.gql

@@ -2,7 +2,6 @@ query FetchFeaturedToken(
   $chainId: Int!
   $collectionAddress: Address!
   $tokenId: String!
-  $now: Datetime!
   $address: Address
 ) {
   asset(
@@ -50,10 +49,10 @@ query FetchFeaturedToken(
     }
   }
   ownerships(
-    filter: {
-      chainId: { equalTo: $chainId }
-      collectionAddress: { equalTo: $collectionAddress }
-      tokenId: { equalTo: $tokenId }
+    condition: {
+      chainId: $chainId
+      collectionAddress: $collectionAddress
+      tokenId: $tokenId
     }
     orderBy: [
       QUANTITY_DESC
@@ -76,13 +75,13 @@ query FetchFeaturedToken(
       }
     }
   }
-  sales: offerOpenSales(
+  sales: listings(
     orderBy: [UNIT_PRICE_IN_REF_ASC, CREATED_AT_ASC]
-    filter: {
-      chainId: { equalTo: $chainId }
-      collectionAddress: { equalTo: $collectionAddress }
-      tokenId: { equalTo: $tokenId }
-      expiredAt: { greaterThan: $now }
+    condition: {
+      chainId: $chainId
+      collectionAddress: $collectionAddress
+      tokenId: $tokenId
+      status: ACTIVE
     } # TODO: implement pagination. when implementing pagination, find a way to get availableQuantity of all sales
   ) {
     nodes {
@@ -112,9 +111,9 @@ query FetchFeaturedToken(
   }
   currencies(
     orderBy: CREATED_AT_ASC
-    filter: {
-      chainId: { equalTo: $chainId }
-      address: { isNull: false } # keep only non-native currency. Cannot create bid with native currency.
+    condition: {
+      chainId: $chainId
+      onlyToken: true # keep only non-native currency. Cannot create bid with native currency.
     }
   ) {
     nodes {

components/HomeSection/FeaturedToken.tsx

@@ -20,26 +20,19 @@ import TokenMedia from '../Token/Media'
 import TokenMetadata from '../Token/Metadata'
 
 export type Props = {
-  date: Date
   chainId: number
   collectionAddress: string
   tokenId: string
 }
 
-const FeaturedToken: FC<Props> = ({
-  date,
-  chainId,
-  collectionAddress,
-  tokenId,
-}) => {
+const FeaturedToken: FC<Props> = ({ chainId, collectionAddress, tokenId }) => {
   const { address } = useAccount()
 
   const fetchFeaturedTokenQuery = useFetchFeaturedTokenQuery({
     variables: {
       chainId,
       collectionAddress,
       tokenId,
-      now: date,
       address: address || '',
     },
   })
@@ -52,9 +45,7 @@ const FeaturedToken: FC<Props> = ({
   const media = useDetectAssetMedia(asset)
 
   const refresh = useCallback(async () => {
-    await fetchFeaturedTokenQuery.refetch({
-      now: new Date(),
-    })
+    await fetchFeaturedTokenQuery.refetch()
   }, [fetchFeaturedTokenQuery])
 
   useCart({ onCheckout: fetchFeaturedTokenQuery.refetch })

components/HomeSection/Users.gql

@@ -1,5 +1,5 @@
 query FetchUsers($limit: Int!, $userIds: [Address!]!) {
-  users: accounts(filter: { address: { in: $userIds } }, first: $limit) {
+  users: accounts(condition: { addresses: $userIds }, first: $limit) {
     nodes {
       username
       address

components/Offer/Form/Checkout.tsx

@@ -41,7 +41,7 @@ type FormData = {
 }
 
 type Props = {
-  offer: NonNullable<CheckoutQuery['offer']>
+  offer: NonNullable<CheckoutQuery['listing']>
   onPurchased: () => void
   multiple?: boolean
 }