Phase 3 - Rent Pallet

[Victor-Salomon]

Rent Pallet

This document specifies the design choices took for the Rent pallet implementation in the Indexer and SDK.
Feel free to comment on certain misunderstandings and new suggestions are warm welcomed.

Sections:

• Events: list of the incoming events from the chain. (10 events)
• Extrinsics: SDK extrinsics to implement on the SDK. (7 helpers)
• Constants: SDK constants to implement on the SDK. (4 getters)
• Storage: SDK storage to implement on the SDK. (6 getters)
• Indexer Schema: The RentEntity entity schema for Indexer and the links it creates on other existing entities.

Events

In order to make the returned events datas usefull, we provide both the native format and a friendly ready to use format design format :

• a string as an AccountId32 correspond to a classic user valid address.
• a string as u128 is a BN value as string natively used under the hood by the chain.
• a rounded data (ex: amoutRounded) is the "human" version of a data, (usually a BN) that can be directly used.

10 events are triggered by the chain in the module Rent.

/// Contract Created.

//Old : 
ContractCreated {
    nft_id: NFTId,
    renter: T::AccountId,
    duration: Duration<T::BlockNumber>,
    acceptance_type: AcceptanceType<AccountList<T::AccountId, T::AccountSizeLimit>>,
    revocation_type: RevocationType,
    rent_fee: RentFee<BalanceOf<T>>,
    renter_cancellation_fee: Option<CancellationFee<BalanceOf<T>>>,
    rentee_cancellation_fee: Option<CancellationFee<BalanceOf<T>>>,
}

// New :
ContractCreated {
			nft_id: NFTId,
			renter: T::AccountId,
			duration: Duration<T::BlockNumber>,
			acceptance_type: AcceptanceType<AccountList<T::AccountId, T::AccountSizeLimit>>,
			renter_can_cancel: bool,
			rent_fee: RentFee<BalanceOf<T>>,
			renter_cancellation_fee: Option<CancellationFee<BalanceOf<T>>>,
			rentee_cancellation_fee: Option<CancellationFee<BalanceOf<T>>>,
		},

/// Contract was accepted and has started.
ContractStarted { nft_id: NFTId, rentee: T::AccountId }

/// Contract was revoked by either renter or rentee.
ContractRevoked { nft_id: NFTId, revoked_by: T::AccountId }

/// An offer was made for manual acceptance rent contract.
ContractOfferCreated { nft_id: NFTId, rentee: T::AccountId }

/// An offer was retracted for manual acceptance rent contract.
ContractOfferRetracted { nft_id: NFTId, rentee: T::AccountId }

/// A contract subscription's terms were changed by renter.
// Old : 
ContractSubscriptionTermsChanged {
    nft_id: NFTId,
    duration: Duration<T::BlockNumber>,
    rent_fee: RentFee<BalanceOf<T>>,
}

// New : 
ContractSubscriptionTermsChanged {
			nft_id: NFTId,
			period: T::BlockNumber,
			max_duration: Option<T::BlockNumber>,
			rent_fee: BalanceOf<T>,
		},

/// A contract new subscription's terms were accpeted by rentee.
ContractSubscriptionTermsAccepted { nft_id: NFTId }

/// A contract has ended.
ContractEnded { nft_id: NFTId, revoked_by: Option<T::AccountId> }

/// A contract's subscription period has started.
ContractSubscriptionPeriodStarted { nft_id: NFTId }

/// A contract available for sale was expired before its acceptance.
ContractAvailableExpired { nft_id: NFTId }

/// Contract was canceled.
ContractCanceled { nft_id: NFTId },

SDK events

Additional events will be added to the EventType enum in src > events.ts in the SDK:

export enum EventType {
  ...
	 // Rent
  ContractCreated = "rent.ContractCreated",
  ContractStarted = "rent.ContractStarted",
  ContractRevoked = "rent.ContractRevoked",
// New :
  ContractCanceled = "rent.ContractCanceled",
  ContractOfferCreated = "rent.ContractOfferCreated",
  ContractOfferRetracted = "rent.ContractOfferRetracted",
  ContractSubscriptionTermsChanged = "rent.ContractSubscriptionTermsChanged",
  ContractSubscriptionTermsAccepted = "rent.ContractSubscriptionTermsAccepted",
  ContractEnded = "rent.ContractEnded",
  ContractSubscriptionPeriodStarted = "rent.ContractSubscriptionPeriodStarted",
  ContractAvailableExpired = "rent.ContractAvailableExpired",
}

static fromEvent(event: Event): BlockchainEvent {
    ...
    
    switch (name) {
      ...
      // Rent
      case EventType.ContractCreated:
        return new ContractCreatedEvent(event)
      case EventType.ContractStarted:
        return new ContractStartedEvent(event)
      case EventType.ContractRevoked:
        return new ContractRevokedEvent(event)
      case EventType.ContractOfferCreated:
        return new ContractOfferCreatedEvent(event)
      case EventType.ContractOfferRetracted:
        return new ContractOfferRetractedEvent(event)
      case EventType.ContractSubscriptionTermsChanged:
        return new ContractSubscriptionTermsChangedEvent(event)
      case EventType.ContractSubscriptionTermsAccepted:
        return new ContractSubscriptionTermsAcceptedEvent(event)
      case EventType.ContractEnded:
        return new ContractEndedEvent(event)
      case EventType.ContractSubscriptionPeriodStarted:
        return new ContractSubscriptionPeriodStartedEvent(event)
      case EventType.ContractAvailableExpired:
        return new ContractAvailableExpiredEvent(event)
    }

    ...
  }
}

/**
 * This class represents the on-chain ContractCreatedEvent event.
 */
export class ContractCreatedEvent extends BlockchainEvent {
  nftId: number
  renter: string
  durationType?: string
  blockDuration?: number | null
  blockSubscriptionRenewal?: number | null
  acceptanceType?: string
  acceptanceList?: string[]
  revocationType?: string
  rentFeeType?: string
  rentFee?: string | number
  rentFeeRounded?: number
  renterCancellationFeeType?: string | null
  renterCancellationFee?: string | number | null
  renterCancellationFeeRounded?: number | null
  renteeCancellationFeeType?: string | null
  renteeCancellationFee?: string | number | null
  renteeCancellationFeeRounded?: number | null

  /**
   * Construct the data object from the ContractCreatedEvent event
   * @param event The ContractCreatedEvent event
   */
  constructor(event: Event) {
    super(event, EventType.ContractCreated)
    const [
      nftId,
      renter,
      duration,
      acceptanceType,
      revocationType,
      rentFee,
      renterCancellationFee,
      renteeCancellationFee,
    ] = event.data

    const parsedDuration = JSON.parse(duration.toString())
    const isDurationFixed = parsedDuration.Fixed 
    const isDurationSubscription = parsedDuration.Subscription
    const parsedAcceptance = JSON.parse(acceptanceType.toString())
    const isAutoAcceptance = parsedAcceptance.AutoAcceptance 
    const isrevocationTypeNoRevocation = revocationType.toString() === RevocationAction.NoRevocation
    const isrevocationTypeOnSubscriptionChange = revocationType.toString() === RevocationAction.OnSubscriptionChange
    const parsedRentFee = JSON.parse(rentFee.toString())
    const isRentFeeToken = parsedRentFee.Token 
    const parsedRenterCancellationFee = renterCancellationFee && JSON.parse(renterCancellationFee.toString())
    const isRenterCancellationFeeFixed = parsedRenterCancellationFee.FixedTokens 
    const isRenterCancellationFeeFlexible = parsedRenterCancellationFee.FlexibleTokens
    const parsedRenteeCancellationFee = renteeCancellationFee && JSON.parse(renteeCancellationFee.toString())
    const isRenteeCancellationFeeFixed = parsedRenteeCancellationFee.FixedTokens 
    const isRenteeCancellationFeeFlexible = parsedRenteeCancellationFee.FlexibleTokens

    this.nftId = Number.parseInt(nftId.toString())
    this.renter = renter.toString()
    this.durationType = undefined
    this.blockDuration = undefined
    this.blockSubscriptionRenewal = undefined
    this.acceptanceType = undefined
    this.acceptanceList = undefined
    this.revocationType = undefined
    this.rentFeeType = undefined
    this.rentFee = undefined
    this.rentFeeRounded = undefined
    this.renterCancellationFeeType = undefined
    this.renterCancellationFee = undefined
    this.renterCancellationFeeRounded = undefined
    this.renteeCancellationFeeType = undefined
    this.renteeCancellationFee = undefined
    this.renteeCancellationFeeRounded = undefined

    if (isDurationFixed) {
      this.durationType = DurationAction.Fixed
      this.blockDuration = Number.parseInt(parsedDuration.Fixed.toString())
    } else if (isDurationSubscription) {
      this.durationType = DurationAction.Subscription
      this.blockDuration = Number.parseInt(parsedDuration.Subscription[0].toString())
      this.blockSubscriptionRenewal = Number.parseInt(parsedDuration.Subscription[1].toString()) 
    } else {
      this.durationType = DurationAction.Infinite
    }

    if (isAutoAcceptance) {
      this.acceptanceType = AcceptanceAction.AutoAcceptance
      this.acceptanceList = [] 
      parsedAcceptance.AutoAcceptance.map((account: string) => this.acceptanceList?.push(account.toString()))
    } else {
      this.acceptanceType = AcceptanceAction.ManualAcceptance
      this.acceptanceList = [] 
      parsedAcceptance.ManualAcceptance.map((account: string) => this.acceptanceList?.push(account.toString()))
    }

    if (isrevocationTypeNoRevocation) {
      this.revocationType = RevocationAction.NoRevocation
    } else if (isrevocationTypeOnSubscriptionChange) {
      this.revocationType = RevocationAction.OnSubscriptionChange
    } else {
      this.revocationType = RevocationAction.Anytime
    }

    if (isRentFeeToken) {
      this.rentFeeType = RentFeeAction.Tokens
      this.rentFee = bnToBn(isRentFeeToken).toString()
      this.rentFeeRounded = roundBalance(this.rentFee)
    } else {
      this.rentFeeType = RentFeeAction.NFT
      this.rentFee = Number.parseInt(parsedRentFee.NFT.toString())
      this.rentFeeRounded = this.rentFee
    }

    if (isRenterCancellationFeeFixed) {
      this.renterCancellationFeeType = CancellationFeeAction.FixedTokens
      this.renterCancellationFee = bnToBn(parsedRenterCancellationFee.FixedTokens).toString()
      this.renterCancellationFeeRounded = roundBalance(this.renterCancellationFee)
    } else if (isRenterCancellationFeeFlexible) {
      this.renterCancellationFeeType = CancellationFeeAction.FlexibleTokens
      this.renterCancellationFee = bnToBn(parsedRenterCancellationFee.FlexibleTokens).toString()
      this.renterCancellationFeeRounded = roundBalance(this.renterCancellationFee)
    } else {
      this.renterCancellationFeeType = CancellationFeeAction.NFT
      this.renterCancellationFee = Number.parseInt(parsedRenterCancellationFee.NFT.toString())
      this.renterCancellationFeeRounded = this.renterCancellationFee
    }

    if (isRenteeCancellationFeeFixed) {
      this.renteeCancellationFeeType = CancellationFeeAction.FixedTokens
      this.renteeCancellationFee = bnToBn(parsedRenteeCancellationFee.FixedTokens).toString()
      this.renteeCancellationFeeRounded = roundBalance(this.renteeCancellationFee)
    } else if (isRenteeCancellationFeeFlexible) {
      this.renteeCancellationFeeType = CancellationFeeAction.FlexibleTokens
      this.renteeCancellationFee = bnToBn(parsedRenteeCancellationFee.FlexibleTokens).toString()
      this.renteeCancellationFeeRounded = roundBalance(this.renteeCancellationFee)
    } else {
      this.renteeCancellationFeeType = CancellationFeeAction.NFT
      this.renteeCancellationFee = Number.parseInt(parsedRenteeCancellationFee.NFT.toString())
      this.renteeCancellationFeeRounded = this.renteeCancellationFee
    }
  }
}

/**
 * This class represents the on-chain ContractStartedEvent event.
 */
export class ContractStartedEvent extends BlockchainEvent {
  nftId: number
  rentee: string

  /**
   * Construct the data object from the ContractStartedEvent event
   * @param event The ContractStartedEvent event
   */
  constructor(event: Event) {
    super(event, EventType.ContractStarted)
    const [nftId, rentee] = event.data

    this.nftId = Number.parseInt(nftId.toString())
    this.rentee = rentee.toString()
  }
}

/**
 * This class represents the on-chain ContractRevokedEvent event.
 */
export class ContractRevokedEvent extends BlockchainEvent {
  nftId: number
  revokedBy: string

  /**
   * Construct the data object from the ContractRevokedEvent event
   * @param event The ContractRevokedEvent event
   */
  constructor(event: Event) {
    super(event, EventType.ContractRevoked)
    const [nftId, revokedBy] = event.data

    this.nftId = Number.parseInt(nftId.toString())
    this.revokedBy = revokedBy.toString()
  }
}

/**
 * This class represents the on-chain ContractOfferCreatedEvent event.
 */
export class ContractOfferCreatedEvent extends BlockchainEvent {
  nftId: number
  rentee: string

  /**
   * Construct the data object from the ContractOfferCreatedEvent event
   * @param event The ContractOfferCreatedEvent event
   */
  constructor(event: Event) {
    super(event, EventType.ContractOfferCreated)
    const [nftId, rentee] = event.data

    this.nftId = Number.parseInt(nftId.toString())
    this.rentee = rentee.toString()
  }
}

/**
 * This class represents the on-chain ContractOfferRetractedEvent event.
 */
export class ContractOfferRetractedEvent extends BlockchainEvent {
  nftId: number
  rentee: string

  /**
   * Construct the data object from the ContractOfferRetractedEvent event
   * @param event The ContractOfferRetractedEvent event
   */
  constructor(event: Event) {
    super(event, EventType.ContractOfferRetracted)
    const [nftId, rentee] = event.data

    this.nftId = Number.parseInt(nftId.toString())
    this.rentee = rentee.toString()
  }
}

/**
 * This class represents the on-chain ContractSubscriptionTermsChangedEvent event.
 */
export class ContractSubscriptionTermsChangedEvent extends BlockchainEvent {
  nftId: number
  durationType?: string
  blockDuration?: number | null
  blockSubscriptionRenewal?: number | null
  rentFeeType?: string
  rentFee?: string | number
  rentFeeRounded?: number

  /**
   * Construct the data object from the ContractSubscriptionTermsChangedEvent event
   * @param event The ContractSubscriptionTermsChangedEvent event
   */
  constructor(event: Event) {
    super(event, EventType.ContractSubscriptionTermsChanged)
    const [nftId, duration, rentFee] = event.data

    const parsedDuration = JSON.parse(duration.toString())
    const isDurationFixed = parsedDuration.Fixed
    const isDurationSubscription = parsedDuration.Subscription
    const parsedRentFee = JSON.parse(rentFee.toString())
    const isRentFeeToken = parsedRentFee.Token

    this.nftId = Number.parseInt(nftId.toString())
    this.durationType = undefined
    this.blockDuration = undefined
    this.blockSubscriptionRenewal = undefined
    this.rentFeeType = undefined
    this.rentFee = undefined
    this.rentFeeRounded = undefined

    if (isDurationFixed) {
      this.durationType = DurationAction.Fixed
      this.blockDuration = Number.parseInt(parsedDuration.Fixed.toString())
    } else if (isDurationSubscription) {
      this.durationType = DurationAction.Subscription
      this.blockDuration = Number.parseInt(parsedDuration.Subscription[0].toString())
      this.blockSubscriptionRenewal = Number.parseInt(parsedDuration.Subscription[1].toString())
    } else {
      this.durationType = DurationAction.Infinite
    }

    if (isRentFeeToken) {
      this.rentFeeType = RentFeeAction.Tokens
      this.rentFee = bnToBn(isRentFeeToken).toString()
      this.rentFeeRounded = roundBalance(this.rentFee)
    } else {
      this.rentFeeType = RentFeeAction.NFT
      this.rentFee = Number.parseInt(parsedRentFee.NFT.toString())
      this.rentFeeRounded = this.rentFee
    }
  }
}

/**
 * This class represents the on-chain ContractSubscriptionTermsAcceptedEvent event.
 */
export class ContractSubscriptionTermsAcceptedEvent extends BlockchainEvent {
  nftId: number

  /**
   * Construct the data object from the ContractSubscriptionTermsAcceptedEvent event
   * @param event The ContractSubscriptionTermsAcceptedEvent event
   */
  constructor(event: Event) {
    super(event, EventType.ContractSubscriptionTermsAccepted)
    const [nftId] = event.data

    this.nftId = Number.parseInt(nftId.toString())
  }
}

/**
 * This class represents the on-chain ContractEndedEvent event.
 */
export class ContractEndedEvent extends BlockchainEvent {
  nftId: number
  revokedBy: string

  /**
   * Construct the data object from the ContractEndedEvent event
   * @param event The ContractEndedEvent event
   */
  constructor(event: Event) {
    super(event, EventType.ContractEnded)
    const [nftId, revokedBy] = event.data

    this.nftId = Number.parseInt(nftId.toString())
    this.revokedBy = revokedBy.toString()
  }
}

/**
 * This class represents the on-chain ContractSubscriptionPeriodStartedEvent event.
 */
export class ContractSubscriptionPeriodStartedEvent extends BlockchainEvent {
  nftId: number

  /**
   * Construct the data object from the ContractSubscriptionPeriodStartedEvent event
   * @param event The ContractSubscriptionPeriodStartedEvent event
   */
  constructor(event: Event) {
    super(event, EventType.ContractSubscriptionPeriodStarted)
    const [nftId] = event.data

    this.nftId = Number.parseInt(nftId.toString())
  }
}

/**
 * This class represents the on-chain ContractAvailableExpiredEvent event.
 */
export class ContractAvailableExpiredEvent extends BlockchainEvent {
  nftId: number

  /**
   * Construct the data object from the ContractAvailableExpiredEvent event
   * @param event The ContractAvailableExpiredEvent event
   */
  constructor(event: Event) {
    super(event, EventType.ContractAvailableExpired)
    const [nftId] = event.data

    this.nftId = Number.parseInt(nftId.toString())
  }
}

Extrinsics

7 extrinsics will be implemented from the Rent pallet.

Each helperTx will be duplicated by another helper version with 2 additional parameters: the keyring that will be used to sign and submit the transaction, and a waitUntil callback parameter, to define at which point we want to get the results of the transaction execution.

/**
 * @name createContractTx
 * @summary    Creates an unsigned unsubmitted Create-Rent-Contract Transaction Hash for an NFT.
 * @param  nftId    The NFT Id of the contract. 
 * @param duration    The contract duration : Fixed, Subscription or Infinite
 * @param acceptanceType    The type of acceptance: automatic or manuall
 * @param revocationType    The type/periode of revocation: NoRevocation, OnSubscriptionChange, Anytime
 * @param rentFee    The fee to rent the contract: a token amount or an NFT
 * @param renterCancellationFee    The fee to cancel the contract (due by the renter): FixedTokens amount, FlexibleTokens amount or an NFT
 * @param renteeCancellationFee    The fee to cancel the contract (due by the rentee): FixedTokens amount, FlexibleTokens amount or an NFT
 * @returns    Unsigned unsubmitted Create-Rent-Contract Transaction Hash. The Hash is only valid for 5 minutes.
 */

// Old: 
createContractTx(
    nftId: number,
    duration: DurationType
    acceptanceType: AcceptanceType
    revocationType: RevocationType
    rentFee: RentFeeType
    renterCancellationFee: CancellationFeeType | null = null
    renteeCancellationFee: CancellationFeeType | null = null
)

// New :
createContractTx(
    nftId: number,
    duration: DurationType
    acceptanceType: AcceptanceType
    renterCanCancel:Boolean
    rentFee: RentFeeType
    renterCancellationFee: CancellationFeeType | null = null
    renteeCancellationFee: CancellationFeeType | null = null
)

/**
 * @name revokeContractTx
 * @summary    Creates an unsigned unsubmitted Revoke-Rent-Contract Transaction Hash for an NFT.
 * @param  nftId    The NFT Id of the contract to revoke. 
 * @returns    Unsigned unsubmitted Revoke-Rent-Contract Transaction Hash. The Hash is only valid for 5 minutes.
 */
revokeContractTx(nftId: number)

// New : 
/**
 * @name cancelContractTx
 * @summary    Creates an unsigned unsubmitted Cancel-Contract Transaction Hash for an NFT.
 * @param  nftId    The NFT Id with the contract to cancel. 
 * @returns    Unsigned unsubmitted Cancel-Contract Transaction Hash. The Hash is only valid for 5 minutes.
 */
cancelContractTx(nftId: number) => New Event to be create  

// New : 
/**
 * @name makeRentOfferTx
 * @summary    Creates an unsigned unsubmitted MakeRentOffer-Contract Transaction Hash for an NFT.
 * @param  nftId    The NFT Id with the contract to cancel. 
 * @returns    Unsigned unsubmitted MakeRentOffer-Contract Transaction Hash. The Hash is only valid for 5 minutes.
 */
cancelContractTx(nftId: number) => Event : ContractOfferCreated


/**
 * @name rentTx
 * @summary    Creates an unsigned unsubmitted Rent-Contract Transaction Hash for an NFT.
 * @param  nftId    The NFT Id with the contract to rent. 
 * @returns    Unsigned unsubmitted Rent-Contract Transaction Hash. The Hash is only valid for 5 minutes.
 */
rentTx(nftId: number)

/**
 * @name acceptRentOfferTx
 * @summary    Creates an unsigned unsubmitted Accept-Rent-Offer Transaction Hash for an NFT.
 * @param  nftId    The NFT Id of the contract. 
 * @param  rentee    The adresse of the rentee who made the offer. 
 * @returns    Unsigned unsubmitted Accept-Rent-Offer Transaction Hash. The Hash is only valid for 5 minutes.
 */
acceptRentOfferTx(
    nftId: number
    rentee: string
)

/**
 * @name retractRentOfferTx
 * @summary    Creates an unsigned unsubmitted Retract-Rent-Offer Transaction Hash for an NFT.
 * @param  nftId    The NFT Id of the contract to retract the offer. 
 * @returns    Unsigned unsubmitted Retract-Rent-Offer Transaction Hash. The Hash is only valid for 5 minutes.
 */
retractRentOfferTx(nftId: number)

// Old 
/**
 * @name changeSubscriptionTermsTx
 * @summary    Creates an unsigned unsubmitted Change-Contract-Subscription-Terms Transaction Hash for an NFT.
 * @param  nftId    The NFT Id of the contract to change the subscription terms. 
 * @param duration    The contract duration : Fixed, Subscription or Infinite
 * @param amount    The fee to rent the contract: a token amount
 * @returns    Unsigned unsubmitted Change-Contract-Subscription-Terms Transaction Hash. The Hash is only valid for 5 minutes.
 */
changeSubscriptionTermsTx(
    nftId: number
    duration: DurationType
    amount: number | BN
)

// New :

/**
 * @name changeSubscriptionTermsTx
 * @summary    Creates an unsigned unsubmitted Change-Contract-Subscription-Terms Transaction Hash for an NFT.
 * @param  nftId    The NFT Id of the contract to change the subscription terms. 
 * @param duration    The contract duration : Fixed, Subscription or Infinite
 * @param amount    The fee to rent the contract: a token amount
 * @returns    Unsigned unsubmitted Change-Contract-Subscription-Terms Transaction Hash. The Hash is only valid for 5 minutes.
 */
changeSubscriptionTermsTx(
   nft_id: NFTId,
   period: T::BlockNumber,
   max_duration: Option<T::BlockNumber>,
   rent_fee: BalanceOf<T>,
   changeable: bool,
)

/**
 * @name acceptSubscriptionTermsTx
 * @summary    Creates an unsigned unsubmitted Accept-Contract-Subscription-Terms Transaction Hash for an NFT.
 * @param  nftId    The NFT Id of the contract to accept the new subscription terms. 
 * @returns    Unsigned unsubmitted Accept-Contract-Subscription-Terms Transaction Hash. The Hash is only valid for 5 minutes.
 */
acceptSubscriptionTermsTx(nftId: number)

Constants

4 constants getters will be implemented from the rent pallet.

export enum txPallets {
  ...
  rent = "rent",
}

export enum chainConstants {
  ...
  // rent
  accountSizeLimit = "accountSizeLimit"
  actionsInBlockLimit = "actionsInBlockLimit"
  contractExpirationDuration = "contractExpirationDuration"
  simultaneousContractLimit = "simultaneousContractLimit"
}

/**
 * @name getAccountSizeLimit
 * @summary The maximum number of accounts that can be stored inside the account list of acceptance.
 * @returns Number.
 */
getAccountSizeLimit(): number => consts(txPallets.rent, chainConstants.accountSizeLimit)

/**
 * @name getActionsInBlockLimit
 * @summary Maximum number of related automatic rent actions in block.
 * @returns Number.
 */
getActionsInBlockLimit(): number => consts(txPallets.rent, chainConstants.actionsInBlockLimit)

/**
 * @name getContractExpirationDuration
 * @summary Maximum number of blocks during which a rent contract is available for renting.
 * @returns Number.
 */
getContractExpirationDuration(): number => consts(txPallets.rent, chainConstants.contractExpirationDuration)

/**
 * @name getSimultaneousContractLimit
 * @summary Maximum number of simultaneous rent contract.
 * @returns Number.
 */
getSimultaneousContractLimit(): number => consts(txPallets.rent, chainConstants.simultaneousContractLimit)

Storage

6 storage getters will be implemented for the rent pallet.

export enum txPallets {
  ...
  rent = "rent",
}

export enum chainQuery {
  ...
  // rent
  contracts = "contracts"
  numberOfCurrentContracts = "numberOfCurrentContracts"
  availableQueue = "availableQueue"
  fixedQueue = "fixedQueue"
  subscriptionQueue = "subscriptionQueue"
  offers = "offers"
}

type RentalContractDataType = {
   hasStarted: boolean
  startBlockId: number | null
  startBlockDate: Date | null
  renter: string
  rentee: string | null
  durationType: DurationAction
  blockDuration: number | null
  blockSubscriptionRenewal: number | null
  acceptanceType: AcceptanceAction
  acceptanceList: string[]
  revocationType: RevocationAction
  rentFeeType: RentFeeAction
  rentFee: BalanceType | number
  rentFeeRounded: number
  renterCancellationFeeType: CancellationFeeAction | null
  renterCancellationFee: BalanceType | number | null
  renterCancellationFeeRounded: number | null
  renteeCancellationFeeType: CancellationFeeAction | null
  renteeCancellationFee: BalanceType | number | null
  renteeCancellationFeeRounded: number | null
  termsAccepted: boolean
}

type AvailableRentalContractType = {
  nftId: number
  contractExpirationBlockId: number
  contractExpirationDate: Date 
}

type ActiveFixedContractType = {
  nftId: number
  contractEndingBlockId: number
  contractEndingDate: Date
}

type ActiveSubscribedContractType = {
  nftId: number
  contractRenewalOrEndBlockId: number
  contractRenewalOrEndDate: Date
}

/**
 * @name getRentalContractData
 * @summary       Provides the data related to a rent contract.
 * @param nftId   The ID of the contracted NFT.
 * @returns           A JSON object with the rental contract data.
 */
getRentalContractData(
    nftId: number,
): Promise<RentalContractDataType | null> => query(txPallets.rent, chainQuery.contracts, [nftId])

/**
 * @name getRentalContractNb
 * @summary       Provides the data related to available for rent contract deadlines.
 * @returns Number.
 */
getRentalContractNb(): Promise<number> => query(txPallets.rent, chainQuery.numberOfCurrentContracts)

/**
 * @name getAvailableRentalContracts
 * @summary       Provides the data related to fixed contract deadlines.
 * @returns Number.
 */
getAvailableRentalContracts(): Promise<AvailableRentalContractType[]> => query(txPallets.rent, chainQuery.availableQueue)

/**
 * @name getActiveFixedRentalContracts
 * @summary       Provides the data related to fixed contract deadlines.
 * @returns Number.
 */
getActiveFixedRentalContracts(): Promise<ActiveFixedContractType[]> => query(txPallets.rent, chainQuery.fixedQueue)

/**
 * @name getActiveSubscribedRentalContracts
 * @summary       Provides the data related to subscription contract deadlines.
 * @returns Number.
 */
getActiveSubscribedRentalContracts(): Promise<ActiveSubscribedContractType[]> => query(txPallets.rent, chainQuery.subscriptionQueue)

/**
 * @name getRentalOffers
 * @summary       Provides the data related to rent contracts offers.
 * @param nftId   The ID of the contracted NFT.
 * @returns Number.
 */
getRentalOffers(
    nftId: number,
): Promise<string[]> => query(txPallets.rent, chainQuery.offers, [nftId])

Schema

The Indexer schema for the new RentEntity is detailed here below.

type RentEntity @entity {
  id: ID!
  nftId: String!
  hasStarted: Boolean!
  hasEnded: Boolean!
  isExpired: Boolean!
  renter: String! @index
  rentee: String @index
  startBlockId: String
  durationType: String!
  blockDuration: Int
  blockSubscriptionRenewal: Int 
  nbSubscriptionRenewal: Int
  acceptanceType: String!
  acceptanceList: [String]
  revocationType: String!
  revokedBy: String
  rentFeeType: String!
  rentFee: String!
  rentFeeRounded: Float!
  rentOffers: [String]
  nbRentOffers: Int
  areTermsAccepted: Boolean
  nbTermsUpdate: Int
  renterCancellationFeeType: String
  renterCancellationFee: String
  renterCancellationFeeRounded: Float
  renteeCancellationFeeType: String
  renteeCancellationFee: String
  renterCancellationFeeRounded: Float
  timestampCreate: Date! @index
  timestampStart: Date @index
  timestampLastSubscriptionRenewal: Date
  timestampNextSubscriptionRenewal: Date
  timestampLastTermsUpdate: Date
  timestampLastOffer: Date
  timestampEnd: Date
  timestampRevoke: Date
  timestampExpire: Date
}

Linking upgrades

The integration of the rent pallet introduces new links to existing entities: the NftEntity.

type NftEntity @entity {
  ...
  isRented: Boolean!     👈 A new field to detailed if the NFT is rented. 
                                           Default value: false
                                           On ContractStarted event = true
                                           On ContractSubscriptionTermsChanged event = true
                                           On ContractSubscriptionPeriodStarted event = true
                                           On ContractRevoked event = false
                                           On ContractEnded event = false 
                                           On ContractSubscriptionTermsChanged event = false 

rentee: String     👈 A new field to detailed who rented the NFT. 
                                           Default value: null
                                           On ContractStarted event = "rentee address"
                                           On ContractSubscriptionTermsChanged event =  "rentee address"
                                           On ContractSubscriptionPeriodStarted event = "rentee address"
                                           On ContractRevoked event = null
                                           On ContractEnded event = null
                                           On ContractSubscriptionTermsChanged event = null
                   
rentContract: RentEntity     👈 A new field to detailed the NFT contract. 
                                           Default value: RentEntity
                                           On ContractCreated event = RentEntity
                                           On ContractAvailableExpired event = null
                                           On ContractRevoked event = null
                                           On ContractEnded event = null
}

New NFT operations

The rent pallet introduces 6 new NFT operations. The NftOperationEntity remains the same and the fulfilled fields for each new operation are listed below.

• createRent
  typeOfTransaction='createRentContract'

• renewContract // TBC ?? => ContractSubscriptionPeriodStarted

• startingRent
  typeOfTransaction='rentContractStarted, from, to, price (price, priceRounded if renteFeeType = RentFeeAction.Tokens)

• endingRent = ContractRevoked ?? or ContractEnded?? or ContractAvailableExpired ??
  typeOfTransaction='unrent', from, to

• addRentalOffer => TBC ??
  typeOfTransaction='addRentalOffer', from(price, priceRounded if renteFeeType = RentFeeAction.Tokens)

• removeRentalOffer => TBC ??
  typeOfTransaction='removeRentalOffer', from (price, priceRounded if renteFeeType = RentFeeAction.Tokens)

[Victor-Salomon]

Rent Pallet v2.0.0

Second version of the Rent Pallet :

Global changes :

• No more : revocation_type

• No more : Inifite Duration Contract

• New : renter_can_revoke: bool.

• New : Duration type {
  Fixed(BlockNumber),
  Subscription(BlockNumber, Option, bool),
  } where last 3rd param : Can_Update or can_be_changed

• New : contract_canceled event

• Update : contractCreated event

• Update : ContractSubscriptionTermsChanged event

• New : cancelContract extrinsic

• New : makeRentOffer extrinsic

• Update : contractCreated extrinsic

• Update : ContractSubscriptionTermsChanged

Events

2 Updated :

/// Contract Created.
ContractCreated {
			nft_id: NFTId,
			renter: T::AccountId,
			duration: Duration<T::BlockNumber>,
			acceptance_type: AcceptanceType<AccountList<T::AccountId, T::AccountSizeLimit>>,
			renter_can_revoke: bool,
			rent_fee: RentFee<BalanceOf<T>>,
			renter_cancellation_fee: Option<CancellationFee<BalanceOf<T>>>,
			rentee_cancellation_fee: Option<CancellationFee<BalanceOf<T>>>,
},

/// A contract subscription's terms were changed by renter.
ContractSubscriptionTermsChanged {
			nft_id: NFTId,
			period: T::BlockNumber,
			max_duration: Option<T::BlockNumber>,
			rent_fee: BalanceOf<T>,
		},

1 Added

/// Contract was canceled.
ContractCanceled { nft_id: NFTId },

Impact on SDK events

Additional events will be added to the EventType enum in src > events.ts in the SDK:

export enum EventType {
  ...
	// Rent
	// Updated :
  ContractCreated = "rent.ContractCreated",
  ContractSubscriptionTermsChanged = "rent.ContractSubscriptionTermsChanged",
	// New : 
	ContractCanceled = "rent.ContractCanceled",
}

static fromEvent(event: Event): BlockchainEvent {
    ...
    
    switch (name) {
      ...
      // Rent
	  	 // Updated :
      case EventType.ContractCreated:
        return new ContractCreatedEvent(event)
      case EventType.ContractSubscriptionTermsChanged:
        return new ContractSubscriptionTermsChangedEvent(event)
			//New : 
			case EventType.ContractCanceled:
				return new ContractCanceledEvent(event)
    }

    ...
  }
}

/**
 * This class represents the on-chain ContractCreatedEvent event.
 */
export class ContractCreatedEvent extends BlockchainEvent {
  nftId: number
  renter: string
  durationType?: string
  blockDuration?: number | null
  blockSubscriptionRenewal?: number | null
  acceptanceType?: string
  acceptanceList?: string[]
  renterCanRevoke?: boolean
  rentFeeType?: string
  rentFee?: string | number
  rentFeeRounded?: number
  renterCancellationFeeType?: string | null
  renterCancellationFee?: string | number | null
  renterCancellationFeeRounded?: number | null
  renteeCancellationFeeType?: string | null
  renteeCancellationFee?: string | number | null
  renteeCancellationFeeRounded?: number | null

  /**
   * Construct the data object from the ContractCreatedEvent event
   * @param event The ContractCreatedEvent event
   */
  constructor(event: Event) {
    super(event, EventType.ContractCreated)
    const [
      nftId,
      renter,
      duration,
      acceptanceType,
      renterCanRevoke,
      rentFee,
      renterCancellationFee,
      renteeCancellationFee,
    ] = event.data

    const parsedDuration = JSON.parse(duration.toString())
    const isDurationFixed = parsedDuration.Fixed 
    const isDurationSubscription = parsedDuration.Subscription
    const parsedAcceptance = JSON.parse(acceptanceType.toString())
    const isAutoAcceptance = parsedAcceptance.AutoAcceptance 
//    const isrevocationTypeNoRevocation = revocationType.toString() === RevocationAction.NoRevocation
//    const isrevocationTypeOnSubscriptionChange = revocationType.toString() === RevocationAction.OnSubscriptionChange
    const parsedRentFee = JSON.parse(rentFee.toString())
    const isRentFeeToken = parsedRentFee.Token 
    const parsedRenterCancellationFee = renterCancellationFee && JSON.parse(renterCancellationFee.toString())
    const isRenterCancellationFeeFixed = parsedRenterCancellationFee.FixedTokens 
    const isRenterCancellationFeeFlexible = parsedRenterCancellationFee.FlexibleTokens
    const parsedRenteeCancellationFee = renteeCancellationFee && JSON.parse(renteeCancellationFee.toString())
    const isRenteeCancellationFeeFixed = parsedRenteeCancellationFee.FixedTokens 
    const isRenteeCancellationFeeFlexible = parsedRenteeCancellationFee.FlexibleTokens

    this.nftId = Number.parseInt(nftId.toString())
    this.renter = renter.toString()
    this.durationType = undefined
    this.blockDuration = undefined
    this.blockSubscriptionRenewal = undefined
    this.acceptanceType = undefined
    this.acceptanceList = undefined
	  this.renterCanRevoke = renterCanRevoke
    //this.revocationType = undefined
    this.rentFeeType = undefined
    this.rentFee = undefined
    this.rentFeeRounded = undefined
    this.renterCancellationFeeType = undefined
    this.renterCancellationFee = undefined
    this.renterCancellationFeeRounded = undefined
    this.renteeCancellationFeeType = undefined
    this.renteeCancellationFee = undefined
    this.renteeCancellationFeeRounded = undefined

    if (isDurationFixed) {
      this.durationType = DurationAction.Fixed
      this.blockDuration = Number.parseInt(parsedDuration.Fixed.toString())
    } else if (isDurationSubscription) {
      this.durationType = DurationAction.Subscription
      this.blockDuration = Number.parseInt(parsedDuration.Subscription[0].toString())
      this.blockSubscriptionRenewal = Number.parseInt(parsedDuration.Subscription[1].toString()) 
    } else {
      this.durationType = DurationAction.Infinite
    }

    if (isAutoAcceptance) {
      this.acceptanceType = AcceptanceAction.AutoAcceptance
      this.acceptanceList = [] 
      parsedAcceptance.AutoAcceptance.map((account: string) => this.acceptanceList?.push(account.toString()))
    } else {
      this.acceptanceType = AcceptanceAction.ManualAcceptance
      this.acceptanceList = [] 
      parsedAcceptance.ManualAcceptance.map((account: string) => this.acceptanceList?.push(account.toString()))
    }

//    if (isrevocationTypeNoRevocation) {
//     this.revocationType = RevocationAction.NoRevocation
//    } else if (isrevocationTypeOnSubscriptionChange) {
//      this.revocationType = RevocationAction.OnSubscriptionChange
//    } else {
//     this.revocationType = RevocationAction.Anytime
//    }

    if (isRentFeeToken) {
      this.rentFeeType = RentFeeAction.Tokens
      this.rentFee = bnToBn(isRentFeeToken).toString()
      this.rentFeeRounded = roundBalance(this.rentFee)
    } else {
      this.rentFeeType = RentFeeAction.NFT
      this.rentFee = Number.parseInt(parsedRentFee.NFT.toString())
      this.rentFeeRounded = this.rentFee
    }

    if (isRenterCancellationFeeFixed) {
      this.renterCancellationFeeType = CancellationFeeAction.FixedTokens
      this.renterCancellationFee = bnToBn(parsedRenterCancellationFee.FixedTokens).toString()
      this.renterCancellationFeeRounded = roundBalance(this.renterCancellationFee)
    } else if (isRenterCancellationFeeFlexible) {
      this.renterCancellationFeeType = CancellationFeeAction.FlexibleTokens
      this.renterCancellationFee = bnToBn(parsedRenterCancellationFee.FlexibleTokens).toString()
      this.renterCancellationFeeRounded = roundBalance(this.renterCancellationFee)
    } else {
      this.renterCancellationFeeType = CancellationFeeAction.NFT
      this.renterCancellationFee = Number.parseInt(parsedRenterCancellationFee.NFT.toString())
      this.renterCancellationFeeRounded = this.renterCancellationFee
    }

    if (isRenteeCancellationFeeFixed) {
      this.renteeCancellationFeeType = CancellationFeeAction.FixedTokens
      this.renteeCancellationFee = bnToBn(parsedRenteeCancellationFee.FixedTokens).toString()
      this.renteeCancellationFeeRounded = roundBalance(this.renteeCancellationFee)
    } else if (isRenteeCancellationFeeFlexible) {
      this.renteeCancellationFeeType = CancellationFeeAction.FlexibleTokens
      this.renteeCancellationFee = bnToBn(parsedRenteeCancellationFee.FlexibleTokens).toString()
      this.renteeCancellationFeeRounded = roundBalance(this.renteeCancellationFee)
    } else {
      this.renteeCancellationFeeType = CancellationFeeAction.NFT
      this.renteeCancellationFee = Number.parseInt(parsedRenteeCancellationFee.NFT.toString())
      this.renteeCancellationFeeRounded = this.renteeCancellationFee
    }
  }
}

/**
 * This class represents the on-chain ContractSubscriptionTermsChangedEvent event.
 */ 
export class ContractSubscriptionTermsChangedEvent extends BlockchainEvent {
  nftId: number
  durationType?: string
  blockDuration?: number | null
  blockSubscriptionRenewal?: number | null
  rentFeeType?: string
  rentFee?: string | number
  rentFeeRounded?: number

  /**
   * Construct the data object from the ContractSubscriptionTermsChangedEvent event
   * @param event The ContractSubscriptionTermsChangedEvent event
   */
  constructor(event: Event) {
    super(event, EventType.ContractSubscriptionTermsChanged)
    const [nftId, duration, rentFee] = event.data
	// Received from the chain. Need to log format
	// nft_id: number
  // period: T::BlockNumber,
	// max_duration: Option<T::BlockNumber>,
	// rent_fee: BalanceOf<T>,
	
	
    const parsedDuration = JSON.parse(duration.toString())
    const parsedRentFee = JSON.parse(rentFee.toString())
    this.nftId = Number.parseInt(nftId.toString())
    this.durationType = DurationAction.Subscription
    this.blockDuration = Number.parseInt(parsedDuration.subscription[0].toString())
    this.blockSubscriptionRenewal =
      parsedDuration.subscription[1] && Number.parseInt(parsedDuration.subscription[1].toString())
    this.rentFeeType = RentFeeAction.Tokens
    this.rentFee = bnToBn(parsedRentFee.tokens).toString()
    this.rentFeeRounded = roundBalance(this.rentFee)
  }
}

  

Added :

/**
 * This class represents the on-chain ContractCanceledEvent event.
 */
export class ContractCanceledEvent extends BlockchainEvent {
  nftId: number

  /**
   * Construct the data object from the ContractCanceledEvent event
   * @param event The ContractCanceledEvent event
   */
  constructor(event: Event) {
    super(event, EventType.ContractCanceled)
    const [nftId] = event.data

    this.nftId = Number.parseInt(nftId.toString())
  }
}

Extrinsics

3 Updated tx

/**
 * @name createContractTx
 * @summary    Creates an unsigned unsubmitted Create-Rent-Contract Transaction Hash for an NFT.
 * @param  nftId    The NFT Id of the contract. 
 * @param duration    The contract duration : Fixed, Subscription
 * @param acceptanceType    The type of acceptance: automatic or manuall
 * @param renterRevoke    Set to true if renter can revoke the running contract, and false if he can't.
 * @param rentFee    The fee to rent the contract: a token amount or an NFT
 * @param renterCancellationFee    The fee to cancel the contract (due by the renter): FixedTokens amount, FlexibleTokens amount or an NFT
 * @param renteeCancellationFee    The fee to cancel the contract (due by the rentee): FixedTokens amount, FlexibleTokens amount or an NFT
 * @returns    Unsigned unsubmitted Create-Rent-Contract Transaction Hash. The Hash is only valid for 5 minutes.
 */
createContractTx(
    nftId: number,
    duration: DurationType
    acceptanceType: AcceptanceType
    renterCanRevoke:boolean
    rentFee: RentFeeType
    renterCancellationFee: CancellationFeeType | null = null
    renteeCancellationFee: CancellationFeeType | null = null
)

/**
 * @name changeSubscriptionTermsTx
 * @summary    Creates an unsigned unsubmitted Change-Contract-Subscription-Terms Transaction Hash for an NFT.
 * @param  nftId    The NFT Id of the contract to change the subscription terms. 
 * @param period    tbc
 * @param maxDuration   tbc
 * @param rentFee   tbc
 * @param changeable   tbc
 * @returns    Unsigned unsubmitted Change-Contract-Subscription-Terms Transaction Hash. The Hash is only valid for 5 minutes.
 */
changeSubscriptionTermsTx(
   nft_id: number
   period: tbc
   maxDuration: tbc
   rentFee: tbc
   changeable: boolean
)

// Need to update rent tx description as offer are not anymore made from this extrinsic

2 Added tx

/**
 * @name cancelContractTx
 * @summary    Creates an unsigned unsubmitted Cancel-Contract Transaction Hash for an NFT.
 * @param  nftId    The NFT Id of the contract to cancel. 
 * @returns    Unsigned unsubmitted Cancel-Contract Transaction Hash. The Hash is only valid for 5 minutes.
 */
cancelContract(nftId: number) => Event : ContractCanceled

/**
 * @name makeRentOfferTx
 * @summary    Creates an unsigned unsubmitted MakeRentOffer-Contract Transaction Hash for an NFT.
 * @param  nftId    The NFT Id of the contract to make an offer on. 
 * @returns    Unsigned unsubmitted MakeRentOffer-Contract Transaction Hash. The Hash is only valid for 5 minutes.
 */
makeRentOffer(nftId: number) => Event : ContractOfferCreated

Constants

No changes

Storage

3 remaining storages

export enum chainQuery {
  ...
  // rent
  contracts = "contracts"
  offers = "offers"
  // add 
  queues = "queues"

  //Remove : 
  numberOfCurrentContracts = "numberOfCurrentContracts"
  availableQueue = "availableQueue"
  fixedQueue = "fixedQueue"
  subscriptionQueue = "subscriptionQueue"
}

type RentalContractDataType = {
  hasStarted: boolean
  startBlockId: number | null
  startBlockDate: Date | null
  renter: string
  rentee: string | null
  durationType: DurationAction
  blockDuration: number | null
  blockSubscriptionRenewal: number | null
  acceptanceType: AcceptanceAction
  acceptanceList: string[]
  renterCanRevoke: boolean // ??
  //revocationType: RevocationAction
  rentFeeType: RentFeeAction
  rentFee: BalanceType | number
  rentFeeRounded: number
  renterCancellationFeeType: CancellationFeeAction | null
  renterCancellationFee: BalanceType | number | null
  renterCancellationFeeRounded: number | null
  renteeCancellationFeeType: CancellationFeeAction | null
  renteeCancellationFee: BalanceType | number | null
  renteeCancellationFeeRounded: number | null
  termsAccepted: boolean
}

// Must be removed
type AvailableRentalContractType = {
  nftId: number
  contractExpirationBlockId: number
  contractExpirationDate: Date 
}
// Must be removed
type ActiveFixedContractType = {
  nftId: number
  contractEndingBlockId: number
  contractEndingDate: Date
}
// Must be removed
type ActiveSubscribedContractType = {
  nftId: number
  contractRenewalOrEndBlockId: number
  contractRenewalOrEndDate: Date
}

/**
 * @name getRentalContractData
 * @summary       Provides the data related to a rent contract.
 * @param nftId   The ID of the contracted NFT.
 * @returns           A JSON object with the rental contract data.
 */
getRentalContractData(
    nftId: number,
): Promise<RentalContractDataType | null> => query(txPallets.rent, chainQuery.contracts, [nftId])

/**
 * @name getRentalOffers
 * @summary       Provides the data related to rent contracts offers.
 * @param nftId   The ID of the contracted NFT.
 * @returns Number.
 */
getRentalOffers(
    nftId: number,
): Promise<string[]> => query(txPallets.rent, chainQuery.offers, [nftId])

/**
 * @name getQueues
 * @summary       Data related to contracts queues.
 * @returns Number.
 */
getQueues(): Promise<number> => query(txPallets.rent, chainQuery.queues)

// Must be removed
/**
 * @name getAvailableRentalContracts
 * @summary       Provides the data related to fixed contract deadlines.
 * @returns Number.
 */
getAvailableRentalContracts(): Promise<AvailableRentalContractType[]> => query(txPallets.rent, chainQuery.availableQueue)
// Must be removed
/**
 * @name getActiveFixedRentalContracts
 * @summary       Provides the data related to fixed contract deadlines.
 * @returns Number.
 */
getActiveFixedRentalContracts(): Promise<ActiveFixedContractType[]> => query(txPallets.rent, chainQuery.fixedQueue)
// Must be removed
/**
 * @name getActiveSubscribedRentalContracts
 * @summary       Provides the data related to subscription contract deadlines.
 * @returns Number.
 */
getActiveSubscribedRentalContracts(): Promise<ActiveSubscribedContractType[]> => query(txPallets.rent, chainQuery.subscriptionQueue)

Schema

The Indexer schema for the new RentEntity is detailed here below.

type RentEntity @entity {
  id: ID!
  nftId: String!
  hasStarted: Boolean!
  hasEnded: Boolean!
  isExpired: Boolean!
  renter: String! @index
  rentee: String @index
  startBlockId: String
  durationType: String!
  blockDuration: Int
  blockSubscriptionRenewal: Int 
  nbSubscriptionRenewal: Int
  acceptanceType: String!
  acceptanceList: [String]
  renterCanrevoke: Boolean
  #revocationType: String!
  revokedBy: String
  rentFeeType: String!
  rentFee: String!
  rentFeeRounded: Float!
  rentOffers: [String]
  nbRentOffers: Int
  areTermsAccepted: Boolean
  nbTermsUpdate: Int
  renterCancellationFeeType: String
  renterCancellationFee: String
  renterCancellationFeeRounded: Float
  renteeCancellationFeeType: String
  renteeCancellationFee: String
  renterCancellationFeeRounded: Float
  timestampCreate: Date! @index
  timestampStart: Date @index
  timestampLastSubscriptionRenewal: Date
  timestampNextSubscriptionRenewal: Date
  timestampLastTermsUpdate: Date
  timestampLastOffer: Date
  timestampEnd: Date
  timestampRevoke: Date
  timestampExpire: Date
}

New NFT operations

• cancelContract
  typeOfTransaction='cancelContract'