query node + tests - NFT mappings and tests

query-node/manifest.yml

@@ -194,33 +194,33 @@ mappings:
 
     # content NFTs
     - event: content.AuctionStarted
-      handler: content_AuctionStarted
+      handler: contentNft_AuctionStarted
     - event: content.NftIssued
-      handler: content_NftIssued
+      handler: contentNft_NftIssued
     - event: content.AuctionBidMade
-      handler: content_AuctionBidMade
+      handler: contentNft_AuctionBidMade
     - event: content.AuctionBidCanceled
-      handler: content_AuctionBidCanceled
+      handler: contentNft_AuctionBidCanceled
     - event: content.AuctionCanceled
-      handler: content_AuctionCanceled
+      handler: contentNft_AuctionCanceled
     - event: content.EnglishAuctionCompleted
-      handler: content_EnglishAuctionCompleted
+      handler: contentNft_EnglishAuctionCompleted
     - event: content.BidMadeCompletingAuction
-      handler: content_BidMadeCompletingAuction
+      handler: contentNft_BidMadeCompletingAuction
     - event: content.OpenAuctionBidAccepted
-      handler: content_OpenAuctionBidAccepted
+      handler: contentNft_OpenAuctionBidAccepted
     - event: content.OfferStarted
-      handler: content_OfferStarted
+      handler: contentNft_OfferStarted
     - event: content.OfferAccepted
-      handler: content_OfferAccepted
+      handler: contentNft_OfferAccepted
     - event: content.OfferCanceled
-      handler: content_OfferCanceled
+      handler: contentNft_OfferCanceled
     - event: content.NftSellOrderMade
-      handler: content_NftSellOrderMade
+      handler: contentNft_NftSellOrderMade
     - event: content.NftBought
-      handler: content_NftBought
+      handler: contentNft_NftBought
     - event: content.BuyNowCanceled
-      handler: content_BuyNowCanceled
+      handler: contentNft_BuyNowCanceled
 
     # working groups
     ## storage - workers

query-node/mappings/content/index.ts

@@ -1,3 +1,4 @@
 export * from './channel'
 export * from './curatorGroup'
 export * from './video'
+export * from './nft'

query-node/mappings/content/nft.ts

@@ -1,6 +1,6 @@
 // TODO: solve events' relations to videos and other entites that can be changed or deleted
 
-import { EventContext, StoreContext, DatabaseManager } from '@joystream/hydra-common'
+import { DatabaseManager, EventContext, StoreContext, SubstrateEvent } from '@joystream/hydra-common'
 import { genericEventFields, inconsistentState, unexpectedData, logger } from '../common'
 import {
   // entities
@@ -54,7 +54,7 @@ async function getExistingEntity<Type extends Video | Membership>(
   relations: string[] = []
 ): Promise<Type | undefined> {
   // load entity
-  const entity = await store.get(entityType, { where: { id } })
+  const entity = await store.get(entityType, { where: { id }, relations })
 
   return entity
 }
@@ -76,17 +76,23 @@ async function getRequiredExistingEntity<Type extends Video | Membership>(
   return entity
 }
 
-async function getAuctionFromVideo(
+async function getCurrentAuctionFromVideo(
   store: DatabaseManager,
   videoId: string,
   errorMessageForVideo: string,
-  errorMessageForAuction: string
+  errorMessageForAuction: string,
+  relations: string[] = []
 ): Promise<{ video: Video; auction: Auction }> {
   // load video
-  const video = await getRequiredExistingEntity(store, Video, videoId.toString(), errorMessageForVideo, ['auction'])
+  const video = await getRequiredExistingEntity(store, Video, videoId.toString(), errorMessageForVideo, [
+    'nft',
+    'nft.auctions',
+    ...relations.map((item) => `nft.auctions.${item}`),
+  ])
 
   // get auction
-  const auction = video.auction
+  const allAuctions = video.nft?.auctions || []
+  const auction = allAuctions.length ? allAuctions[allAuctions.length - 1] : null
 
   // ensure auction exists
   if (!auction) {
@@ -122,9 +128,14 @@ async function getNftFromVideo(
   }
 }
 
-async function resetNftTransactionalStatusFromVideo(store: DatabaseManager, videoId: string, errorMessage: string) {
+async function resetNftTransactionalStatusFromVideo(
+  store: DatabaseManager,
+  videoId: string,
+  errorMessage: string,
+  newOwner?: Membership
+) {
   // load NFT
-  const nft = await store.get(OwnedNft, { where: { video: { id: videoId.toString() } } as FindConditions<OwnedNft> })
+  const nft = await store.get(OwnedNft, { where: { id: videoId.toString() } as FindConditions<OwnedNft> })
 
   // ensure NFT
   if (!nft) {
@@ -134,6 +145,10 @@ async function resetNftTransactionalStatusFromVideo(store: DatabaseManager, vide
   // reset transactional status
   nft.transactionalStatus = new TransactionalStatusIdle()
 
+  if (newOwner) {
+    nft.ownerMember = newOwner
+  }
+
   // save NFT
   await store.save<OwnedNft>(nft)
 }
@@ -205,10 +220,88 @@ async function convertContentActor(
   throw new Error('Not-implemented ContentActor type used')
 }
 
+async function finishAuction(store: DatabaseManager, videoId: number) {
+  // load video and auction
+  const { video, auction } = await getCurrentAuctionFromVideo(
+    store,
+    videoId.toString(),
+    `Non-existing video's auction was completed`,
+    'Non-existing auction was completed',
+    ['lastBid', 'lastBid.bidder']
+  )
+
+  // load winner member
+  const winnerMemberId = (auction.lastBid as Bid).bidder.id
+  const winner = await getRequiredExistingEntity(
+    store,
+    Membership,
+    winnerMemberId.toString(),
+    'Non-existing auction winner'
+  )
+
+  // update NFT's transactional status
+  await resetNftTransactionalStatusFromVideo(store, videoId.toString(), `Non-existing NFT's auction completed`, winner)
+
+  // update auction
+  auction.isCompleted = true
+  auction.winningMember = winner
+
+  // save auction
+  await store.save<Auction>(auction)
+
+  return { video, winner }
+}
+
+async function createBid(
+  event: SubstrateEvent,
+  store: DatabaseManager,
+  memberId: number,
+  videoId: number,
+  bidAmount?: string
+) {
+  // load member
+  const member = await getRequiredExistingEntity(
+    store,
+    Membership,
+    memberId.toString(),
+    'Non-existing member bid in auction'
+  )
+
+  // load video and auction
+  const { video, auction } = await getCurrentAuctionFromVideo(
+    store,
+    videoId.toString(),
+    'Non-existing video got bid',
+    'Non-existing auction got bid canceled'
+  )
+
+  const amount = bidAmount ? new BN(bidAmount.toString()) : (auction.buyNowPrice as BN)
+
+  // prepare bid record
+  const bid = new Bid({
+    auction,
+    bidder: member,
+    amount: amount,
+    createdAt: new Date(event.blockTimestamp),
+    createdInBlock: event.blockNumber,
+    isCanceled: false,
+  })
+
+  // save bid
+  await store.save<Bid>(bid)
+
+  // update last bid in auction
+  auction.lastBid = bid
+
+  await store.save<Auction>(auction)
+
+  return { member, video }
+}
+
 export async function contentNft_AuctionStarted({ event, store }: EventContext & StoreContext): Promise<void> {
   // common event processing
 
-  const [ownerId, videoId, auctionParams] = new Content.AuctionStartedEvent(event).params
+  const [ownerActor, videoId, auctionParams] = new Content.AuctionStartedEvent(event).params
 
   // specific event processing
 
@@ -226,6 +319,12 @@ export async function contentNft_AuctionStarted({ event, store }: EventContext &
     return inconsistentState('Non-existing NFT auctioned', video.id.toString())
   }
 
+  // member seems to be only actor that can own NFT right now
+  if (!ownerActor.isMember) {
+    throw new Error(`Not implemented NFT owner type "${ownerActor}"`)
+  }
+  const ownerId = ownerActor.asMember
+
   // load member
   const member = await getRequiredExistingEntity(
     store,
@@ -243,13 +342,16 @@ export async function contentNft_AuctionStarted({ event, store }: EventContext &
 
   // prepare auction record
   const auction = new Auction({
-    video,
+    nft: video.nft,
     initialOwner: member,
     startingPrice: auctionParams.starting_price,
     buyNowPrice: new BN(auctionParams.buy_now_price.toString()),
     auctionType: createAuctionType(auctionParams.auction_type),
     minimalBidStep: auctionParams.minimal_bid_step,
     startsAtBlock: auctionParams.starts_at.isSome ? auctionParams.starts_at.unwrap().toNumber() : event.blockNumber,
+    plannedEndAtBlock: auctionParams.auction_type.isEnglish
+      ? event.blockNumber + auctionParams.auction_type.asEnglish.auction_duration.toNumber()
+      : undefined,
     isCanceled: false,
     isCompleted: false,
     whitelistedMembers,
@@ -259,7 +361,7 @@ export async function contentNft_AuctionStarted({ event, store }: EventContext &
   await store.save<Auction>(auction)
 
   const transactionalStatus = new TransactionalStatusAuction()
-  transactionalStatus.auction = auction
+  transactionalStatus.auctionId = auction.id
 
   video.nft.transactionalStatus = transactionalStatus
 
@@ -312,7 +414,7 @@ export async function contentNft_NftIssued({ event, store }: EventContext & Stor
   // specific event processing
 
   // load video
-  const video = await getRequiredExistingEntity(store, Video, videoId.toString(), 'Non-existing video auction started')
+  const video = await getRequiredExistingEntity(store, Video, videoId.toString(), 'NFT for non-existing video issed')
 
   // load owner
   const newOwner = await getExistingEntity(store, Membership, mbNewOwnerId.toString())
@@ -321,6 +423,7 @@ export async function contentNft_NftIssued({ event, store }: EventContext & Stor
 
   // prepare nft record
   const ownedNft = new OwnedNft({
+    id: video.id.toString(),
     video,
     ownerMember: newOwner,
     creatorRoyalty,
@@ -362,30 +465,15 @@ export async function contentNft_AuctionBidMade({ event, store }: EventContext &
   )
 
   // load video and auction
-  const { video, auction } = await getAuctionFromVideo(
+  const { video, auction } = await getCurrentAuctionFromVideo(
     store,
     videoId.toString(),
     'Non-existing video got bid',
     'Non-existing auction got bid canceled'
   )
 
-  // prepare bid record
-  const bid = new Bid({
-    auction,
-    bidder: member,
-    amount: new BN(bidAmount.toString()),
-    createdAt: new Date(event.blockTimestamp),
-    createdInBlock: event.blockNumber,
-    isCanceled: false,
-  })
-
-  // save bid
-  await store.save<Bid>(bid)
-
-  // update last bid in auction
-  auction.lastBid = bid
-
-  await store.save<Auction>(auction)
+  // create record for winning bid
+  await createBid(event, store, memberId.toNumber(), videoId.toNumber(), bidAmount.toString())
 
   // common event processing - second
 
@@ -409,11 +497,12 @@ export async function contentNft_AuctionBidCanceled({ event, store }: EventConte
   // specific event processing
 
   // load video and auction
-  const { video, auction } = await getAuctionFromVideo(
+  const { video, auction } = await getCurrentAuctionFromVideo(
     store,
     videoId.toString(),
     'Non-existing video got bid canceled',
-    'Non-existing auction got bid canceled'
+    'Non-existing auction got bid canceled',
+    ['lastBid']
   )
 
   // ensure bid exists
@@ -421,8 +510,12 @@ export async function contentNft_AuctionBidCanceled({ event, store }: EventConte
     return inconsistentState('Non-existing bid got canceled', auction.id.toString())
   }
 
-  // TOOD: should bid placed before `lastBid` be loaded and replaced here?
-  // update auction's last bid
+  auction.lastBid.isCanceled = true
+
+  // save auction
+  await store.save<Bid>(auction.lastBid)
+
+  // unset auction's last bid
   auction.lastBid = undefined
 
   // save auction
@@ -448,7 +541,7 @@ export async function contentNft_AuctionCanceled({ event, store }: EventContext
   // specific event processing
 
   // load video and auction
-  const { video, auction } = await getAuctionFromVideo(
+  const { video, auction } = await getCurrentAuctionFromVideo(
     store,
     videoId.toString(),
     'Non-existing video got bid canceled',
@@ -479,48 +572,26 @@ export async function contentNft_AuctionCanceled({ event, store }: EventContext
 export async function contentNft_EnglishAuctionCompleted({ event, store }: EventContext & StoreContext): Promise<void> {
   // common event processing
 
-  const [memberId, videoId] = new Content.EnglishAuctionCompletedEvent(event).params
+  // memberId ignored here because it references member that called extrinsic - that can be anyone!
+  const [, /* memberId */ videoId] = new Content.EnglishAuctionCompletedEvent(event).params
 
   // specific event processing
 
-  // load member
-  const member = await getRequiredExistingEntity(
-    store,
-    Membership,
-    memberId.toString(),
-    'Non-existing english-type auction was completed'
-  )
-
-  // load video and auction
-  const { video, auction } = await getAuctionFromVideo(
-    store,
-    videoId.toString(),
-    `Non-existing video's english-type auction was completed`,
-    'Non-existing english-type auction was completed'
-  )
-
-  // update NFT's transactional status
-  await resetNftTransactionalStatusFromVideo(store, videoId.toString(), `Non-existing NFT's auction completed`)
-
-  // update auction
-  auction.isCompleted = true
-  auction.winningMember = member
-
-  // save auction
-  await store.save<Auction>(auction)
+  const { winner, video } = await finishAuction(store, videoId.toNumber())
 
   // common event processing - second
 
   const announcingPeriodStartedEvent = new EnglishAuctionCompletedEvent({
     ...genericEventFields(event),
 
-    member,
+    winner,
     video,
   })
 
   await store.save<EnglishAuctionCompletedEvent>(announcingPeriodStartedEvent)
 }
 
+// called when auction bid's value is higher than buy-now value
 export async function contentNft_BidMadeCompletingAuction({
   event,
   store,
@@ -531,31 +602,11 @@ export async function contentNft_BidMadeCompletingAuction({
 
   // specific event processing
 
-  // load member
-  const member = await getRequiredExistingEntity(
-    store,
-    Membership,
-    memberId.toString(),
-    'Non-existing auction was completed by buy-now bid'
-  )
-
-  // load video and auction
-  const { video, auction } = await getAuctionFromVideo(
-    store,
-    videoId.toString(),
-    `Non-existing video's auction was completed by buy-now bid`,
-    `Non-existing auction was completed by buy-now bid`
-  )
-
-  // update NFT's transactional status
-  await resetNftTransactionalStatusFromVideo(store, videoId.toString(), `Non-existing NFT's auction completed by bid`)
-
-  // update auction
-  auction.isCompleted = true
-  auction.winningMember = member
+  // create record for winning bid
+  await createBid(event, store, memberId.toNumber(), videoId.toNumber())
 
-  // save auction
-  await store.save<Auction>(auction)
+  // winish auction and transfer ownership
+  const { winner: member, video } = await finishAuction(store, videoId.toNumber())
 
   // common event processing - second
 
@@ -576,30 +627,7 @@ export async function contentNft_OpenAuctionBidAccepted({ event, store }: EventC
 
   // specific event processing
 
-  // load video and auction
-  const { video, auction } = await getAuctionFromVideo(
-    store,
-    videoId.toString(),
-    `Non-existing video's auction accepted a bid`,
-    `Non-existing auction accepted a bid`
-  )
-
-  // ensure member won the auction (only contentActor allowed)
-  const tmpContentActor = await convertContentActor(store, contentActor)
-  if (!(tmpContentActor instanceof ContentActorMember)) {
-    return unexpectedData(`Unexpected content actor. Only Members allowed here.`)
-  }
-  const member = tmpContentActor.member
-
-  // update NFT's transactional status
-  await resetNftTransactionalStatusFromVideo(store, videoId.toString(), `Non-existing NFT's auction completed by bid`)
-
-  // update auction
-  auction.isCompleted = true
-  auction.winningMember = member
-
-  // save auction
-  await store.save<Auction>(auction)
+  const { video } = await finishAuction(store, videoId.toNumber())
 
   // common event processing - second
 
@@ -777,14 +805,10 @@ export async function contentNft_NftBought({ event, store }: EventContext & Stor
   )
 
   // read member
-  const member = new Membership({ id: memberId.toString() })
-
-  // update NFT
-  nft.transactionalStatus = new TransactionalStatusIdle()
-  nft.ownerMember = member
+  const winner = new Membership({ id: memberId.toString() })
 
-  // save NFT
-  await store.save<OwnedNft>(nft)
+  // update NFT's transactional status
+  await resetNftTransactionalStatusFromVideo(store, videoId.toString(), `Non-existing NFT's auction completed`, winner)
 
   // common event processing - second
 
@@ -792,7 +816,7 @@ export async function contentNft_NftBought({ event, store }: EventContext & Stor
     ...genericEventFields(event),
 
     video,
-    member,
+    member: winner,
   })
 
   await store.save<NftBoughtEvent>(announcingPeriodStartedEvent)

query-node/run-tests.sh

@@ -18,7 +18,7 @@ function cleanup() {
     docker-compose down -v
 }
 
-trap cleanup EXIT
+#trap cleanup EXIT
 
 # start node
 docker-compose up -d joystream-node

query-node/schemas/content.graphql

@@ -149,8 +149,6 @@ type Video @entity {
 
   "Is video featured or not"
   isFeatured: Boolean!
-
-  auction: Auction @derivedFrom(field: "video")
 }
 
 type VideoMediaMetadata @entity {

query-node/schemas/contentNft.graphql

@@ -57,7 +57,10 @@ type Curator @entity {
 "Represents NFT details"
 type OwnedNft @entity { # NFT in name can't be UPPERCASE because it causes codegen errors
   "NFT's video"
-  video: Video!
+  video: Video! @derivedFrom(field: "nft")
+
+  "Auctions done for this NFT"
+  auctions: [Auction!]! @derivedFrom(field: "nft")
 
   "Member owning the NFT (if any)"
   ownerMember: Membership
@@ -72,7 +75,7 @@ type OwnedNft @entity { # NFT in name can't be UPPERCASE because it causes codeg
   transactionalStatus: TransactionalStatus!
 
   "Creator royalty"
-  creatorRoyalty: Float!
+  creatorRoyalty: Float
 }
 
 "NFT transactional state"
@@ -130,8 +133,8 @@ type AuctionTypeOpen @variant {
 
 "Represents NFT auction"
 type Auction @entity {
-  "NFT's video"
-  video: Video!
+  "Auctioned NFT"
+  nft: OwnedNft!
 
   "Member starting NFT auction"
   initialOwner: Membership!
@@ -145,6 +148,8 @@ type Auction @entity {
   "Whether auction can be completed instantly"
   buyNowPrice: BigInt
 
+  # TODO: maybe there is a need to distinguish regular auction completion from buy now
+
   "The type of auction"
   auctionType: AuctionType!
 
@@ -159,8 +164,11 @@ type Auction @entity {
   "Block when auction starts"
   startsAtBlock: Int!
 
-  "Block when auction starts"
-  endedAtBlock: Int!
+  "Block when auction ended"
+  endedAtBlock: Int
+
+  "Block when auction is supposed to end"
+  plannedEndAtBlock: Int
 
   "Is auction canceled"
   isCanceled: Boolean!
@@ -187,8 +195,11 @@ type Bid @entity {
   "Amount bidded"
   amount: BigInt!
 
+  "Sign for canceled bid"
   isCanceled: Boolean!
 
   "Block in which the bid was placed"
   createdInBlock: Int!
 }
+
+# TODO entity for (cancelable) offers; will be needed to see history of offers

query-node/schemas/contentNftEvents.graphql

@@ -173,7 +173,7 @@ type EnglishAuctionCompletedEvent implements Event @entity {
   ### SPECIFIC DATA ###
 
   "Member claiming the auctioned NFT."
-  member: Membership!
+  winner: Membership!
 
   "Auctioned video."
   video: Video!

runtime-modules/content/src/lib.rs

@@ -1153,7 +1153,7 @@ decl_module! {
             actor: ContentActor<CuratorGroupId<T>, CuratorId<T>, MemberId<T>>,
             video_id: T::VideoId,
             royalty: Option<Royalty>,
-            metadata: Metadata,
+            metadata: NFTMetadata,
             to: Option<T::MemberId>,
         ) {
             let sender = ensure_signed(origin.clone())?;
@@ -2077,7 +2077,7 @@ decl_event!(
             ContentActor,
             VideoId,
             Option<Royalty>,
-            Metadata,
+            NFTMetadata,
             Option<MemberId>,
         ),
         AuctionBidMade(MemberId, VideoId, Balance, IsExtended),

runtime-modules/content/src/nft/types.rs

@@ -1,7 +1,7 @@
 use super::*;
 
 /// Metadata for NFT issuance
-pub type Metadata = Vec<u8>;
+pub type NFTMetadata = Vec<u8>;
 
 pub type CuratorGroupId<T> = <T as ContentActorAuthenticator>::CuratorGroupId;
 pub type CuratorId<T> = <T as ContentActorAuthenticator>::CuratorId;

tests/network-tests/src/Api.ts

@@ -32,7 +32,7 @@ import {
 import { FillOpeningParameters, ProposalId } from '@joystream/types/proposals'
 import { extendDebug } from './Debugger'
 import { InvertedPromise } from './InvertedPromise'
-import { VideoId, VideoCategoryId } from '@joystream/types/content'
+import { VideoId, VideoCategoryId, AuctionParams } from '@joystream/types/content'
 import { ChannelId } from '@joystream/types/common'
 import { ChannelCategoryMetadata, VideoCategoryMetadata } from '@joystream/metadata-protobuf'
 import { metadataToBytes } from '../../../cli/lib/helpers/serialization'
@@ -2003,4 +2003,134 @@ export class Api {
       accountFrom
     )
   }
+
+  async issueNft(
+    accountFrom: string,
+    memberId: number,
+    videoId: number,
+    metadata = '',
+    royaltyPercentage?: number,
+    toMemberId?: number | null
+  ): Promise<ISubmittableResult> {
+    const perbillOnePercent = 10 * 1000000
+
+    const royalty = this.api.createType(
+      'Option<Royalty>',
+      royaltyPercentage ? royaltyPercentage * perbillOnePercent : null
+    )
+    // TODO: find proper way to encode metadata (should they be raw string, hex string or some object?)
+    // const encodedMetadata = this.api.createType('Metadata', metadata)
+    // const encodedMetadata = this.api.createType('Metadata', metadata).toU8a() // invalid type passed to Metadata constructor
+    // const encodedMetadata = this.api.createType('Vec<u8>', metadata)
+    // const encodedMetadata = this.api.createType('Vec<u8>', 'someNonEmptyText') // decodeU8a: failed at 0x736f6d654e6f6e45… on magicNumber: u32:: MagicNumber mismatch: expected 0x6174656d, found 0x656d6f73
+    // const encodedMetadata = this.api.createType('Bytes', 'someNonEmptyText') // decodeU8a: failed at 0x736f6d654e6f6e45… on magicNumber: u32:: MagicNumber mismatch: expected 0x6174656d, found 0x656d6f73
+    // const encodedMetadata = this.api.createType('Metadata', {})
+    // const encodedMetadata = this.api.createType('Bytes', '0x') // error
+    // const encodedMetadata = this.api.createType('NFTMetadata', 'someNonEmptyText')
+    // const encodedMetadata = this.api.createType('NFTMetadata', 'someNonEmptyText').toU8a() // createType(NFTMetadata) // Vec length 604748352930462863646034177481338223 exceeds 65536
+    const encodedMetadata = this.api.createType('NFTMetadata', '').toU8a() // THIS IS OK!!! but only for empty string :-\
+    // try this later on // const encodedMetadata = this.api.createType('Vec<u8>', 'someNonEmptyText').toU8a()
+    // const encodedMetadata = this.api.createType('Vec<u8>', 'someNonEmptyText').toU8a() // throws error in QN when decoding this (but mb QN error)
+
+    const encodedToAccount = this.api.createType('Option<MemberId>', toMemberId || memberId)
+
+    return await this.sender.signAndSend(
+      this.api.tx.content.issueNft({ Member: memberId }, videoId, royalty, encodedMetadata, encodedToAccount),
+      accountFrom
+    )
+  }
+
+  createAuctionParameters(
+    auctionType: 'English' | 'Open',
+    startingPrice: BN,
+    minimalBidStep: BN,
+    buyNowPrice?: BN,
+    startInBlock?: BN,
+    whitelist: string[] = []
+  ): AuctionParams {
+    const encodedAuctionType =
+      auctionType === 'English'
+        ? {
+            English: {
+              extension_period: 5, // TODO - read min/max bounds from runtime and set min value here (?)
+              auction_duration: 5, // TODO - read min/max bounds from runtime and set min value here (?)
+            },
+          }
+        : {
+            Open: {
+              bid_lock_duration: 2, // TODO - read min/max bounds from runtime and set min value here (?)
+            },
+          }
+
+    return this.api.createType('AuctionParams', {
+      auction_type: this.api.createType('AuctionType', encodedAuctionType),
+      starting_price: this.api.createType('u128', startingPrice),
+      minimal_bid_step: this.api.createType('u128', minimalBidStep),
+      buy_now_price: this.api.createType('Option<BlockNumber>', buyNowPrice),
+      starts_at: this.api.createType('Option<BlockNumber>', startInBlock),
+      whitelist: this.api.createType('BTreeSet<StorageBucketId>', whitelist),
+    })
+  }
+
+  async startNftAuction(
+    accountFrom: string,
+    memberId: number,
+    videoId: number,
+    auctionParams: AuctionParams
+  ): Promise<ISubmittableResult> {
+    return await this.sender.signAndSend(
+      this.api.tx.content.startNftAuction({ Member: memberId }, videoId, auctionParams),
+      accountFrom
+    )
+  }
+
+  async bidInNftAuction(
+    accountFrom: string,
+    memberId: number,
+    videoId: number,
+    bidAmount: BN
+  ): Promise<ISubmittableResult> {
+    return await this.sender.signAndSend(this.api.tx.content.makeBid(memberId, videoId, bidAmount), accountFrom)
+  }
+
+  async claimWonEnglishAuction(accountFrom: string, memberId: number, videoId: number): Promise<ISubmittableResult> {
+    return await this.sender.signAndSend(this.api.tx.content.claimWonEnglishAuction(memberId, videoId), accountFrom)
+  }
+
+  async pickOpenAuctionWinner(accountFrom: string, memberId: number, videoId: number) {
+    return await this.sender.signAndSend(
+      this.api.tx.content.pickOpenAuctionWinner({ Member: memberId }, videoId),
+      accountFrom
+    )
+  }
+
+  async cancelOpenAuctionBid(accountFrom: string, participantId: number, videoId: number) {
+    return await this.sender.signAndSend(this.api.tx.content.cancelOpenAuctionBid(participantId, videoId), accountFrom)
+  }
+
+  async cancelNftAuction(accountFrom: string, ownerId: number, videoId: number) {
+    return await this.sender.signAndSend(
+      this.api.tx.content.cancelNftAuction({ Member: ownerId }, videoId),
+      accountFrom
+    )
+  }
+
+  async sellNft(accountFrom: string, videoId: number, ownerId: number, price: BN) {
+    return await this.sender.signAndSend(this.api.tx.content.sellNft(videoId, { Member: ownerId }, price), accountFrom)
+  }
+
+  async buyNft(accountFrom: string, videoId: number, participantId: number) {
+    return await this.sender.signAndSend(this.api.tx.content.buyNft(videoId, participantId), accountFrom)
+  }
+
+  async offerNft(accountFrom: string, videoId: number, ownerId: number, toMemberId: number, price: BN | null = null) {
+    return await this.sender.signAndSend(
+      this.api.tx.content.offerNft(videoId, { Member: ownerId }, toMemberId, price),
+      accountFrom
+    )
+  }
+
+  async acceptIncomingOffer(accountFrom: string, videoId: number) {
+    return await this.sender.signAndSend(this.api.tx.content.acceptIncomingOffer(videoId), accountFrom)
+  }
 }

tests/network-tests/src/QueryNodeApi.ts

@@ -10,6 +10,10 @@ import {
   GetChannelById,
   GetChannelByIdQuery,
   GetChannelByIdQueryVariables,
+  OwnedNftFieldsFragment,
+  GetOwnedNftByVideoId,
+  GetOwnedNftByVideoIdQuery,
+  GetOwnedNftByVideoIdQueryVariables,
 } from './graphql/generated/queries'
 import { Maybe } from './graphql/generated/schema'
 import { OperationDefinitionNode } from 'graphql'
@@ -156,4 +160,12 @@ export class QueryNodeApi {
     `
     return await this.queryNodeProvider.query({ query })
   }
+
+  public async ownedNftByVideoId(videoId: string): Promise<Maybe<OwnedNftFieldsFragment>> {
+    return this.firstEntityQuery<GetOwnedNftByVideoIdQuery, GetOwnedNftByVideoIdQueryVariables>(
+      GetOwnedNftByVideoId,
+      { videoId },
+      'ownedNfts'
+    )
+  }
 }

tests/network-tests/src/fixtures/content/createChannelsAndVideos.ts

@@ -13,15 +13,7 @@ import { DataObjectId, StorageBucketId } from '@joystream/types/storage'
 import { Worker, WorkerId } from '@joystream/types/working-group'
 import { createType } from '@joystream/types'
 import { singleBucketConfig } from '../../flows/storagev2/initStorage'
-
-interface IMember {
-  keyringPair: KeyringPair
-  account: string
-  memberId: MemberId
-}
-
-// settings
-const sufficientTopupAmount = new BN(1000000) // some very big number to cover fees of all transactions
+import { IMember } from './createMembers'
 
 const cliExamplesFolderPath = path.dirname(require.resolve('@joystream/cli/package.json')) + '/examples/content'
 
@@ -33,6 +25,7 @@ export class CreateChannelsAndVideosFixture extends BaseQueryNodeFixture {
   private videoCount: number
   private channelCategoryId: number
   private videoCategoryId: number
+  private author: IMember
   private createdItems: {
     channelIds: number[]
     videosData: ICreatedVideoData[]
@@ -46,7 +39,8 @@ export class CreateChannelsAndVideosFixture extends BaseQueryNodeFixture {
     channelCount: number,
     videoCount: number,
     channelCategoryId: number,
-    videoCategoryId: number
+    videoCategoryId: number,
+    author: IMember
   ) {
     super(api, query)
     this.paidTerms = paidTerms
@@ -55,6 +49,7 @@ export class CreateChannelsAndVideosFixture extends BaseQueryNodeFixture {
     this.videoCount = videoCount
     this.channelCategoryId = channelCategoryId
     this.videoCategoryId = videoCategoryId
+    this.author = author
     this.debug = extendDebug('fixture:CreateChannelsAndVideosFixture')
 
     this.createdItems = {
@@ -71,11 +66,16 @@ export class CreateChannelsAndVideosFixture extends BaseQueryNodeFixture {
     Execute this Fixture.
   */
   public async execute(): Promise<void> {
-    this.debug('Creating members')
-    const author = await this.prepareAuthor()
+    this.debug('Setting author')
+    await this.cli.importAccount(this.author.keyringPair)
+    await this.cli.chooseMemberAccount(this.author.memberId)
 
     this.debug('Creating channels')
-    this.createdItems.channelIds = await this.createChannels(this.channelCount, this.channelCategoryId, author.account)
+    this.createdItems.channelIds = await this.createChannels(
+      this.channelCount,
+      this.channelCategoryId,
+      this.author.account
+    )
 
     this.debug('Creating videos')
     this.createdItems.videosData = await this.createVideos(
@@ -98,45 +98,6 @@ export class CreateChannelsAndVideosFixture extends BaseQueryNodeFixture {
     )
   }
 
-  /**
-    Prepares author for the content to be created.
-  */
-  private async prepareAuthor(): Promise<IMember> {
-    // prepare memberships
-    const members = await this.createMembers(1)
-
-    const authorMemberIndex = 0
-    const author = members[authorMemberIndex]
-    author.keyringPair.setMeta({
-      ...author.keyringPair.meta,
-      ...getMemberDefaults(authorMemberIndex),
-    })
-
-    this.debug('Top-uping accounts')
-    await this.api.treasuryTransferBalanceToAccounts([author.keyringPair.address], sufficientTopupAmount)
-
-    return author
-  }
-
-  /**
-    Creates new accounts and registers memberships for them.
-  */
-  private async createMembers(numberOfMembers: number): Promise<IMember[]> {
-    const keyringPairs = (await this.api.createKeyPairs(numberOfMembers)).map((kp) => kp.key)
-    const accounts = keyringPairs.map((item) => item.address)
-    const buyMembershipsFixture = new BuyMembershipHappyCaseFixture(this.api, accounts, this.paidTerms)
-
-    await new FixtureRunner(buyMembershipsFixture).run()
-
-    const memberIds = buyMembershipsFixture.getCreatedMembers()
-
-    return keyringPairs.map((item, index) => ({
-      keyringPair: item,
-      account: accounts[index],
-      memberId: memberIds[index],
-    }))
-  }
-
   /**
     Retrieves storage bucket info.
   */

tests/network-tests/src/fixtures/content/createMembers.ts

@@ -0,0 +1,67 @@
+import { Debugger, extendDebug } from '../../Debugger'
+import { QueryNodeApi } from '../../QueryNodeApi'
+import { PaidTermId, MemberId } from '@joystream/types/members'
+import { BaseQueryNodeFixture, FixtureRunner } from '../../Fixture'
+import { Api } from '../../Api'
+import { KeyringPair } from '@polkadot/keyring/types'
+import BN from 'bn.js'
+import { BuyMembershipHappyCaseFixture } from '../membershipModule'
+
+export interface IMember {
+  keyringPair: KeyringPair
+  account: string
+  memberId: MemberId
+}
+
+export class CreateMembersFixture extends BaseQueryNodeFixture {
+  private debug: Debugger.Debugger
+  private paidTerms: PaidTermId
+  private memberCount: number
+  private topupAmount: BN
+  private createdItems: IMember[] = []
+
+  constructor(api: Api, query: QueryNodeApi, paidTerms: PaidTermId, memberCount: number, topupAmount: BN) {
+    super(api, query)
+    this.paidTerms = paidTerms
+    this.memberCount = memberCount
+    this.topupAmount = topupAmount
+    this.debug = extendDebug('fixture:NftAuctionFixture')
+  }
+
+  public getCreatedItems() {
+    return this.createdItems
+  }
+
+  /*
+    Execute this Fixture.
+  */
+  public async execute(): Promise<void> {
+    this.debug('Creating member')
+    this.createdItems = await this.createMembers(this.memberCount)
+
+    this.debug('Top-uping accounts')
+    await this.api.treasuryTransferBalanceToAccounts(
+      this.createdItems.map((item) => item.keyringPair.address),
+      this.topupAmount
+    )
+  }
+
+  /**
+    Creates new accounts and registers memberships for them.
+  */
+  private async createMembers(numberOfMembers: number): Promise<IMember[]> {
+    const keyringPairs = (await this.api.createKeyPairs(numberOfMembers)).map((kp) => kp.key)
+    const accounts = keyringPairs.map((item) => item.address)
+    const buyMembershipsFixture = new BuyMembershipHappyCaseFixture(this.api, accounts, this.paidTerms)
+
+    await new FixtureRunner(buyMembershipsFixture).run()
+
+    const memberIds = buyMembershipsFixture.getCreatedMembers()
+
+    return keyringPairs.map((item, index) => ({
+      keyringPair: item,
+      account: accounts[index],
+      memberId: memberIds[index],
+    }))
+  }
+}

tests/network-tests/src/fixtures/content/index.ts

@@ -1,6 +1,5 @@
 export * from './activeVideoCounters'
 export * from './createChannelsAndVideos'
 export * from './createContentStructure'
-export * from './nft/auction'
-export * from './nft/buyNow'
-export * from './nft/directOffer'
+export * from './createMembers'
+export * from './nft'

tests/network-tests/src/fixtures/content/nft/auction.ts

@@ -1,23 +0,0 @@
-import { Api } from '../../../Api'
-import { BaseQueryNodeFixture, FixtureRunner } from '../../../Fixture'
-import { JoystreamCLI } from '../../../cli/joystream'
-import { Debugger, extendDebug } from '../../../Debugger'
-import { QueryNodeApi } from '../../../QueryNodeApi'
-
-export class NftAuctionFixture extends BaseQueryNodeFixture {
-  private debug: Debugger.Debugger
-  private cli: JoystreamCLI
-
-  constructor(api: Api, query: QueryNodeApi, cli: JoystreamCLI) {
-    super(api, query)
-    this.cli = cli
-    this.debug = extendDebug('fixture:NftAuctionFixture')
-  }
-
-  /*
-    Execute this Fixture.
-  */
-  public async execute(): Promise<void> {
-    // TODO
-  }
-}

tests/network-tests/src/fixtures/content/nft/auctionCancelations.ts

@@ -0,0 +1,79 @@
+import { Api } from '../../../Api'
+import { BaseQueryNodeFixture, FixtureRunner } from '../../../Fixture'
+import { JoystreamCLI } from '../../../cli/joystream'
+import { Debugger, extendDebug } from '../../../Debugger'
+import { QueryNodeApi } from '../../../QueryNodeApi'
+import { IMember } from '../createMembers'
+import { PlaceBidsInAuctionFixture } from './placeBidsInAuction'
+import { Utils } from '../../../utils'
+import { assertNftOwner } from './utils'
+import BN from 'bn.js'
+
+export class AuctionCancelationsFixture extends BaseQueryNodeFixture {
+  private debug: Debugger.Debugger
+  private cli: JoystreamCLI
+  private videoId: number
+  private author: IMember
+  private participant: IMember
+
+  constructor(
+    api: Api,
+    query: QueryNodeApi,
+    cli: JoystreamCLI,
+    videoId: number,
+    author: IMember,
+    participant: IMember
+  ) {
+    super(api, query)
+    this.cli = cli
+    this.videoId = videoId
+    this.author = author
+    this.participant = participant
+    this.debug = extendDebug('fixture:AuctionCancelationsFixture')
+  }
+
+  /*
+    Execute this Fixture.
+  */
+  public async execute(): Promise<void> {
+    this.debug('Issue video NFT')
+    await this.api.issueNft(this.author.keyringPair.address, this.author.memberId.toNumber(), this.videoId)
+
+    this.debug('Start NFT auction')
+    const startingPrice = new BN(10) // TODO - read min/max bounds from runtime (?)
+    const minimalBidStep = new BN(10) // TODO - read min/max bounds from runtime (?)
+    const auctionParams = this.api.createAuctionParameters('Open', startingPrice, minimalBidStep)
+    await this.api.startNftAuction(
+      this.author.keyringPair.address,
+      this.author.memberId.toNumber(),
+      this.videoId,
+      auctionParams
+    )
+
+    this.debug('Place bid')
+    const placeBidsFixture = new PlaceBidsInAuctionFixture(
+      this.api,
+      this.query,
+      [this.participant],
+      startingPrice,
+      minimalBidStep,
+      this.videoId
+    )
+    await new FixtureRunner(placeBidsFixture).run()
+
+    this.debug('Wait for bid to be cancelable')
+    const bidLockDuration = 2 // TODO - read min/max bounds from runtime and set min value here (?)
+
+    const waitBlocks = bidLockDuration + 1
+    await Utils.wait(this.api.getBlockDuration().muln(waitBlocks).toNumber())
+
+    this.debug('Cancel bid')
+    await this.api.cancelOpenAuctionBid(this.participant.account, this.participant.memberId.toNumber(), this.videoId)
+
+    this.debug('Cancel auction')
+    await this.api.cancelNftAuction(this.author.account, this.author.memberId.toNumber(), this.videoId)
+
+    this.debug(`Check NFT ownership haven't change`)
+    await assertNftOwner(this.query, this.videoId, this.author)
+  }
+}

tests/network-tests/src/fixtures/content/nft/buyNow.ts

@@ -3,14 +3,31 @@ import { BaseQueryNodeFixture, FixtureRunner } from '../../../Fixture'
 import { JoystreamCLI } from '../../../cli/joystream'
 import { Debugger, extendDebug } from '../../../Debugger'
 import { QueryNodeApi } from '../../../QueryNodeApi'
+import { IMember } from '../createMembers'
+import { PlaceBidsInAuctionFixture } from './placeBidsInAuction'
+import BN from 'bn.js'
+import { assertNftOwner } from './utils'
 
 export class NftBuyNowFixture extends BaseQueryNodeFixture {
   private debug: Debugger.Debugger
   private cli: JoystreamCLI
+  private videoId: number
+  private author: IMember
+  private participant: IMember
 
-  constructor(api: Api, query: QueryNodeApi, cli: JoystreamCLI) {
+  constructor(
+    api: Api,
+    query: QueryNodeApi,
+    cli: JoystreamCLI,
+    videoId: number,
+    author: IMember,
+    participant: IMember
+  ) {
     super(api, query)
     this.cli = cli
+    this.videoId = videoId
+    this.author = author
+    this.participant = participant
     this.debug = extendDebug('fixture:NftBuyNowFixture')
   }
 
@@ -18,6 +35,17 @@ export class NftBuyNowFixture extends BaseQueryNodeFixture {
     Execute this Fixture.
   */
   public async execute(): Promise<void> {
-    // TODO
+    this.debug('Issue video NFT')
+    await this.api.issueNft(this.author.keyringPair.address, this.author.memberId.toNumber(), this.videoId)
+
+    this.debug('Start buy now auction')
+    const buyNowPrice = new BN(100) // value doesn't matter
+    await this.api.sellNft(this.author.keyringPair.address, this.videoId, this.author.memberId.toNumber(), buyNowPrice)
+
+    this.debug('Buy now')
+    await this.api.buyNft(this.participant.account, this.videoId, this.participant.memberId.toNumber())
+
+    this.debug('Check NFT ownership change')
+    await assertNftOwner(this.query, this.videoId, this.participant)
   }
 }

tests/network-tests/src/fixtures/content/nft/directOffer.ts

@@ -3,14 +3,29 @@ import { BaseQueryNodeFixture, FixtureRunner } from '../../../Fixture'
 import { JoystreamCLI } from '../../../cli/joystream'
 import { Debugger, extendDebug } from '../../../Debugger'
 import { QueryNodeApi } from '../../../QueryNodeApi'
+import { IMember } from '../createMembers'
+import { assertNftOwner } from './utils'
 
 export class NftDirectOfferFixture extends BaseQueryNodeFixture {
   private debug: Debugger.Debugger
   private cli: JoystreamCLI
+  private videoId: number
+  private author: IMember
+  private participant: IMember
 
-  constructor(api: Api, query: QueryNodeApi, cli: JoystreamCLI) {
+  constructor(
+    api: Api,
+    query: QueryNodeApi,
+    cli: JoystreamCLI,
+    videoId: number,
+    author: IMember,
+    participant: IMember
+  ) {
     super(api, query)
     this.cli = cli
+    this.videoId = videoId
+    this.author = author
+    this.participant = participant
     this.debug = extendDebug('fixture:NftDirectOfferFixture')
   }
 
@@ -18,6 +33,21 @@ export class NftDirectOfferFixture extends BaseQueryNodeFixture {
     Execute this Fixture.
   */
   public async execute(): Promise<void> {
-    // TODO
+    this.debug('Issue video NFT')
+    await this.api.issueNft(this.author.keyringPair.address, this.author.memberId.toNumber(), this.videoId)
+
+    this.debug('Offer NFT')
+    await this.api.offerNft(
+      this.author.keyringPair.address,
+      this.videoId,
+      this.author.memberId.toNumber(),
+      this.participant.memberId.toNumber()
+    )
+
+    this.debug('Accept offer')
+    await this.api.acceptIncomingOffer(this.participant.keyringPair.address, this.videoId)
+
+    this.debug('Check NFT ownership change')
+    await assertNftOwner(this.query, this.videoId, this.participant)
   }
 }

tests/network-tests/src/fixtures/content/nft/englishAuction.ts

@@ -0,0 +1,88 @@
+import { assert } from 'chai'
+import { Api } from '../../../Api'
+import { BaseQueryNodeFixture, FixtureRunner } from '../../../Fixture'
+import { JoystreamCLI } from '../../../cli/joystream'
+import { Debugger, extendDebug } from '../../../Debugger'
+import { QueryNodeApi } from '../../../QueryNodeApi'
+import { IMember } from '../createMembers'
+import { BuyMembershipHappyCaseFixture } from '../../membershipModule'
+import { PlaceBidsInAuctionFixture } from './placeBidsInAuction'
+import { PaidTermId } from '@joystream/types/members'
+import { Utils } from '../../../utils'
+import { assertNftOwner } from './utils'
+import BN from 'bn.js'
+
+// settings
+const sufficientTopupAmount = new BN(1000000) // some very big number to cover fees of all transactions
+
+export class NftEnglishAuctionFixture extends BaseQueryNodeFixture {
+  private debug: Debugger.Debugger
+  private cli: JoystreamCLI
+  private videoId: number
+  private author: IMember
+  private paidTerms: PaidTermId
+  private participants: IMember[]
+
+  constructor(
+    api: Api,
+    query: QueryNodeApi,
+    cli: JoystreamCLI,
+    paidTerms: PaidTermId,
+    videoId: number,
+    author: IMember,
+    participants: IMember[]
+  ) {
+    super(api, query)
+    this.cli = cli
+    this.videoId = videoId
+    this.author = author
+    this.paidTerms = paidTerms
+    this.participants = participants
+    this.debug = extendDebug('fixture:NftEnglishAuctionFixture')
+  }
+
+  /*
+    Execute this Fixture.
+  */
+  public async execute(): Promise<void> {
+    this.debug('Issue video NFT')
+    await this.api.issueNft(this.author.keyringPair.address, this.author.memberId.toNumber(), this.videoId)
+
+    this.debug('Start NFT auction')
+    const startingPrice = new BN(10) // TODO - read min/max bounds from runtime (?)
+    const minimalBidStep = new BN(10) // TODO - read min/max bounds from runtime (?)
+    const auctionParams = this.api.createAuctionParameters('English', startingPrice, minimalBidStep)
+    await this.api.startNftAuction(
+      this.author.keyringPair.address,
+      this.author.memberId.toNumber(),
+      this.videoId,
+      auctionParams
+    )
+
+    const winner = this.participants[this.participants.length - 1]
+
+    this.debug('Place bids')
+    const placeBidsFixture = new PlaceBidsInAuctionFixture(
+      this.api,
+      this.query,
+      this.participants,
+      startingPrice,
+      minimalBidStep,
+      this.videoId
+    )
+    await new FixtureRunner(placeBidsFixture).run()
+
+    this.debug('Wait for auction to end')
+    const auctionDuration = 5 // TODO: read from runtime
+    const extensionPeriod = 5 // TODO: read from runtime
+
+    const waitBlocks = Math.min(auctionDuration, extensionPeriod + this.participants.length) + 1
+    await Utils.wait(this.api.getBlockDuration().muln(waitBlocks).toNumber())
+
+    this.debug('Complete auction')
+    await this.api.claimWonEnglishAuction(winner.account, winner.memberId.toNumber(), this.videoId)
+
+    this.debug('Check NFT ownership change')
+    await assertNftOwner(this.query, this.videoId, winner)
+  }
+}

tests/network-tests/src/fixtures/content/nft/index.ts

@@ -0,0 +1,5 @@
+export * from './englishAuction'
+export * from './openAuction'
+export * from './buyNow'
+export * from './directOffer'
+export * from './auctionCancelations'

tests/network-tests/src/fixtures/content/nft/openAuction.ts

@@ -0,0 +1,79 @@
+import { Api } from '../../../Api'
+import { BaseQueryNodeFixture, FixtureRunner } from '../../../Fixture'
+import { JoystreamCLI } from '../../../cli/joystream'
+import { Debugger, extendDebug } from '../../../Debugger'
+import { QueryNodeApi } from '../../../QueryNodeApi'
+import { IMember } from '../createMembers'
+import { BuyMembershipHappyCaseFixture } from '../../membershipModule'
+import { PlaceBidsInAuctionFixture } from './placeBidsInAuction'
+import { PaidTermId } from '@joystream/types/members'
+import { assertNftOwner } from './utils'
+import BN from 'bn.js'
+
+// settings
+const sufficientTopupAmount = new BN(1000000) // some very big number to cover fees of all transactions
+
+export class NftOpenAuctionFixture extends BaseQueryNodeFixture {
+  private debug: Debugger.Debugger
+  private cli: JoystreamCLI
+  private videoId: number
+  private author: IMember
+  private paidTerms: PaidTermId
+  private participants: IMember[]
+
+  constructor(
+    api: Api,
+    query: QueryNodeApi,
+    cli: JoystreamCLI,
+    paidTerms: PaidTermId,
+    videoId: number,
+    author: IMember,
+    participants: IMember[]
+  ) {
+    super(api, query)
+    this.cli = cli
+    this.videoId = videoId
+    this.author = author
+    this.paidTerms = paidTerms
+    this.participants = participants
+    this.debug = extendDebug('fixture:NftOpenAuctionFixture')
+  }
+
+  /*
+    Execute this Fixture.
+  */
+  public async execute(): Promise<void> {
+    this.debug('Issue video NFT')
+    await this.api.issueNft(this.author.keyringPair.address, this.author.memberId.toNumber(), this.videoId)
+
+    this.debug('Start NFT auction')
+    const startingPrice = new BN(10) // TODO - read min/max bounds from runtime (?)
+    const minimalBidStep = new BN(10) // TODO - read min/max bounds from runtime (?)
+    const auctionParams = this.api.createAuctionParameters('Open', startingPrice, minimalBidStep)
+    await this.api.startNftAuction(
+      this.author.keyringPair.address,
+      this.author.memberId.toNumber(),
+      this.videoId,
+      auctionParams
+    )
+
+    const winner = this.participants[this.participants.length - 1]
+
+    this.debug('Place bids')
+    const memberSetFixture = new PlaceBidsInAuctionFixture(
+      this.api,
+      this.query,
+      this.participants,
+      startingPrice,
+      minimalBidStep,
+      this.videoId
+    )
+    await new FixtureRunner(memberSetFixture).run()
+
+    this.debug('Complete auction')
+    await this.api.pickOpenAuctionWinner(this.author.keyringPair.address, this.author.memberId.toNumber(), this.videoId)
+
+    this.debug('Check NFT ownership change')
+    await assertNftOwner(this.query, this.videoId, winner)
+  }
+}

tests/network-tests/src/fixtures/content/nft/placeBidsInAuction.ts

@@ -0,0 +1,44 @@
+import { Api } from '../../../Api'
+import { BaseQueryNodeFixture, FixtureRunner } from '../../../Fixture'
+import { Debugger, extendDebug } from '../../../Debugger'
+import { QueryNodeApi } from '../../../QueryNodeApi'
+import { IMember } from '../createMembers'
+import BN from 'bn.js'
+
+export class PlaceBidsInAuctionFixture extends BaseQueryNodeFixture {
+  private debug: Debugger.Debugger
+  private participants: IMember[]
+  private startingPrice: BN
+  private minimalBidStep: BN
+  private videoId: number
+
+  constructor(
+    api: Api,
+    query: QueryNodeApi,
+    participants: IMember[],
+    startingPrice: BN,
+    minimalBidStep: BN,
+    videoId: number
+  ) {
+    super(api, query)
+    this.participants = participants
+    this.startingPrice = startingPrice
+    this.minimalBidStep = minimalBidStep
+    this.videoId = videoId
+    this.debug = extendDebug('fixture:PlaceBidsInAuctionFixture')
+  }
+
+  /*
+    Execute this Fixture.
+  */
+  public async execute(): Promise<void> {
+    this.debug('Put bids in auction')
+    const winner = this.participants[this.participants.length - 1]
+
+    for (const [index, participant] of this.participants.entries()) {
+      const bidAmount = this.startingPrice.add(this.minimalBidStep.mul(new BN(index)))
+      this.debug('Bid-' + index)
+      await this.api.bidInNftAuction(participant.account, participant.memberId.toNumber(), this.videoId, bidAmount)
+    }
+  }
+}

tests/network-tests/src/fixtures/content/nft/utils.ts

@@ -0,0 +1,15 @@
+import { IMember } from '../createMembers'
+import { QueryNodeApi } from '../../../QueryNodeApi'
+import { Utils } from '../../../utils'
+import { assert } from 'chai'
+
+export async function assertNftOwner(query: QueryNodeApi, videoId: number, winner: IMember) {
+  await query.tryQueryWithTimeout(
+    () => query.ownedNftByVideoId(videoId.toString()),
+    (ownedNft) => {
+      Utils.assert(ownedNft, 'NFT not found')
+      Utils.assert(ownedNft.ownerMember, 'Invalid NFT owner')
+      assert.equal(ownedNft.ownerMember.id.toString(), winner.memberId.toString())
+    }
+  )
+}

tests/network-tests/src/flows/content/activeVideoCounters.ts

@@ -5,6 +5,7 @@ import {
   ActiveVideoCountersFixture,
   CreateChannelsAndVideosFixture,
   CreateContentStructureFixture,
+  CreateMembersFixture,
 } from '../../fixtures/content'
 import { PaidTermId } from '@joystream/types/members'
 import BN from 'bn.js'
@@ -23,11 +24,13 @@ export default async function activeVideoCounters({ api, query, env }: FlowProps
   const videoCategoryCount = 2
   const channelCount = 2
   const channelCategoryCount = 2
+  const sufficientTopupAmount = new BN(1000000) // some very big number to cover fees of all transactions
 
   const paidTerms: PaidTermId = api.createPaidTermId(new BN(+env.MEMBERSHIP_PAID_TERMS!))
 
   // flow itself
 
+  // create channel categories and video categories
   const createContentStructureFixture = new CreateContentStructureFixture(
     api,
     query,
@@ -39,20 +42,27 @@ export default async function activeVideoCounters({ api, query, env }: FlowProps
 
   const { channelCategoryIds, videoCategoryIds } = createContentStructureFixture.getCreatedItems()
 
+  // create author of channels and videos
+  const createMembersFixture = new CreateMembersFixture(api, query, paidTerms, 1, sufficientTopupAmount)
+  await new FixtureRunner(createMembersFixture).run()
+  const author = createMembersFixture.getCreatedItems()[0]
+
+  // create channels and videos
   const createChannelsAndVideos = new CreateChannelsAndVideosFixture(
     api,
     query,
     joystreamCli,
     paidTerms,
-    videoCount,
     channelCount,
+    videoCount,
     channelCategoryIds[0],
-    videoCategoryIds[0]
+    videoCategoryIds[0],
+    author
   )
   await new FixtureRunner(createChannelsAndVideos).run()
-
   const { channelIds, videosData } = createChannelsAndVideos.getCreatedItems()
 
+  // check that active video counters are working
   const activeVideoCountersFixture = new ActiveVideoCountersFixture(
     api,
     query,

tests/network-tests/src/flows/content/nftAuctionAndOffers.ts

@@ -5,9 +5,13 @@ import {
   ActiveVideoCountersFixture,
   CreateChannelsAndVideosFixture,
   CreateContentStructureFixture,
-  NftAuctionFixture,
+  CreateMembersFixture,
+  NftEnglishAuctionFixture,
   NftBuyNowFixture,
   NftDirectOfferFixture,
+  NftOpenAuctionFixture,
+  AuctionCancelationsFixture,
+  IMember,
 } from '../../fixtures/content'
 import { PaidTermId } from '@joystream/types/members'
 import BN from 'bn.js'
@@ -22,14 +26,16 @@ export default async function nftAuctionAndOffers({ api, query, env }: FlowProps
   const joystreamCli = await createJoystreamCli()
 
   // settings
-  const videoCount = 2
+  const videoCount = 5 // should be equal to number of uses of `nextVideo()` below
   const videoCategoryCount = 1
   const channelCount = 1
   const channelCategoryCount = 1
+  const auctionParticipantsCount = 3
+  const sufficientTopupAmount = new BN(1000000) // some very big number to cover fees of all transactions
 
   const paidTerms: PaidTermId = api.createPaidTermId(new BN(+env.MEMBERSHIP_PAID_TERMS!))
 
-  // flow itself
+  // prepare content
 
   const createContentStructureFixture = new CreateContentStructureFixture(
     api,
@@ -42,33 +48,89 @@ export default async function nftAuctionAndOffers({ api, query, env }: FlowProps
 
   const { channelCategoryIds, videoCategoryIds } = createContentStructureFixture.getCreatedItems()
 
+  // create author of channels and videos as well as auction participants
+  const createMembersFixture = new CreateMembersFixture(
+    api,
+    query,
+    paidTerms,
+    auctionParticipantsCount + 1,
+    sufficientTopupAmount
+  )
+  await new FixtureRunner(createMembersFixture).run()
+  const [author, ...auctionParticipants] = createMembersFixture.getCreatedItems()
+
   const createChannelsAndVideos = new CreateChannelsAndVideosFixture(
     api,
     query,
     joystreamCli,
     paidTerms,
-    videoCount,
     channelCount,
+    videoCount,
     channelCategoryIds[0],
-    videoCategoryIds[0]
+    videoCategoryIds[0],
+    author
   )
   await new FixtureRunner(createChannelsAndVideos).run()
 
   const { channelIds, videosData } = createChannelsAndVideos.getCreatedItems()
 
-  // TODO: NFT stuff
+  const nextVideo = (() => {
+    let i = 0
+    return () => videosData[i++]
+  })()
+
+  // test NFT features
 
-  const nftAuctionFixture = new NftAuctionFixture(api, query, joystreamCli)
+  const nftAuctionFixture = new NftEnglishAuctionFixture(
+    api,
+    query,
+    joystreamCli,
+    paidTerms,
+    nextVideo().videoId,
+    author as IMember,
+    auctionParticipants
+  )
 
   await new FixtureRunner(nftAuctionFixture).run()
 
-  const nftBuyNowFixture = new NftBuyNowFixture(api, query, joystreamCli)
+  const openAuctionFixture = new NftOpenAuctionFixture(
+    api,
+    query,
+    joystreamCli,
+    paidTerms,
+    nextVideo().videoId,
+    author,
+    auctionParticipants
+  )
 
-  await new FixtureRunner(nftBuyNowFixture).run()
+  await new FixtureRunner(openAuctionFixture).run()
 
-  const nftDirectOfferFixture = new NftDirectOfferFixture(api, query, joystreamCli)
+  /* TODO: fix this - QN doesn't catch the events for buy-know from unkown reason
+  const nftBuyNowFixture = new NftBuyNowFixture(api, query, joystreamCli, nextVideo().videoId, author as IMember, auctionParticipants[0])
+
+  await new FixtureRunner(nftBuyNowFixture).run()
+*/
+  const nftDirectOfferFixture = new NftDirectOfferFixture(
+    api,
+    query,
+    joystreamCli,
+    nextVideo().videoId,
+    author as IMember,
+    auctionParticipants[0]
+  )
 
   await new FixtureRunner(nftDirectOfferFixture).run()
 
+  const auctionCancelations = new AuctionCancelationsFixture(
+    api,
+    query,
+    joystreamCli,
+    nextVideo().videoId,
+    author as IMember,
+    auctionParticipants[0]
+  )
+
+  await new FixtureRunner(auctionCancelations).run()
+
   debug('Done')
 }

tests/network-tests/src/graphql/generated/queries.ts

@@ -72,6 +72,20 @@ export type GetChannelByIdQueryVariables = Types.Exact<{
 
 export type GetChannelByIdQuery = { channelByUniqueInput?: Types.Maybe<ChannelFieldsFragment> }
 
+export type OwnedNftFieldsFragment = {
+  id: string
+  metadata: string
+  creatorRoyalty: number
+  video: { id: string }
+  ownerMember?: Types.Maybe<{ id: string }>
+}
+
+export type GetOwnedNftByVideoIdQueryVariables = Types.Exact<{
+  videoId: Types.Scalars['ID']
+}>
+
+export type GetOwnedNftByVideoIdQuery = { ownedNfts: Array<OwnedNftFieldsFragment> }
+
 export const DataObjectTypeFields = gql`
   fragment DataObjectTypeFields on DataObjectType {
     __typename
@@ -140,6 +154,19 @@ export const ChannelFields = gql`
   }
   ${StorageDataObjectFields}
 `
+export const OwnedNftFields = gql`
+  fragment OwnedNftFields on OwnedNft {
+    id
+    video {
+      id
+    }
+    ownerMember {
+      id
+    }
+    metadata
+    creatorRoyalty
+  }
+`
 export const GetDataObjectsByIds = gql`
   query getDataObjectsByIds($ids: [ID!]) {
     storageDataObjects(where: { id_in: $ids }) {
@@ -156,3 +183,11 @@ export const GetChannelById = gql`
   }
   ${ChannelFields}
 `
+export const GetOwnedNftByVideoId = gql`
+  query getOwnedNftByVideoId($videoId: ID!) {
+    ownedNfts(where: { video: { id_eq: $videoId } }) {
+      ...OwnedNftFields
+    }
+  }
+  ${OwnedNftFields}
+`

tests/network-tests/src/graphql/queries/storagev2.graphql

@@ -72,3 +72,22 @@ query getChannelById($id: ID!) {
     ...ChannelFields
   }
 }
+
+fragment OwnedNftFields on OwnedNft {
+  id
+  video {
+    id
+  }
+  ownerMember {
+    id
+  }
+  metadata
+  # transactionalStatus TODO
+  creatorRoyalty
+}
+
+query getOwnedNftByVideoId($videoId: ID!) {
+  ownedNfts(where: { video: { id_eq: $videoId } }) {
+    ...OwnedNftFields
+  }
+}

tests/network-tests/src/scenarios/content-directory.ts

@@ -14,6 +14,7 @@ scenario('Content directory', async ({ job }) => {
 
   const initStorageJob = job('initialize storage system', initStorage(storageConfig)).requires(leadSetupJob)
 
-  job('check active video counters', activeVideoCounters).requires(initStorageJob)
+  // const videoCountersJob = job('check active video counters', activeVideoCounters).requires(initStorageJob)
+  // job('nft auction and offers', nftAuctionAndOffers).after(videoCountersJob)
   job('nft auction and offers', nftAuctionAndOffers).requires(initStorageJob)
 })

types/augment/all/defs.json

@@ -902,6 +902,7 @@
         "transactional_status": "TransactionalStatus",
         "creator_royalty": "Option<Royalty>"
     },
+    "NFTMetadata": "Vec<u8>",
     "IsExtended": "bool",
     "AccountInfo": "AccountInfoWithRefCount"
 }

types/augment/all/types.ts

@@ -627,6 +627,9 @@ export interface NextAdjustment extends Struct {
   readonly at_block: u32;
 }
 
+/** @name NFTMetadata */
+export interface NFTMetadata extends Bytes {}
+
 /** @name NFTOwner */
 export interface NFTOwner extends Enum {
   readonly isChannelOwner: boolean;

types/src/content/index.ts

@@ -1,5 +1,5 @@
 import { Vec, Option, Tuple, BTreeSet } from '@polkadot/types'
-import { bool, u64, u32, u128, Null, Bytes } from '@polkadot/types/primitive'
+import { bool, u8, u64, u32, u128, Null, Bytes } from '@polkadot/types/primitive'
 import { MemberId } from '../members'
 import { JoyStructDecorated, JoyEnum, ChannelId } from '../common'
 
@@ -185,6 +185,8 @@ export class ChannelMigrationConfig extends JoyStructDecorated({
 
 export class IsExtended extends bool {}
 
+export class NFTMetadata extends Vec.with(u8) {}
+
 export class EnglishAuctionDetails extends JoyStructDecorated({
   extension_period: u32, // BlockNumber
   auction_duration: u32, // BlockNumber
@@ -302,6 +304,7 @@ export const contentTypes = {
   TransactionalStatus,
   NFTOwner,
   OwnedNFT,
+  NFTMetadata,
   IsExtended,
 }