@infy-protocol/sdk/src/timeBasedNFTRentals.ts

Lend and rent any ERC721s and ERC1155s on supported mainnet and testnet.

import { Signer, BigNumber, ContractTransaction, Contract } from 'ethers';

import { ITimeBasedNFTRentals, NFTStandard } from './types';
import { TimeBasedNFTRentalsAbi } from './abi/TimeBasedNFTRentalsAbi';
import { prepareBatch } from './utils';
import {
  ContractType,
  NetworkConfig,
  SupportedChainIds,
} from './networkConfig';

class TimeBasedNFTRentals implements ITimeBasedNFTRentals {
  readonly signer: Signer;
  protected contract: Contract;

  constructor(_signer: Signer, chainId: SupportedChainIds, type: ContractType) {
    this.signer = _signer;
    var _address = undefined;
    if (
      NetworkConfig[chainId] === undefined ||
      NetworkConfig[chainId].collateralizedContractAddresses === undefined ||
      NetworkConfig[chainId].collateralizedContractAddresses.length <= 0 ||
      NetworkConfig[chainId].collateralFreeContractAddresses === undefined ||
      NetworkConfig[chainId].collateralFreeContractAddresses.length <= 0
    ) {
      throw new Error('Requested for unsupported chain');
    } else {
      if (type === ContractType.COLLATERALIZED) {
        _address = NetworkConfig[chainId].collateralizedContractAddresses[0];
      } else {
        _address = NetworkConfig[chainId].collateralFreeContractAddresses[0];
      }
      this.contract = new Contract(
        _address,
        TimeBasedNFTRentalsAbi,
        this.signer
      );
    }
  }

  async lend(
    nftStandards: NFTStandard[],
    nftAddresses: string[],
    tokenIds: BigNumber[],
    lendAmounts: BigNumber[],
    maxRentDurations: number[],
    minRentDurations: number[],
    dailyRentPrices: BigNumber[],
    paymentOptions: number[],
    collateralPrices: BigNumber[],
    allowedRenters: string[][][]
  ): Promise<ContractTransaction> {
    const args = prepareBatch({
      nftStandards: nftStandards.map(nft => Number(nft)),
      nftAddresses: nftAddresses.map(nft => String(nft).toLowerCase()),
      tokenIds: tokenIds.map(id => BigNumber.from(id)),
      lendAmounts: lendAmounts.map(amt => BigNumber.from(amt)),
      maxRentDurations: maxRentDurations.map(value => Number(value)),
      minRentDurations: minRentDurations.map(value => Number(value)),
      dailyRentPrices: dailyRentPrices.map(value => BigNumber.from(value)),
      paymentOptions,
      collateralPrices: collateralPrices.map(value =>
        BigNumber.from(BigNumber.from(value))
      ),
      allowedRenters: allowedRenters,
    });

    return await this.contract.lend(
      args.nftStandards,
      args.nftAddresses,
      args.tokenIds,
      args.lendAmounts,
      args.maxRentDurations,
      args.minRentDurations,
      args.dailyRentPrices,
      args.paymentOptions,
      args.collateralPrices,
      args.allowedRenters
    );
  }

  async rent(
    nftStandards: NFTStandard[],
    nftAddresses: string[],
    tokenIds: BigNumber[],
    lendingIds: BigNumber[],
    rentDurations: number[],
    rentAmounts: BigNumber[]
  ): Promise<ContractTransaction> {
    const args = prepareBatch({
      nftStandards: nftStandards.map(nft => Number(nft)),
      nftAddresses: nftAddresses.map(nft => String(nft).toLowerCase()),
      tokenIds: tokenIds.map(id => BigNumber.from(id)),
      lendingIds: lendingIds.map(id => BigNumber.from(id)),
      rentDurations: rentDurations.map(value => Number(value)),
      rentAmounts: rentAmounts.map(amount => BigNumber.from(amount)),
    });

    return await this.contract.rent(
      args.nftStandards,
      args.nftAddresses,
      args.tokenIds,
      args.lendingIds,
      args.rentDurations,
      args.rentAmounts
    );
  }

  async stopRenting(
    nftStandards: NFTStandard[],
    nftAddresses: string[],
    tokenIds: BigNumber[],
    lendingIds: BigNumber[],
    rentingIds: BigNumber[]
  ): Promise<ContractTransaction> {
    const args = prepareBatch({
      nftStandards: nftStandards.map(nft => Number(nft)),
      nftAddresses: nftAddresses.map(nft => String(nft).toLowerCase()),
      tokenIds: tokenIds.map(id => BigNumber.from(id)),
      lendingIds: lendingIds.map(id => BigNumber.from(id)),
      rentingIds: rentingIds.map(id => BigNumber.from(id)),
    });

    return await this.contract.stopRenting(
      args.nftStandards,
      args.nftAddresses,
      args.tokenIds,
      args.lendingIds,
      args.rentingIds
    );
  }

  async stopLending(
    nftStandards: NFTStandard[],
    nftAddresses: string[],
    tokenIds: BigNumber[],
    lendingIds: BigNumber[]
  ): Promise<ContractTransaction> {
    const args = prepareBatch({
      nftStandards: nftStandards.map(nft => Number(nft)),
      nftAddresses: nftAddresses.map(nft => String(nft).toLowerCase()),
      tokenIds: tokenIds.map(id => BigNumber.from(id)),
      lendingIds: lendingIds.map(id => BigNumber.from(id)),
    });

    return await this.contract.stopLending(
      args.nftStandards,
      args.nftAddresses,
      args.tokenIds,
      args.lendingIds
    );
  }

  async claimRentOrCollateral(
    nftStandards: NFTStandard[],
    nftAddresses: string[],
    tokenIds: BigNumber[],
    lendingIds: BigNumber[],
    rentingIds: BigNumber[]
  ): Promise<ContractTransaction> {
    const args = prepareBatch({
      nftStandards: nftStandards.map(nft => Number(nft)),
      nftAddresses: nftAddresses.map(nft => String(nft).toLowerCase()),
      tokenIds: tokenIds.map(id => BigNumber.from(id)),
      lendingIds: lendingIds.map(id => BigNumber.from(id)),
      rentingIds: rentingIds.map(id => BigNumber.from(id)),
    });

    return await this.contract.claimRentOrCollateral(
      args.nftStandards,
      args.nftAddresses,
      args.tokenIds,
      args.lendingIds,
      args.rentingIds
    );
  }
}
export class CollateralizedNFTRentals extends TimeBasedNFTRentals {
  constructor(_signer: Signer, _chainId: SupportedChainIds) {
    super(_signer, _chainId, ContractType.COLLATERALIZED);
  }
}
export class CollateralFreeNFTRentals extends TimeBasedNFTRentals {
  constructor(_signer: Signer, _chainId: SupportedChainIds) {
    super(_signer, _chainId, ContractType.COLLATERAL_FREE);
  }
}