mirror of
https://github.com/oceanprotocol/ocean.js.git
synced 2024-11-26 20:39:05 +01:00
1073 lines
34 KiB
TypeScript
1073 lines
34 KiB
TypeScript
import { AbiItem } from 'web3-utils'
|
|
import { TransactionReceipt } from 'web3-eth'
|
|
import ERC721Template from '@oceanprotocol/contracts/artifacts/contracts/templates/ERC721Template.sol/ERC721Template.json'
|
|
import { LoggerInstance, generateDtName, estimateGas } from '../../utils'
|
|
import { Contract } from 'web3-eth-contract'
|
|
import { MetadataProof, MetadataAndTokenURI, NftRoles } from '../../@types'
|
|
import { SmartContract } from '..'
|
|
|
|
export class Nft extends SmartContract {
|
|
getDefaultAbi(): AbiItem | AbiItem[] {
|
|
return ERC721Template.abi as AbiItem[]
|
|
}
|
|
|
|
/**
|
|
* Estimate gas cost for createDatatoken token creation
|
|
* @param {String} nftAddress NFT address
|
|
* @param {String} address User address
|
|
* @param {String} minter User set as initial minter for the Datatoken
|
|
* @param {String} paymentCollector initial paymentCollector for this DT
|
|
* @param {String} mpFeeAddress Consume marketplace fee address
|
|
* @param {String} feeToken address of the token marketplace wants to add fee on top
|
|
* @param {String} feeAmount amount of feeToken to be transferred to mpFeeAddress on top, will be converted to WEI
|
|
* @param {String} cap Maximum cap (Number) - will be converted to wei
|
|
* @param {String} name Token name
|
|
* @param {String} symbol Token symbol
|
|
* @param {Number} templateIndex NFT template index
|
|
* @param {Contract} nftContract optional contract instance
|
|
* @return {Promise<any>}
|
|
*/
|
|
public async estGasGasCreateDatatoken(
|
|
nftAddress: string,
|
|
address: string,
|
|
minter: string,
|
|
paymentCollector: string,
|
|
mpFeeAddress: string,
|
|
feeToken: string,
|
|
feeAmount: string,
|
|
cap: string,
|
|
name?: string,
|
|
symbol?: string,
|
|
templateIndex?: number,
|
|
contractInstance?: Contract
|
|
): Promise<any> {
|
|
const nftContract = contractInstance || this.getContract(nftAddress)
|
|
return estimateGas(
|
|
address,
|
|
nftContract.methods.createERC20,
|
|
templateIndex,
|
|
[name, symbol],
|
|
[minter, paymentCollector, mpFeeAddress, feeToken],
|
|
[this.web3.utils.toWei(cap), this.web3.utils.toWei(feeAmount)],
|
|
[]
|
|
)
|
|
}
|
|
|
|
/**
|
|
* Create new ERC20 Datatoken - only user with DatatokenDeployer permission can succeed
|
|
* @param {String} nftAddress NFT address
|
|
* @param {String} address User address
|
|
* @param {String} minter User set as initial minter for the Datatoken
|
|
* @param {String} paymentCollector initial paymentCollector for this DT
|
|
* @param {String} mpFeeAddress Consume marketplace fee address
|
|
* @param {String} feeToken address of the token marketplace wants to add fee on top
|
|
* @param {String} feeAmount amount of feeToken to be transferred to mpFeeAddress on top, will be converted to WEI
|
|
* @param {String} cap Maximum cap (Number) - will be converted to wei
|
|
* @param {String} name Token name
|
|
* @param {String} symbol Token symbol
|
|
* @param {Number} templateIndex NFT template index
|
|
* @return {Promise<string>} ERC20 Datatoken address
|
|
*/
|
|
public async createDatatoken(
|
|
nftAddress: string,
|
|
address: string,
|
|
minter: string,
|
|
paymentCollector: string,
|
|
mpFeeAddress: string,
|
|
feeToken: string,
|
|
feeAmount: string,
|
|
cap: string,
|
|
name?: string,
|
|
symbol?: string,
|
|
templateIndex?: number
|
|
): Promise<string> {
|
|
if ((await this.getNftPermissions(nftAddress, address)).deployERC20 !== true) {
|
|
throw new Error(`Caller is not DatatokenDeployer`)
|
|
}
|
|
if (!templateIndex) templateIndex = 1
|
|
|
|
// Generate name & symbol if not present
|
|
if (!name || !symbol) {
|
|
;({ name, symbol } = generateDtName())
|
|
}
|
|
|
|
// Create 721contract object
|
|
const nftContract = this.getContract(nftAddress)
|
|
|
|
const estGas = await estimateGas(
|
|
address,
|
|
nftContract.methods.createERC20,
|
|
templateIndex,
|
|
[name, symbol],
|
|
[minter, paymentCollector, mpFeeAddress, feeToken],
|
|
[this.web3.utils.toWei(cap), this.web3.utils.toWei(feeAmount)],
|
|
[]
|
|
)
|
|
|
|
// Call createERC20 token function of the contract
|
|
const trxReceipt = await nftContract.methods
|
|
.createERC20(
|
|
templateIndex,
|
|
[name, symbol],
|
|
[minter, paymentCollector, mpFeeAddress, feeToken],
|
|
[this.web3.utils.toWei(cap), this.web3.utils.toWei(feeAmount)],
|
|
[]
|
|
)
|
|
.send({
|
|
from: address,
|
|
gas: estGas + 1,
|
|
gasPrice: await this.getFairGasPrice()
|
|
})
|
|
|
|
let tokenAddress = null
|
|
try {
|
|
tokenAddress = trxReceipt.events.TokenCreated.returnValues[0]
|
|
} catch (e) {
|
|
LoggerInstance.error(`ERROR: Failed to create datatoken : ${e.message}`)
|
|
}
|
|
return tokenAddress
|
|
}
|
|
|
|
/**
|
|
* Estimate gas cost for add manager call
|
|
* @param {String} nftAddress NFT contract address
|
|
* @param {String} address NFT Owner adress
|
|
* @param {String} manager User adress which is going to be assing manager
|
|
* @param {Contract} nftContract optional contract instance
|
|
* @return {Promise<any>}
|
|
*/
|
|
public async estGasGasAddManager(
|
|
nftAddress: string,
|
|
address: string,
|
|
manager: string,
|
|
contractInstance?: Contract
|
|
) {
|
|
const nftContract = contractInstance || this.getContract(nftAddress)
|
|
|
|
return estimateGas(address, nftContract.methods.addManager, manager)
|
|
}
|
|
|
|
/**
|
|
* Add Manager for NFT Contract (only NFT Owner can succeed)
|
|
* @param {String} nftAddress NFT contract address
|
|
* @param {String} address NFT Owner adress
|
|
* @param {String} manager User adress which is going to be assing manager
|
|
* @return {Promise<TransactionReceipt>} trxReceipt
|
|
*/
|
|
public async addManager(nftAddress: string, address: string, manager: string) {
|
|
const nftContract = this.getContract(nftAddress)
|
|
|
|
if ((await this.getNftOwner(nftAddress)) !== address) {
|
|
throw new Error(`Caller is not NFT Owner`)
|
|
}
|
|
|
|
const estGas = await estimateGas(address, nftContract.methods.addManager, manager)
|
|
|
|
// Invoke addManager function of the contract
|
|
const trxReceipt = await nftContract.methods.addManager(manager).send({
|
|
from: address,
|
|
gas: estGas + 1,
|
|
gasPrice: await this.getFairGasPrice()
|
|
})
|
|
|
|
return trxReceipt
|
|
}
|
|
|
|
/**
|
|
* Estimate gas cost for removeManager method
|
|
* @param {String} nftAddress NFT contract address
|
|
* @param {String} address NFT Owner adress
|
|
* @param {String} manager User adress which is going to be removed as manager
|
|
* @param {Contract} nftContract optional contract instance
|
|
* @return {Promise<any>}
|
|
*/
|
|
public async estGasGasRemoveManager(
|
|
nftAddress: string,
|
|
address: string,
|
|
manager: string,
|
|
contractInstance?: Contract
|
|
) {
|
|
const nftContract = contractInstance || this.getContract(nftAddress)
|
|
return estimateGas(address, nftContract.methods.removeManager, manager)
|
|
}
|
|
|
|
/**
|
|
* Removes a specific manager for NFT Contract (only NFT Owner can succeed)
|
|
* @param {String} nftAddress NFT contract address
|
|
* @param {String} address NFT Owner adress
|
|
* @param {String} manager User adress which is going to be removed as manager
|
|
* @return {Promise<TransactionReceipt>} trxReceipt
|
|
*/
|
|
public async removeManager(nftAddress: string, address: string, manager: string) {
|
|
const nftContract = this.getContract(nftAddress)
|
|
|
|
if ((await this.getNftOwner(nftAddress)) !== address) {
|
|
throw new Error(`Caller is not NFT Owner`)
|
|
}
|
|
|
|
const estGas = await estimateGas(address, nftContract.methods.removeManager, manager)
|
|
|
|
// Invoke removeManager function of the contract
|
|
const trxReceipt = await nftContract.methods.removeManager(manager).send({
|
|
from: address,
|
|
gas: estGas + 1,
|
|
gasPrice: await this.getFairGasPrice()
|
|
})
|
|
|
|
return trxReceipt
|
|
}
|
|
|
|
/**
|
|
* Estimate gas cost for addToCreateERC20List method
|
|
* @param {String} nftAddress NFT contract address
|
|
* @param {String} address NFT Manager adress
|
|
* @param {String} datatokenDeployer User adress which is going to have DatatokenDeployer permission
|
|
* @param {Contract} nftContract optional contract instance
|
|
* @return {Promise<any>}
|
|
*/
|
|
public async estGasGasAddDatatokenDeployer(
|
|
nftAddress: string,
|
|
address: string,
|
|
datatokenDeployer: string,
|
|
contractInstance?: Contract
|
|
): Promise<any> {
|
|
const nftContract = contractInstance || this.getContract(nftAddress)
|
|
return estimateGas(
|
|
address,
|
|
nftContract.methods.addToCreateERC20List,
|
|
datatokenDeployer
|
|
)
|
|
}
|
|
|
|
/**
|
|
* Add DatatokenDeployer permission - only Manager can succeed
|
|
* @param {String} nftAddress NFT contract address
|
|
* @param {String} address NFT Manager adress
|
|
* @param {String} datatokenDeployer User adress which is going to have DatatokenDeployer permission
|
|
* @return {Promise<TransactionReceipt>} trxReceipt
|
|
*/
|
|
public async addDatatokenDeployer(
|
|
nftAddress: string,
|
|
address: string,
|
|
datatokenDeployer: string
|
|
): Promise<TransactionReceipt> {
|
|
const nftContract = this.getContract(nftAddress)
|
|
|
|
if ((await this.getNftPermissions(nftAddress, address)).manager !== true) {
|
|
throw new Error(`Caller is not Manager`)
|
|
}
|
|
|
|
// Estimate gas for addToCreateERC20List method
|
|
const estGas = await estimateGas(
|
|
address,
|
|
nftContract.methods.addToCreateERC20List,
|
|
datatokenDeployer
|
|
)
|
|
|
|
// Invoke addToCreateERC20List function of the contract
|
|
const trxReceipt = await nftContract.methods
|
|
.addToCreateERC20List(datatokenDeployer)
|
|
.send({
|
|
from: address,
|
|
gas: estGas + 1,
|
|
gasPrice: await this.getFairGasPrice()
|
|
})
|
|
|
|
return trxReceipt
|
|
}
|
|
|
|
/**
|
|
* Estimate gas cost for removeFromCreateERC20List method
|
|
* @param {String} nftAddress NFT contract address
|
|
* @param {String} address NFT Manager adress
|
|
* @param {String} datatokenDeployer Address of the user to be revoked DatatokenDeployer Permission
|
|
* @param {Contract} nftContract optional contract instance
|
|
* @return {Promise<any>}
|
|
*/
|
|
public async estGasGasRemoveDatatokenDeployer(
|
|
nftAddress: string,
|
|
address: string,
|
|
datatokenDeployer: string,
|
|
contractInstance?: Contract
|
|
): Promise<any> {
|
|
const nftContract = contractInstance || this.getContract(nftAddress)
|
|
|
|
return estimateGas(
|
|
address,
|
|
nftContract.methods.removeFromCreateERC20List,
|
|
datatokenDeployer
|
|
)
|
|
}
|
|
|
|
/**
|
|
* Remove DatatokenDeployer permission - only Manager can succeed
|
|
* @param {String} nftAddress NFT contract address
|
|
* @param {String} address NFT Manager adress
|
|
* @param {String} datatokenDeployer Address of the user to be revoked DatatokenDeployer Permission
|
|
* @return {Promise<TransactionReceipt>} trxReceipt
|
|
*/
|
|
public async removeDatatokenDeployer(
|
|
nftAddress: string,
|
|
address: string,
|
|
datatokenDeployer: string
|
|
): Promise<TransactionReceipt> {
|
|
const nftContract = this.getContract(nftAddress)
|
|
|
|
if (
|
|
(await this.getNftPermissions(nftAddress, address)).manager !== true ||
|
|
(address === datatokenDeployer &&
|
|
(await this.getNftPermissions(nftAddress, address)).deployERC20 !== true)
|
|
) {
|
|
throw new Error(`Caller is not Manager nor DatatokenDeployer`)
|
|
}
|
|
const estGas = await estimateGas(
|
|
address,
|
|
nftContract.methods.removeFromCreateERC20List,
|
|
datatokenDeployer
|
|
)
|
|
|
|
// Call removeFromCreateERC20List function of the contract
|
|
const trxReceipt = await nftContract.methods
|
|
.removeFromCreateERC20List(datatokenDeployer)
|
|
.send({
|
|
from: address,
|
|
gas: estGas + 1,
|
|
gasPrice: await this.getFairGasPrice()
|
|
})
|
|
|
|
return trxReceipt
|
|
}
|
|
|
|
/**
|
|
* Estimate gas cost for addToMetadataList method
|
|
* @param {String} nftAddress NFT contract address
|
|
* @param {String} address NFT Manager adress
|
|
* @param {String} metadataUpdater User adress which is going to have Metadata Updater permission
|
|
* @param {Contract} nftContract optional contract instance
|
|
* @return {Promise<any>}
|
|
*/
|
|
public async estGasGasAddMetadataUpdater(
|
|
nftAddress: string,
|
|
address: string,
|
|
metadataUpdater: string,
|
|
contractInstance?: Contract
|
|
): Promise<any> {
|
|
const nftContract = contractInstance || this.getContract(nftAddress)
|
|
|
|
return estimateGas(address, nftContract.methods.addToMetadataList, metadataUpdater)
|
|
}
|
|
|
|
/**
|
|
* Add Metadata Updater permission - only Manager can succeed
|
|
* @param {String} nftAddress NFT contract address
|
|
* @param {String} address NFT Manager adress
|
|
* @param {String} metadataUpdater User adress which is going to have Metadata Updater permission
|
|
* @return {Promise<TransactionReceipt>} trxReceipt
|
|
*/
|
|
public async addMetadataUpdater(
|
|
nftAddress: string,
|
|
address: string,
|
|
metadataUpdater: string
|
|
): Promise<TransactionReceipt> {
|
|
const nftContract = this.getContract(nftAddress)
|
|
|
|
if ((await this.getNftPermissions(nftAddress, address)).manager !== true) {
|
|
throw new Error(`Caller is not Manager`)
|
|
}
|
|
|
|
const estGas = await estimateGas(
|
|
address,
|
|
nftContract.methods.addToMetadataList,
|
|
metadataUpdater
|
|
)
|
|
|
|
// Call addToMetadataList function of the contract
|
|
const trxReceipt = await nftContract.methods.addToMetadataList(metadataUpdater).send({
|
|
from: address,
|
|
gas: estGas + 1,
|
|
gasPrice: await this.getFairGasPrice()
|
|
})
|
|
|
|
return trxReceipt
|
|
}
|
|
|
|
/**
|
|
* Estimate gas cost for removeFromMetadataList method
|
|
* @param {String} nftAddress NFT contract address
|
|
* @param {String} address NFT Manager adress
|
|
* @param {String} metadataUpdater Address of the user to be revoked Metadata updater Permission
|
|
* @param {Contract} nftContract optional contract instance
|
|
* @return {Promise<any>}
|
|
*/
|
|
public async esGasRemoveMetadataUpdater(
|
|
nftAddress: string,
|
|
address: string,
|
|
metadataUpdater: string,
|
|
contractInstance?: Contract
|
|
): Promise<any> {
|
|
const nftContract = contractInstance || this.getContract(nftAddress)
|
|
|
|
return estimateGas(
|
|
address,
|
|
nftContract.methods.removeFromMetadataList,
|
|
metadataUpdater
|
|
)
|
|
}
|
|
|
|
/**
|
|
* Remove Metadata Updater permission - only Manager can succeed
|
|
* @param {String} nftAddress NFT contract address
|
|
* @param {String} address NFT Manager adress
|
|
* @param {String} metadataUpdater Address of the user to be revoked Metadata updater Permission
|
|
* @return {Promise<TransactionReceipt>} trxReceipt
|
|
*/
|
|
public async removeMetadataUpdater(
|
|
nftAddress: string,
|
|
address: string,
|
|
metadataUpdater: string
|
|
): Promise<TransactionReceipt> {
|
|
const nftContract = this.getContract(nftAddress)
|
|
|
|
if (
|
|
(await this.getNftPermissions(nftAddress, address)).manager !== true ||
|
|
(address !== metadataUpdater &&
|
|
(await this.getNftPermissions(nftAddress, address)).updateMetadata !== true)
|
|
) {
|
|
throw new Error(`Caller is not Manager nor Metadata Updater`)
|
|
}
|
|
|
|
const estGas = await this.esGasRemoveMetadataUpdater(
|
|
nftAddress,
|
|
address,
|
|
metadataUpdater,
|
|
nftContract
|
|
)
|
|
|
|
// Call removeFromMetadataList function of the contract
|
|
const trxReceipt = await nftContract.methods
|
|
.removeFromMetadataList(metadataUpdater)
|
|
.send({
|
|
from: address,
|
|
gas: estGas + 1,
|
|
gasPrice: await this.getFairGasPrice()
|
|
})
|
|
|
|
return trxReceipt
|
|
}
|
|
|
|
/**
|
|
* Estimate gas cost for addTo725StoreList method
|
|
* @param {String} nftAddress NFT contract address
|
|
* @param {String} address NFT Manager adress
|
|
* @param {String} storeUpdater User adress which is going to have Store Updater permission
|
|
* @param {Contract} nftContract optional contract instance
|
|
* @return {Promise<any>}
|
|
*/
|
|
public async estGasGasAddStoreUpdater(
|
|
nftAddress: string,
|
|
address: string,
|
|
storeUpdater: string,
|
|
contractInstance?: Contract
|
|
): Promise<any> {
|
|
const nftContract = contractInstance || this.getContract(nftAddress)
|
|
|
|
return estimateGas(address, nftContract.methods.addTo725StoreList, storeUpdater)
|
|
}
|
|
|
|
/**
|
|
* Add Store Updater permission - only Manager can succeed
|
|
* @param {String} nftAddress NFT contract address
|
|
* @param {String} address NFT Manager adress
|
|
* @param {String} storeUpdater User adress which is going to have Store Updater permission
|
|
* @return {Promise<TransactionReceipt>} trxReceipt
|
|
*/
|
|
public async addStoreUpdater(
|
|
nftAddress: string,
|
|
address: string,
|
|
storeUpdater: string
|
|
): Promise<TransactionReceipt> {
|
|
const nftContract = this.getContract(nftAddress)
|
|
|
|
if ((await this.getNftPermissions(nftAddress, address)).manager !== true) {
|
|
throw new Error(`Caller is not Manager`)
|
|
}
|
|
|
|
const estGas = await estimateGas(
|
|
address,
|
|
nftContract.methods.addTo725StoreList,
|
|
storeUpdater
|
|
)
|
|
|
|
// Call addTo725StoreList function of the contract
|
|
const trxReceipt = await nftContract.methods.addTo725StoreList(storeUpdater).send({
|
|
from: address,
|
|
gas: estGas + 1,
|
|
gasPrice: await this.getFairGasPrice()
|
|
})
|
|
|
|
return trxReceipt
|
|
}
|
|
|
|
/**
|
|
* Estimate gas cost for removeFrom725StoreList method
|
|
* @param {String} nftAddress NFT contract address
|
|
* @param {String} address NFT Manager adress
|
|
* @param {String} storeUpdater Address of the user to be revoked Store Updater Permission
|
|
* @param {Contract} nftContract optional contract instance
|
|
* @return {Promise<any>}
|
|
*/
|
|
public async estGasGasRemoveStoreUpdater(
|
|
nftAddress: string,
|
|
address: string,
|
|
storeUpdater: string,
|
|
contractInstance?: Contract
|
|
): Promise<any> {
|
|
const nftContract = contractInstance || this.getContract(nftAddress)
|
|
|
|
return estimateGas(address, nftContract.methods.removeFrom725StoreList, storeUpdater)
|
|
}
|
|
|
|
/**
|
|
* Remove Store Updater permission - only Manager can succeed
|
|
* @param {String} nftAddress NFT contract address
|
|
* @param {String} address NFT Manager adress
|
|
* @param {String} storeUpdater Address of the user to be revoked Store Updater Permission
|
|
* @return {Promise<TransactionReceipt>} trxReceipt
|
|
*/
|
|
public async removeStoreUpdater(
|
|
nftAddress: string,
|
|
address: string,
|
|
storeUpdater: string
|
|
): Promise<TransactionReceipt> {
|
|
const nftContract = this.getContract(nftAddress)
|
|
|
|
if (
|
|
(await this.getNftPermissions(nftAddress, address)).manager !== true ||
|
|
(address !== storeUpdater &&
|
|
(await this.getNftPermissions(nftAddress, address)).store !== true)
|
|
) {
|
|
throw new Error(`Caller is not Manager nor storeUpdater`)
|
|
}
|
|
|
|
const estGas = await estimateGas(
|
|
address,
|
|
nftContract.methods.removeFrom725StoreList,
|
|
storeUpdater
|
|
)
|
|
|
|
// Call removeFrom725StoreList function of the contract
|
|
const trxReceipt = await nftContract.methods
|
|
.removeFrom725StoreList(storeUpdater)
|
|
.send({
|
|
from: address,
|
|
gas: estGas + 1,
|
|
gasPrice: await this.getFairGasPrice()
|
|
})
|
|
|
|
return trxReceipt
|
|
}
|
|
|
|
/**
|
|
* Estimate gas cost for cleanPermissions method
|
|
* @param {String} nftAddress NFT contract address
|
|
* @param {String} address NFT Owner adress
|
|
* @param {Contract} nftContract optional contract instance
|
|
* @return {Promise<any>}
|
|
*/
|
|
public async estGasGasCleanPermissions(
|
|
nftAddress: string,
|
|
address: string,
|
|
contractInstance?: Contract
|
|
): Promise<any> {
|
|
const nftContract = contractInstance || this.getContract(nftAddress)
|
|
|
|
return estimateGas(address, nftContract.methods.cleanPermissions)
|
|
}
|
|
|
|
/**
|
|
* This function allows to remove all ROLES at NFT level: Managers, DatatokenDeployer, MetadataUpdater, StoreUpdater
|
|
* Even NFT Owner has to readd himself as Manager
|
|
* Permissions at Datatoken level stay.
|
|
* Only NFT Owner can call it.
|
|
* @param {String} nftAddress NFT contract address
|
|
* @param {String} address NFT Owner adress
|
|
* @return {Promise<TransactionReceipt>} trxReceipt
|
|
*/
|
|
|
|
public async cleanPermissions(
|
|
nftAddress: string,
|
|
address: string
|
|
): Promise<TransactionReceipt> {
|
|
const nftContract = this.getContract(nftAddress)
|
|
|
|
if ((await this.getNftOwner(nftAddress)) !== address) {
|
|
throw new Error(`Caller is not NFT Owner`)
|
|
}
|
|
|
|
const estGas = await estimateGas(address, nftContract.methods.cleanPermissions)
|
|
|
|
// Call cleanPermissions function of the contract
|
|
const trxReceipt = await nftContract.methods.cleanPermissions().send({
|
|
from: address,
|
|
gas: estGas + 1,
|
|
gasPrice: await this.getFairGasPrice()
|
|
})
|
|
|
|
return trxReceipt
|
|
}
|
|
|
|
/**
|
|
* Estimate gas cost for transfer NFT method
|
|
* @param {String} nftAddress NFT contract address
|
|
* @param {String} nftOwner Current NFT Owner adress
|
|
* @param {String} nftReceiver User which will receive the NFT, will also be set as Manager
|
|
* @param {Number} tokenId The id of the token to be transfered
|
|
* @param {Contract} nftContract optional contract instance
|
|
* @return {Promise<any>}
|
|
*/
|
|
public async estGasGasTransferNft(
|
|
nftAddress: string,
|
|
nftOwner: string,
|
|
nftReceiver: string,
|
|
tokenId: number,
|
|
contractInstance?: Contract
|
|
): Promise<any> {
|
|
const nftContract = contractInstance || this.getContract(nftAddress)
|
|
|
|
return estimateGas(
|
|
nftOwner,
|
|
nftContract.methods.transferFrom,
|
|
nftOwner,
|
|
nftReceiver,
|
|
tokenId
|
|
)
|
|
}
|
|
|
|
/**
|
|
* Transfers the NFT
|
|
* will clean all permissions both on NFT and Datatoken level.
|
|
* @param {String} nftAddress NFT contract address
|
|
* @param {String} nftOwner Current NFT Owner adress
|
|
* @param {String} nftReceiver User which will receive the NFT, will also be set as Manager
|
|
* @param {Number} tokenId The id of the token to be transfered
|
|
* @return {Promise<TransactionReceipt>} trxReceipt
|
|
*/
|
|
public async transferNft(
|
|
nftAddress: string,
|
|
nftOwner: string,
|
|
nftReceiver: string,
|
|
tokenId?: number
|
|
): Promise<TransactionReceipt> {
|
|
const nftContract = this.getContract(nftAddress)
|
|
|
|
if ((await this.getNftOwner(nftAddress)) !== nftOwner) {
|
|
throw new Error(`Caller is not NFT Owner`)
|
|
}
|
|
|
|
const tokenIdentifier = tokenId || 1
|
|
|
|
const estGas = await estimateGas(
|
|
nftOwner,
|
|
nftContract.methods.transferFrom,
|
|
nftOwner,
|
|
nftReceiver,
|
|
tokenIdentifier
|
|
)
|
|
|
|
// Call transferFrom function of the contract
|
|
const trxReceipt = await nftContract.methods
|
|
.transferFrom(nftOwner, nftReceiver, tokenIdentifier)
|
|
.send({
|
|
from: nftOwner,
|
|
gas: estGas + 1,
|
|
gasPrice: await this.getFairGasPrice()
|
|
})
|
|
|
|
return trxReceipt
|
|
}
|
|
|
|
/**
|
|
* Estimate gas cost for safeTransfer NFT method
|
|
* @param {String} nftAddress NFT contract address
|
|
* @param {String} nftOwner Current NFT Owner adress
|
|
* @param {String} nftReceiver User which will receive the NFT, will also be set as Manager
|
|
* @param {Number} tokenId The id of the token to be transfered
|
|
* @param {Contract} nftContract optional contract instance
|
|
* @return {Promise<any>}
|
|
*/
|
|
public async estGasGasSafeTransferNft(
|
|
nftAddress: string,
|
|
nftOwner: string,
|
|
nftReceiver: string,
|
|
tokenId: number,
|
|
contractInstance?: Contract
|
|
): Promise<any> {
|
|
const nftContract = contractInstance || this.getContract(nftAddress)
|
|
|
|
return estimateGas(
|
|
nftOwner,
|
|
nftContract.methods.safeTransferFrom,
|
|
nftOwner,
|
|
nftReceiver,
|
|
tokenId
|
|
)
|
|
}
|
|
|
|
/**
|
|
* safeTransferNFT Used for transferring the NFT, can be used by an approved relayer
|
|
* will clean all permissions both on NFT and Datatoken level.
|
|
* @param {String} nftAddress NFT contract address
|
|
* @param {String} nftOwner Current NFT Owner adress
|
|
* @param {String} nftReceiver User which will receive the NFT, will also be set as Manager
|
|
* @param {Number} tokenId The id of the token to be transfered
|
|
* @return {Promise<TransactionReceipt>} trxReceipt
|
|
*/
|
|
public async safeTransferNft(
|
|
nftAddress: string,
|
|
nftOwner: string,
|
|
nftReceiver: string,
|
|
tokenId?: number
|
|
): Promise<TransactionReceipt> {
|
|
const nftContract = this.getContract(nftAddress)
|
|
|
|
if ((await this.getNftOwner(nftAddress)) !== nftOwner) {
|
|
throw new Error(`Caller is not NFT Owner`)
|
|
}
|
|
|
|
const tokenIdentifier = tokenId || 1
|
|
|
|
const estGas = await estimateGas(
|
|
nftOwner,
|
|
nftContract.methods.safeTransferFrom,
|
|
nftOwner,
|
|
nftReceiver,
|
|
tokenIdentifier
|
|
)
|
|
|
|
// Call transferFrom function of the contract
|
|
const trxReceipt = await nftContract.methods
|
|
.safeTransferFrom(nftOwner, nftReceiver, tokenIdentifier)
|
|
.send({
|
|
from: nftOwner,
|
|
gas: estGas + 1,
|
|
gasPrice: await this.getFairGasPrice()
|
|
})
|
|
|
|
return trxReceipt
|
|
}
|
|
|
|
// TODO: Finish this description
|
|
/**
|
|
* Estimate gas cost for setMetadata method
|
|
* @param {String} nftAddress NFT contract address
|
|
* @param {String} metadataUpdater metadataUpdater address
|
|
* @param {Number} metadataState User which will receive the NFT, will also be set as Manager
|
|
* @param {String} metadataDecryptorUrl
|
|
* @param {Number} tokenId The id of the token to be transfered
|
|
* @param {Contract} nftContract optional contract instance
|
|
* @return {Promise<any>}
|
|
*/
|
|
public async estGasGasSetMetadata(
|
|
nftAddress: string,
|
|
metadataUpdater: string,
|
|
metadataState: number,
|
|
metadataDecryptorUrl: string,
|
|
metadataDecryptorAddress: string,
|
|
flags: string,
|
|
data: string,
|
|
metadataHash: string,
|
|
metadataProofs?: MetadataProof[],
|
|
contractInstance?: Contract
|
|
): Promise<any> {
|
|
const nftContract = contractInstance || this.getContract(nftAddress)
|
|
if (!metadataProofs) metadataProofs = []
|
|
return estimateGas(
|
|
metadataUpdater,
|
|
nftContract.methods.setMetaData,
|
|
metadataState,
|
|
metadataDecryptorUrl,
|
|
metadataDecryptorAddress,
|
|
flags,
|
|
data,
|
|
metadataHash,
|
|
metadataProofs
|
|
)
|
|
}
|
|
|
|
/**
|
|
* safeTransferNFT Used for transferring the NFT, can be used by an approved relayer
|
|
* will clean all permissions both on NFT and Datatoken level.
|
|
* @param {String} nftAddress NFT contract address
|
|
* @param {String} address Caller address NFT Owner adress
|
|
* @return {Promise<TransactionReceipt>} trxReceipt
|
|
*/
|
|
public async setMetadata(
|
|
nftAddress: string,
|
|
address: string,
|
|
metadataState: number,
|
|
metadataDecryptorUrl: string,
|
|
metadataDecryptorAddress: string,
|
|
flags: string,
|
|
data: string,
|
|
metadataHash: string,
|
|
metadataProofs?: MetadataProof[]
|
|
): Promise<TransactionReceipt> {
|
|
const nftContract = this.getContract(nftAddress)
|
|
if (!metadataProofs) metadataProofs = []
|
|
if (!(await this.getNftPermissions(nftAddress, address)).updateMetadata) {
|
|
throw new Error(`Caller is not Metadata updater`)
|
|
}
|
|
const estGas = await estimateGas(
|
|
address,
|
|
nftContract.methods.setMetaData,
|
|
metadataState,
|
|
metadataDecryptorUrl,
|
|
metadataDecryptorAddress,
|
|
flags,
|
|
data,
|
|
metadataHash,
|
|
metadataProofs
|
|
)
|
|
const trxReceipt = await nftContract.methods
|
|
.setMetaData(
|
|
metadataState,
|
|
metadataDecryptorUrl,
|
|
metadataDecryptorAddress,
|
|
flags,
|
|
data,
|
|
metadataHash,
|
|
metadataProofs
|
|
)
|
|
.send({
|
|
from: address,
|
|
gas: estGas + 1,
|
|
gasPrice: await this.getFairGasPrice()
|
|
})
|
|
|
|
return trxReceipt
|
|
}
|
|
|
|
/**
|
|
* Estimate gas cost for setMetadata method
|
|
* @param {String} nftAddress NFT contract address
|
|
* @param {String} metadataUpdater metadataUpdater address
|
|
* @param {MetaDataAndTokenURI} metadataAndTokenURI metaDataAndTokenURI object
|
|
* @param {Contract} nftContract optional contract instance
|
|
* @return {Promise<any>}
|
|
*/
|
|
public async estGasGasSetMetadataAndTokenURI(
|
|
nftAddress: string,
|
|
metadataUpdater: string,
|
|
metadataAndTokenURI: MetadataAndTokenURI,
|
|
contractInstance?: Contract
|
|
): Promise<any> {
|
|
const nftContract = contractInstance || this.getContract(nftAddress)
|
|
const sanitizedMetadataAndTokenURI = {
|
|
...metadataAndTokenURI,
|
|
metadataProofs: metadataAndTokenURI.metadataProofs || []
|
|
}
|
|
return estimateGas(
|
|
metadataUpdater,
|
|
nftContract.methods.setMetaDataAndTokenURI,
|
|
sanitizedMetadataAndTokenURI
|
|
)
|
|
}
|
|
|
|
/**
|
|
* Helper function to improve UX sets both MetaData & TokenURI in one tx
|
|
* @param {String} nftAddress NFT contract address
|
|
* @param {String} address Caller address
|
|
* @param {MetadataAndTokenURI} metadataAndTokenURI metaDataAndTokenURI object
|
|
* @return {Promise<TransactionReceipt>} trxReceipt
|
|
*/
|
|
public async setMetadataAndTokenURI(
|
|
nftAddress: string,
|
|
metadataUpdater: string,
|
|
metadataAndTokenURI: MetadataAndTokenURI
|
|
): Promise<TransactionReceipt> {
|
|
const nftContract = this.getContract(nftAddress)
|
|
if (!(await this.getNftPermissions(nftAddress, metadataUpdater)).updateMetadata) {
|
|
throw new Error(`Caller is not Metadata updater`)
|
|
}
|
|
const sanitizedMetadataAndTokenURI = {
|
|
...metadataAndTokenURI,
|
|
metadataProofs: metadataAndTokenURI.metadataProofs || []
|
|
}
|
|
const estGas = await estimateGas(
|
|
metadataUpdater,
|
|
nftContract.methods.setMetaDataAndTokenURI,
|
|
sanitizedMetadataAndTokenURI
|
|
)
|
|
const trxReceipt = await nftContract.methods
|
|
.setMetaDataAndTokenURI(sanitizedMetadataAndTokenURI)
|
|
.send({
|
|
from: metadataUpdater,
|
|
gas: estGas + 1,
|
|
gasPrice: await this.getFairGasPrice()
|
|
})
|
|
|
|
return trxReceipt
|
|
}
|
|
|
|
/**
|
|
* Estimate gas cost for setMetadataState method
|
|
* @param {String} nftAddress NFT contract address
|
|
* @param {String} nftOwner Current NFT Owner adress
|
|
* @param {Number} metadataState new metadata state
|
|
* @param {Contract} nftContract optional contract instance
|
|
* @return {Promise<any>}
|
|
*/
|
|
public async estGasGasSetMetadataState(
|
|
nftAddress: string,
|
|
metadataUpdater: string,
|
|
metadataState: number,
|
|
contractInstance?: Contract
|
|
): Promise<any> {
|
|
const nftContract = contractInstance || this.getContract(nftAddress)
|
|
|
|
return estimateGas(
|
|
metadataUpdater,
|
|
nftContract.methods.setMetaDataState,
|
|
metadataState
|
|
)
|
|
}
|
|
|
|
/**
|
|
* setMetadataState Used for updating the metadata State
|
|
* @param {String} nftAddress NFT contract address
|
|
* @param {String} address Caller address => metadata updater
|
|
* @param {Number} metadataState new metadata state
|
|
* @return {Promise<TransactionReceipt>} trxReceipt
|
|
*/
|
|
public async setMetadataState(
|
|
nftAddress: string,
|
|
address: string,
|
|
metadataState: number
|
|
): Promise<TransactionReceipt> {
|
|
const nftContract = this.getContract(nftAddress)
|
|
|
|
if (!(await this.getNftPermissions(nftAddress, address)).updateMetadata) {
|
|
throw new Error(`Caller is not Metadata updater`)
|
|
}
|
|
|
|
const estGas = await estimateGas(
|
|
address,
|
|
nftContract.methods.setMetaDataState,
|
|
metadataState
|
|
)
|
|
|
|
// Call transferFrom function of the contract
|
|
const trxReceipt = await nftContract.methods.setMetaDataState(metadataState).send({
|
|
from: address,
|
|
gas: estGas + 1,
|
|
gasPrice: await this.getFairGasPrice()
|
|
})
|
|
|
|
return trxReceipt
|
|
}
|
|
|
|
/** Estimate gas cost for setTokenURI method
|
|
* @param nftAddress NFT contract address
|
|
* @param address user adress
|
|
* @param data input data for TokenURI
|
|
* @return {Promise<TransactionReceipt>} transaction receipt
|
|
*/
|
|
public async estGasSetTokenURI(
|
|
nftAddress: string,
|
|
address: string,
|
|
data: string
|
|
): Promise<any> {
|
|
const nftContract = this.getContract(nftAddress)
|
|
|
|
return estimateGas(address, nftContract.methods.setTokenURI, '1', data)
|
|
}
|
|
|
|
/** set TokenURI on an nft
|
|
* @param nftAddress NFT contract address
|
|
* @param address user adress
|
|
* @param data input data for TokenURI
|
|
* @return {Promise<TransactionReceipt>} transaction receipt
|
|
*/
|
|
public async setTokenURI(
|
|
nftAddress: string,
|
|
address: string,
|
|
data: string
|
|
): Promise<any> {
|
|
const nftContract = this.getContract(nftAddress)
|
|
|
|
const estGas = await estimateGas(address, nftContract.methods.setTokenURI, '1', data)
|
|
const trxReceipt = await nftContract.methods.setTokenURI('1', data).send({
|
|
from: address,
|
|
gas: estGas + 1,
|
|
gasPrice: await this.getFairGasPrice()
|
|
})
|
|
return trxReceipt
|
|
}
|
|
|
|
/** Get Owner
|
|
* @param {String} nftAddress NFT contract address
|
|
* @return {Promise<string>} string
|
|
*/
|
|
public async getNftOwner(nftAddress: string): Promise<string> {
|
|
const nftContract = this.getContract(nftAddress)
|
|
const trxReceipt = await nftContract.methods.ownerOf(1).call()
|
|
return trxReceipt
|
|
}
|
|
|
|
/** Get users NFT Permissions
|
|
* @param {String} nftAddress NFT contract address
|
|
* @param {String} address user adress
|
|
* @return {Promise<NftRoles>}
|
|
*/
|
|
public async getNftPermissions(nftAddress: string, address: string): Promise<NftRoles> {
|
|
const nftContract = this.getContract(nftAddress)
|
|
const roles = await nftContract.methods.getPermissions(address).call()
|
|
return roles
|
|
}
|
|
|
|
/** Get users Metadata, return Metadata details
|
|
* @param {String} nftAddress NFT contract address
|
|
* @return {Promise<Objecta>}
|
|
*/
|
|
public async getMetadata(nftAddress: string): Promise<Object> {
|
|
const nftContract = this.getContract(nftAddress)
|
|
return await nftContract.methods.getMetaData().call()
|
|
}
|
|
|
|
/** Get users DatatokenDeployer role
|
|
* @param {String} nftAddress NFT contract address
|
|
* @param {String} address user adress
|
|
* @return {Promise<boolean>}
|
|
*/
|
|
public async isDatatokenDeployer(
|
|
nftAddress: string,
|
|
address: string
|
|
): Promise<boolean> {
|
|
const nftContract = this.getContract(nftAddress)
|
|
const isDatatokenDeployer = await nftContract.methods.isERC20Deployer(address).call()
|
|
return isDatatokenDeployer
|
|
}
|
|
|
|
/** Gets data at a given `key`
|
|
* @param {String} nftAddress NFT contract address
|
|
* @param {String} key the key which value to retrieve
|
|
* @return {Promise<string>} The data stored at the key
|
|
*/
|
|
public async getData(nftAddress: string, key: string): Promise<string> {
|
|
const nftContract = this.getContract(nftAddress)
|
|
const data = await nftContract.methods.getData(key).call()
|
|
return data
|
|
}
|
|
|
|
/** Gets data at a given `key`
|
|
* @param {String} nftAddress NFT contract address
|
|
* @param {String} id
|
|
* @return {Promise<string>} The data stored at the key
|
|
*/
|
|
public async getTokenURI(nftAddress: string, id: number): Promise<string> {
|
|
const nftContract = this.getContract(nftAddress)
|
|
const data = await nftContract.methods.tokenURI(id).call()
|
|
return data
|
|
}
|
|
}
|