ufomarketplace-sdk-new
Version:
SDK to interact with set ufo marketplace contracts
368 lines • 17.4 kB
JavaScript
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ufoMarketplaceSDK = void 0;
const ethers_1 = require("ethers");
const types_1 = require("./types");
const wrapper_1 = require("./wrapper");
const bignumber_js_1 = require("bignumber.js");
const constants_1 = require("./constants/constants");
const exponent = new bignumber_js_1.BigNumber('10').pow(18);
const usdtExponent = new bignumber_js_1.BigNumber('10').pow(6);
const MAX_INT = ethers_1.BigNumber.from('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff');
class ufoMarketplaceSDK {
constructor(_signer, _config, _netID) {
this.signer = _signer;
this.config = _config;
this.galaticFactory = new wrapper_1.SuperGalaticFactory__factory(_signer).attach(_config.ufoSuperGalaticFactory);
let netId = parseInt(_netID);
this.netId = netId;
switch (netId) {
case constants_1.NETWORK_ID.ETHEREUM:
case constants_1.NETWORK_ID.SEPOLIA:
if (_config.ufoConfig.plasmaTokenOnEth != null && _config.ufoConfig.plasmaTokenOnEth != undefined) {
this.plasma = new wrapper_1.ERC20Upgradeable__factory(this.signer).attach(_config.ufoConfig.plasmaTokenOnEth);
}
this.wETHToken = new wrapper_1.ERC20__factory(this.signer).attach(_config.ufoConfig.WETHOnEth);
break;
case constants_1.NETWORK_ID.BEAM:
case constants_1.NETWORK_ID.BEAM_TESTNET:
this.plasma = new wrapper_1.ERC20Upgradeable__factory(this.signer).attach(_config.ufoConfig.plasmaTokenOnBeamTestNet);
this.wETHToken = new wrapper_1.ERC20__factory(this.signer).attach(_config.ufoConfig.WETHOnBeamTestNet);
this.usdtToken = new wrapper_1.ERC20__factory(this.signer).attach(_config.ufoConfig.usdtTokenOnBeamTestNet);
break;
}
}
sleep(ms) {
return __awaiter(this, void 0, void 0, function* () {
return new Promise((resolve) => setTimeout(resolve, ms));
});
}
nftHasApprovalToMarketplace(contractAddr, nftId) {
return __awaiter(this, void 0, void 0, function* () {
let nftContract = new wrapper_1.ERC721Upgradeable__factory(this.signer).attach(contractAddr);
const _temp = new bignumber_js_1.BigNumber(nftId);
if (_temp.isNegative()) {
throw new Error(`${nftId} is a negative amount`);
}
return (yield nftContract.getApproved(nftId)) == this.config.ufoMarketplace;
});
}
approveNftToMarketplace(contractAddr, nftId) {
return __awaiter(this, void 0, void 0, function* () {
let nftContract = new wrapper_1.ERC721Upgradeable__factory(this.signer).attach(contractAddr);
const _temp = new bignumber_js_1.BigNumber(nftId);
if (_temp.isNegative()) {
throw new Error(`${nftId} is a negative amount`);
}
return nftContract.approve(this.config.ufoMarketplace, nftId);
});
}
wETHAllowance(amount) {
return __awaiter(this, void 0, void 0, function* () {
const addr = yield this.signer.getAddress();
const allowance = yield this.wETHToken.allowance(addr, this.config.ufoMarketplace);
const _temp = new bignumber_js_1.BigNumber(amount);
return new bignumber_js_1.BigNumber(allowance.toString()).gte(_temp);
});
}
wETHBalance() {
return __awaiter(this, void 0, void 0, function* () {
const addr = yield this.signer.getAddress();
let balance = yield this.wETHToken.balanceOf(addr);
const balStr = ethers_1.ethers.utils.formatEther(balance);
return balStr;
});
}
getNFTCurrentSupply(contractAddr) {
return __awaiter(this, void 0, void 0, function* () {
let nftContract = wrapper_1.ERC721EnumerableUpgradeable__factory.connect(contractAddr, this.signer);
return (yield nftContract.totalSupply()).toNumber();
});
}
revealNft() {
return __awaiter(this, void 0, void 0, function* () {
return yield this.galaticFactory.registerForMint();
});
}
test() {
return __awaiter(this, void 0, void 0, function* () {
console.log("========1========");
yield this.sleep(5000);
console.log("=========2=======");
});
}
batchMintGalaticNFT(categoryIds, amounts, type, merkleProof) {
return __awaiter(this, void 0, void 0, function* () {
console.log('======', categoryIds, amounts, type, merkleProof);
switch (type) {
case types_1.PurchaseType.PLASMA:
return this.batchMintGalaticNFTByPlasma(categoryIds, amounts, merkleProof);
case types_1.PurchaseType.BEAM:
return this.batchMintGalaticNFTByBeam(categoryIds, amounts, merkleProof);
case types_1.PurchaseType.USDT:
return this.batchMintGalaticNFTByUsdt(categoryIds, amounts, merkleProof);
}
});
}
batchMintGalaticNFTByPlasma(categoryIds, amounts, merkleProof) {
return __awaiter(this, void 0, void 0, function* () {
return this.galaticFactory.mintBatchSuperGalatic(categoryIds, amounts, merkleProof);
});
}
batchMintGalaticNFTByBeam(categoryIds, amounts, merkleProof) {
return __awaiter(this, void 0, void 0, function* () {
let totalCount = amounts.reduce((acc, curr) => {
return acc + curr;
}, 0);
yield this.sleep(5000);
let nftPriceInBeam = yield this.galaticFactory.beamAmountPerNft();
let nativeTokenAmount = ethers_1.BigNumber.from(totalCount).mul(nftPriceInBeam).mul("250").toString();
return this.galaticFactory.mintWithBeam(categoryIds, amounts, merkleProof, {
value: nativeTokenAmount,
gasLimit: ethers_1.BigNumber.from('2500000'),
});
});
}
batchMintGalaticNFTByUsdt(categoryIds, amounts, merkleProof) {
return __awaiter(this, void 0, void 0, function* () {
// Estimate gas for the transaction
// const gasEstimate = await this.galaticFactory.estimateGas.mintSuperGalaticByUSDT(categoryIds, amounts, merkleProof);
// console.log("===============gas============", gasEstimate.toString());
// // Execute the transaction with the estimated gas
yield this.sleep(5000);
return this.galaticFactory.mintWithUSDT(categoryIds, amounts, merkleProof, {
gasLimit: ethers_1.BigNumber.from('2500000'), //gasEstimate.mul(120).div(100) // Add 20% buffer to gas estimate
});
});
}
plasmaAmountPerNFT() {
return __awaiter(this, void 0, void 0, function* () {
let plasmaAmount = yield this.galaticFactory.plasmaAmountPerNFT();
return new bignumber_js_1.BigNumber(plasmaAmount.toString()).div(exponent).toString();
});
}
//wETH
getWETHAllowanceOfNFTFactory() {
return __awaiter(this, void 0, void 0, function* () {
if (this.wETHToken == null || this.wETHToken == undefined)
throw new Error('check the wETHToken contract of correct network');
let allowance = yield this.wETHToken.allowance(yield this.signer.getAddress(), this.galaticFactory.address);
let ret = new bignumber_js_1.BigNumber(allowance.toString()).div(exponent).toString();
return ret;
});
}
getWETHAllowanceOfMarketplace() {
return __awaiter(this, void 0, void 0, function* () {
if (this.wETHToken == null || this.wETHToken == undefined)
throw new Error('check the wETHToken contract of correct network');
let allowance = yield this.wETHToken.allowance(yield this.signer.getAddress(), this.config.ufoMarketplace);
let ret = new bignumber_js_1.BigNumber(allowance.toString()).div(exponent).toString();
return ret;
});
}
getAddressOfPriceToken(token_unit) {
console.log('getAddressOfPriceToken', this.netId);
switch (this.netId) {
case constants_1.NETWORK_ID.BEAM_TESTNET:
if (token_unit == constants_1.USER_CURRENCY['WETH']) {
return this.config.ufoConfig.WETHOnBeamTestNet;
}
else if (token_unit == constants_1.USER_CURRENCY['UFO']) {
return this.config.ufoConfig.ufoTokenOnBeamTestNet;
}
else {
return this.config.ufoConfig.usdtTokenOnBeamTestNet;
}
case constants_1.NETWORK_ID.BEAM:
if (token_unit == constants_1.USER_CURRENCY['WETH']) {
return this.config.ufoConfig.WETHOnBeamTestNet;
}
else if (token_unit == constants_1.USER_CURRENCY['UFO']) {
return this.config.ufoConfig.ufoTokenOnBeamTestNet;
}
else {
return this.config.ufoConfig.usdtTokenOnBeamTestNet;
}
default:
return '000000';
}
}
approveToken(price_unit, spender, amount) {
return __awaiter(this, void 0, void 0, function* () {
let address = this.getAddressOfPriceToken(price_unit);
let token = new wrapper_1.ERC20__factory(this.signer).attach(address);
return token.approve(spender, amount);
});
}
hasApprovalToken(price_unit, spnder, amount) {
return __awaiter(this, void 0, void 0, function* () {
let address = this.getAddressOfPriceToken(price_unit);
let token = new wrapper_1.ERC20__factory(this.signer).attach(address);
let allowance = yield token.allowance(yield this.signer.getAddress(), spnder);
console.log('allowance======', allowance);
let ret = new bignumber_js_1.BigNumber(allowance.toString()).gte(new bignumber_js_1.BigNumber(amount));
return ret;
});
}
approveWETHToMarketplace() {
return __awaiter(this, void 0, void 0, function* () {
return this.wETHToken.approve(this.config.ufoMarketplace, MAX_INT);
});
}
approveWETHToNFTFactory(amount) {
return __awaiter(this, void 0, void 0, function* () {
if (amount) {
return this.wETHToken.approve(this.config.ufoSuperGalaticFactory, amount);
}
else {
return this.wETHToken.approve(this.config.ufoSuperGalaticFactory, MAX_INT);
}
});
}
hasWETHApprovalOfMarketplace(amount) {
return __awaiter(this, void 0, void 0, function* () {
const _temp = new bignumber_js_1.BigNumber(amount);
if (_temp.isNegative()) {
throw new Error(`${amount} is a negative amount`);
}
let allowance = yield this.getWETHAllowanceOfMarketplace();
return new bignumber_js_1.BigNumber(allowance).gte(_temp);
});
}
//plasma function
hasPlasmaApprovalOfNFTFactory(amount) {
return __awaiter(this, void 0, void 0, function* () {
const _temp = new bignumber_js_1.BigNumber(amount);
if (_temp.isNegative()) {
throw new Error(`${amount} is a negative amount`);
}
let allowance = yield this.getPlasmaAllowanceOfNFTFactory();
return new bignumber_js_1.BigNumber(allowance).gte(_temp);
});
}
approveUsdtToNFTFactory(price) {
return __awaiter(this, void 0, void 0, function* () {
return this.usdtToken.approve(this.galaticFactory.address, usdtExponent.multipliedBy(price).toFixed());
});
}
approvePlasmaToNFTFactory(price) {
return __awaiter(this, void 0, void 0, function* () {
return this.plasma.approve(this.galaticFactory.address, exponent.multipliedBy(price).toFixed());
});
}
approvePlasmaToMarketplace() {
return __awaiter(this, void 0, void 0, function* () {
return this.plasma.approve(this.galaticFactory.address, MAX_INT);
});
}
getPlasmaAllowanceOfNFTFactory() {
return __awaiter(this, void 0, void 0, function* () {
if (this.plasma == null || this.plasma == undefined)
throw new Error('check the Plasma contract of correct network');
let allowance = yield this.plasma.allowance(yield this.signer.getAddress(), this.galaticFactory.address);
let ret = new bignumber_js_1.BigNumber(allowance.toString()).div(exponent).toString();
return ret;
});
}
getNftAddresses() {
return __awaiter(this, void 0, void 0, function* () {
let res = [];
for (let i = 0; i < 10; i++) {
let addr = yield this.galaticFactory.nftContracts(i);
res.push(addr);
}
return res;
});
}
/**
* buy and sell weapon
* buy and sell type depends on buySellType variable of LootBuySellInfo structre
*/
buySellWeaponNFT(v, r, s, data) {
return __awaiter(this, void 0, void 0, function* () {
const marketplaceContract = new wrapper_1.UfoMarketplace__factory(this.signer).attach(this.config.ufoMarketplace);
return marketplaceContract.buySellLootBoxes(v, r, s, data);
});
}
/**
* this function is called by buyer to purchase the
*/
purchaseLoot(quantity, tokenType) {
return __awaiter(this, void 0, void 0, function* () {
return this.galaticFactory.purchaseLootbox(quantity, tokenType);
});
}
/**
* this function is called by sender to send some loot as gift
* this function is depricated because this function only transfer the loot box to receiver
*/
// public async sendLootasGift(quantity: BigNumber, receiver: string): Promise<ContractTransaction> {
// const marketplaceContract = new UfoMarketplace__factory(this.signer).attach(this.config.ufoMarketplace);
// return marketplaceContract.giftLootBoxes(quantity, receiver);
// }
/**
* this function is called by buyer to purchase the
*/
purchaseLootAndSendGift(quantity, giftReceiver, tokenType) {
return __awaiter(this, void 0, void 0, function* () {
return this.galaticFactory.purchaseLootboxAndSendGift(quantity, giftReceiver, tokenType);
});
}
/**
* this function is called by opener who open the loot
*/
openLoot(v, r, s, data) {
return __awaiter(this, void 0, void 0, function* () {
return this.galaticFactory.openLootBoxBySignature(v, r, s, data);
});
}
/**
* update the weapon by weapon owner
*/
updateWeapon(weaponId) {
return __awaiter(this, void 0, void 0, function* () {
return this.galaticFactory.updateWeapon(weaponId);
});
}
/**
* this function is called by buyer on fixed sell item
*/
buyNFT(v, r, s, data) {
return __awaiter(this, void 0, void 0, function* () {
const marketplaceContract = new wrapper_1.UfoMarketplace__factory(this.signer).attach(this.config.ufoMarketplace);
return marketplaceContract.buySellItem(v, r, s, data);
});
}
/**
* this function is called by seller on auction sell. seller accept one bid in many bids
*/
sellNFT(v, r, s, data) {
return __awaiter(this, void 0, void 0, function* () {
const marketplaceContract = new wrapper_1.UfoMarketplace__factory(this.signer).attach(this.config.ufoMarketplace);
return marketplaceContract.buySellItem(v, r, s, data);
});
}
claimUAP(v, r, s, data) {
return __awaiter(this, void 0, void 0, function* () {
const marketplaceContract = new wrapper_1.UfoMarketplace__factory(this.signer).attach(this.config.ufoMarketplace);
return marketplaceContract.claimUAP(v, r, s, data);
});
}
purchaseCartItems(v, r, s, data) {
return __awaiter(this, void 0, void 0, function* () {
const marketplaceContract = new wrapper_1.UfoMarketplace__factory(this.signer).attach(this.config.ufoMarketplace);
return marketplaceContract.buyCartItems(v, r, s, data);
});
}
}
exports.ufoMarketplaceSDK = ufoMarketplaceSDK;
//# sourceMappingURL=ufoMarketplaceSDK.js.map