update init frag && dropsV2 testing

config/kovan-config.js

@@ -62,7 +62,7 @@ module.exports = {
 
 
         //================== NFT ====================
-        Fragment: "0x7DD98F5F25fa946DA1F796E093bD259435646520",
+        Fragment: "0x96d07E96F703B2De722a8671638776924ab81E80",
         NFTCollateralVault: "0xD25278cd387e54E77C5490F5220b551fe2feb772",
         DODONFTRouteHelper: "0xDD1511f2Bcdb0E6F916F9740BF83f31dF0fb63b4",
 
@@ -71,7 +71,7 @@ module.exports = {
         NFTTokenFactory: "0x834D13Ca0322Ccfe67596f09Cc26Ee3584297B94",
 
         DODONFTRegistry: "0x579eBcC668b5517F733587091C35D495FE8d6b68",
-        DODONFTProxy: "0x5A6ba7ad175a2Be5176f76cfaf61E63abe9A7D12",
+        DODONFTProxy: "0xe121c6C90735e2Ca12e21708F2F379A55Ce61426",
 
         //================= MysteryBox =================
         // MysteryBoxV1: "0x47d2b27525b93A9c9E03001E1D19310A08748D55",//波老师

contracts/GeneralizedFragment/impl/Fragment.sol

@@ -54,7 +54,8 @@ contract Fragment is InitializableERC20 {
       uint256 buyoutTimestamp,
       address defaultMaintainer,
       uint256 defaultBuyoutFee,
-      uint256 distributionRatio
+      uint256 distributionRatio,
+      string memory _symbol
     ) external {
         require(!_FRAG_INITIALIZED_, "DODOFragment: ALREADY_INITIALIZED");
         _FRAG_INITIALIZED_ = true;
@@ -70,9 +71,8 @@ contract Fragment is InitializableERC20 {
         _DISTRIBUTION_RATIO_ = distributionRatio;
 
         // init FRAG meta data
-        string memory prefix = "FRAG_";
+        name = string(abi.encodePacked("DODO_FRAG_", _symbol));
-        name = string(abi.encodePacked(prefix, IDVM(_DVM_).addressToShortString(_COLLATERAL_VAULT_)));
+        symbol = string(abi.encodePacked("d_", _symbol));
-        symbol = "FRAG";
         decimals = 18;
         super.init(address(this), _totalSupply, name, symbol, decimals);
 

contracts/GeneralizedFragment/intf/IFragment.sol

@@ -19,7 +19,8 @@ interface IFragment {
       uint256 buyoutTimestamp,
       address defaultMaintainer,
       uint256 defaultBuyoutFee,
-      uint256 distributionRatio
+      uint256 distributionRatio,
+      string memory fragSymbol
     ) external;
 
     function buyout(address newVaultOwner) external;

contracts/SmartRoute/proxies/DODONFTProxy.sol

@@ -98,40 +98,39 @@ contract DODONFTProxy is ReentrancyGuard, InitializableOwnable {
     }
     
     function createFragment(
-        address quoteToken,
+        address[] calldata addrList, //0 - quoteToken, 1 - vaultPreOwner
-        address vaultPreOwner,
+        uint256[] calldata params, //(DVM: 0 - lpFeeRate 1 - I, 2 - K) , (FRAG: 3 - totalSupply, 4 - ownerRatio, 5 - buyoutTimestamp, 6 - distributionRatio)
-        uint256[] calldata dvmParams, //0 - lpFeeRate, 1 - I, 2 - K
+        bool isOpenTwap,
-        uint256[] calldata fragParams, //0 - totalSupply, 1 - ownerRatio, 2 - buyoutTimestamp, 3 - distributionRatio
+        string memory fragSymbol
-        bool isOpenTwap 
     ) external returns (address newFragment, address newDvm) {
         newFragment = ICloneFactory(_CLONE_FACTORY_).clone(_FRAG_TEMPLATE_);
-        address _quoteToken = quoteToken == _ETH_ADDRESS_ ? _WETH_ : quoteToken;
+        address _quoteToken = addrList[0] == _ETH_ADDRESS_ ? _WETH_ : addrList[0];
         
         {
-        uint256[] memory  _dvmParams = dvmParams;
+        uint256[] memory  _params = params;
-        uint256[] memory  _fragParams = fragParams;
         
         newDvm = ICloneFactory(_CLONE_FACTORY_).clone(_DVM_TEMPLATE_);
         IDVM(newDvm).init(
             _DEFAULT_MAINTAINER_,
             newFragment,
             _quoteToken,
-            _dvmParams[0],
+            _params[0],
             _MT_FEE_RATE_MODEL_,
-            _dvmParams[1],
+            _params[1],
-            _dvmParams[2],
+            _params[2],
             isOpenTwap
         );
         IFragment(newFragment).init(
             newDvm, 
-            vaultPreOwner, 
+            addrList[1], 
             msg.sender, 
-            _fragParams[0], 
+            _params[3], 
-            _fragParams[1], 
+            _params[4], 
-            _fragParams[2],
+            _params[5],
             _DEFAULT_MAINTAINER_,
             _DEFAULT_BUYOUT_FEE_,
-            _fragParams[3]
+            _params[6],
+            fragSymbol
         );
         }
 

deploy-nft.txt

@@ -333,4 +333,14 @@ network type: rinkeby
 Deploy time: 2021/5/25 下午3:39:50
 Deploy type: MysteryBoxKAKA
 MysteryBoxV1Address:  0x77915e3AC19E0465F6c0895779A9A4778B56C387
-Init MysteryBoxV1 Tx: 0xc707aad96a65d12a04234b912bd466f91d5f56f99f6c849a6b2a431ada6b519b
+Init MysteryBoxV1 Tx: 0xc707aad96a65d12a04234b912bd466f91d5f56f99f6c849a6b2a431ada6b519b====================================================
+network type: kovan
+Deploy time: 2021/5/26 下午7:11:55
+Deploy type: NFT
+multiSigAddress:  0x7e83d9d94837eE82F0cc18a691da6f42F03F1d86
+FragmentAddress:  0x96d07E96F703B2De722a8671638776924ab81E80
+DODONFTProxyAddress:  0xe121c6C90735e2Ca12e21708F2F379A55Ce61426
+Init DODONFTProxyAddress Tx: 0x6b72dd067b291dfb731af0304ceb0127e6b82696a0dca40e6269276c569ee91d
+DODOApproveProxy unlockAddProxy tx:  0x181aea8369c404f6626b17f843a61e7c51511730360fd112e8b45f89ac2a1865
+DODOApproveProxy addDODOProxy tx:  0x65363a442ef5cf984374d9add8a0c5f97a0cd72f34dba0a1ed1243aa9e5d4ee8
+Add AdminList on DODONFTRegistry Tx: 0x67c34c94a14ba9ee7639f7ff0ba8379eff062d219f16177398803d853b45f253

test/DODODrops/dropsV2.test.ts

@@ -4,20 +4,22 @@
     SPDX-License-Identifier: Apache-2.0
 
 */
-import { decimalStr, fromWei } from '../utils/Converter';
+import { decimalStr } from '../utils/Converter';
 import { logGas } from '../utils/Log';
 import { assert } from 'chai';
-import * as contracts from '../utils/Contracts';
 import { Contract } from 'web3-eth-contract';
+import * as contracts from '../utils/Contracts';
 import { DropsContext, getDropsContext } from '../utils/DropsContext';
-const truffleAssert = require('truffle-assertions');
+import { DVMContext, getDVMContext } from '../utils/DVMContext';
 
 let maintainer: string;
 let user1: string;
 let user2: string;
 let user3: string;
+let ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
+let RandomGenerator: Contract;
 
-async function init(ctx: DropsContext, mode: Boolean): Promise<void> {
+async function init(ctx: DropsContext, ctxDVM: DVMContext, isReveal: Boolean, mode: Boolean): Promise<void> {
     maintainer = ctx.SpareAccounts[0];
     user1 = ctx.SpareAccounts[1];
     user2 = ctx.SpareAccounts[2];
@@ -30,13 +32,41 @@ async function init(ctx: DropsContext, mode: Boolean): Promise<void> {
     await ctx.approveProxy(ctx.DODO, user2);
     await ctx.approveProxy(ctx.DODO, user3);
 
+
+    var nftContract;
+    if(mode) {
+        nftContract = ctx.DropsERC1155.options.address
+    }else {
+        nftContract = ctx.DropsERC721.options.address
+    }
+    var rngAddress;
+    if (isReveal) {
+        rngAddress = ZERO_ADDRESS;
+    }else {
+        await ctxDVM.mintTestToken(maintainer, decimalStr("10"), decimalStr("1000"));
+        await ctxDVM.transferBaseToDVM(maintainer, decimalStr("10"))
+        await ctxDVM.transferQuoteToDVM(maintainer, decimalStr("1000"))
+        await ctxDVM.DVM.methods.buyShares(maintainer).send(ctx.sendParam(maintainer));
+
+        RandomGenerator = await contracts.newContract(contracts.RANDOM_GENERATOR,
+            [
+                [
+                    ctxDVM.DVM.options.address,
+                    ctxDVM.DVM.options.address,
+                    ctxDVM.DVM.options.address
+                ]
+            ]
+        )
+        rngAddress = RandomGenerator.options.address
+    }
+
     var addrList = [
         ctx.Deployer,
         ctx.DODO.options.address,
         ctx.DropsFeeModel.options.address,
         maintainer,
-        "0x0000000000000000000000000000000000000000",
+        rngAddress,
-        ctx.DropsERC721.options.address
+        nftContract
     ]
 
     var curTime = Math.floor(new Date().getTime() / 1000)
@@ -47,12 +77,33 @@ async function init(ctx: DropsContext, mode: Boolean): Promise<void> {
         [10000000000000, 10000000000000, 0],
         [10, 10, 0],
         curTime + 10,
-        false,
+        isReveal,
         mode
     ).send(ctx.sendParam(ctx.Deployer));
 
 }
 
+async function setReveal(ctx: DropsContext) {
+    await ctx.DropsV2.methods.setRevealRn().send(ctx.sendParam(ctx.Deployer));
+}
+
+async function setTokenIdList(ctx: DropsContext) {
+    var tokenList = [1, 2, 3, 4, 5, 6, 7, 8]
+    await ctx.DropsV2.methods.setFixedAmountInfo(tokenList).send(ctx.sendParam(ctx.Deployer));
+}
+
+async function setProbMap(ctx: DropsContext) {
+    var probIntervals = [1, 5, 20, 50, 100]
+    var tokenIdMaps = [
+        [0],
+        [1, 2],
+        [3, 4, 5],
+        [6, 7],
+        [8, 9, 10, 11]
+    ]
+    await ctx.DropsV2.methods.setProbInfo(probIntervals, tokenIdMaps).send(ctx.sendParam(ctx.Deployer));
+}
+
 async function getTicketsInfo(ctx: DropsContext, user: string): Promise<[string, string]> {
     var totalTickets = await ctx.DropsV2.methods.totalSupply().call();
     var userTickets = await ctx.DropsV2.methods.balanceOf(user).call();
@@ -67,12 +118,30 @@ async function getBuyTokenBalance(ctx: DropsContext, user: string, token: Contra
     return [userDodo, dropsDodo];
 }
 
+async function getNFTOwner(nft721: Contract, tokenId: number): Promise<string> {
+    var userAddr = await nft721.methods.ownerOf(tokenId).call();
+    return userAddr
+}
+
+async function getNFTBalance(nft1155: Contract, user:string, tokenId: number): Promise<[number]> {
+    var num = await nft1155.methods.balanceOf(user, tokenId).call();
+    return num
+}
+
 
 describe("DODODropsV2", () => {
     let snapshotId: string;
     let ctx: DropsContext;
+    let ctxDVM: DVMContext;
 
     before(async () => {
+        let config = {
+            lpFeeRate: decimalStr("0.002"),
+            mtFeeRate: decimalStr("0.001"),
+            k: decimalStr("1"),
+            i: "1",
+        };
+        ctxDVM = await getDVMContext(config);
         ctx = await getDropsContext();
     });
 
@@ -86,7 +155,7 @@ describe("DODODropsV2", () => {
 
     describe("DODODropsV2", () => {
         it("buyTicket", async () => {
-            await init(ctx, false);
+            await init(ctx, ctxDVM, true, false);
             await ctx.EVM.increaseTime(10);
             await logGas(await ctx.DropsProxy.methods.buyTickets(ctx.DropsV2.options.address, 2), ctx.sendParam(user1), "buyTickets-user1");
             await logGas(await ctx.DropsProxy.methods.buyTickets(ctx.DropsV2.options.address, 3), ctx.sendParam(user2), "buyTickets-user2");
@@ -98,20 +167,80 @@ describe("DODODropsV2", () => {
             assert(dropsDodoBalance, decimalStr('0.00005'))
         });
 
-        it("redeemPrize", async () => {
+        it("redeemPrize-fixedAmount-reveal", async () => {
+            await init(ctx, ctxDVM, true, false);
+            await setTokenIdList(ctx);
+            await ctx.EVM.increaseTime(10);
+            await logGas(await ctx.DropsProxy.methods.buyTickets(ctx.DropsV2.options.address, 2), ctx.sendParam(user1), "buyTickets-user1");
 
+            await setReveal(ctx);
+
+            var tx = await logGas(await ctx.DropsV2.methods.redeemTicket(1, ZERO_ADDRESS), ctx.sendParam(user1), "redeem-prize");
+            var tokenId = tx.events['RedeemPrize'].returnValues['tokenId'];
+
+            var nftOwner = await getNFTOwner(ctx.DropsERC721, tokenId);
+
+            assert(user1, nftOwner);
+        });
+
+        it("redeemPrize-probAmount-reveal", async () => {
+            await init(ctx, ctxDVM, true, true);
+            await setProbMap(ctx);
+            await ctx.EVM.increaseTime(10);
+            await logGas(await ctx.DropsProxy.methods.buyTickets(ctx.DropsV2.options.address, 2), ctx.sendParam(user1), "buyTickets-user1");
+
+            await setReveal(ctx);
+
+            var tx = await logGas(await ctx.DropsV2.methods.redeemTicket(1, ZERO_ADDRESS), ctx.sendParam(user1), "redeem-prize");
+            var tokenId = tx.events['RedeemPrize'].returnValues['tokenId'];
+
+            var nftAmount = await getNFTBalance(ctx.DropsERC1155, user1, tokenId);
+
+            console.log("nftAmount:", nftAmount);
+
+            assert(nftAmount, '1');
         });
 
 
-        it.only("setProbMap", async () => {
+        it("redeemPrize-fixedAmount-rng", async () => {
-            await init(ctx, true);
+            await init(ctx, ctxDVM, false, false);
+            await setTokenIdList(ctx);
+            await ctx.EVM.increaseTime(10);
+            await logGas(await ctx.DropsProxy.methods.buyTickets(ctx.DropsV2.options.address, 2), ctx.sendParam(user1), "buyTickets-user1");
+
+            var tx = await logGas(await ctx.DropsV2.methods.redeemTicket(1, ZERO_ADDRESS), ctx.sendParam(user1), "redeem-prize");
+            var tokenId = tx.events['RedeemPrize'].returnValues['tokenId'];
+            console.log("tokenId:", tokenId);
+            var nftOwner = await getNFTOwner(ctx.DropsERC721, tokenId);
+
+            assert(user1, nftOwner);
+        });
+
+        it("redeemPrize-probAmount-rng", async () => {
+            await init(ctx, ctxDVM, false, true);
+            await setProbMap(ctx);
+            await ctx.EVM.increaseTime(10);
+            await logGas(await ctx.DropsProxy.methods.buyTickets(ctx.DropsV2.options.address, 2), ctx.sendParam(user1), "buyTickets-user1");
+
+            var tx = await logGas(await ctx.DropsV2.methods.redeemTicket(1, ZERO_ADDRESS), ctx.sendParam(user1), "redeem-prize");
+            var tokenId = tx.events['RedeemPrize'].returnValues['tokenId'];
+
+            var nftAmount = await getNFTBalance(ctx.DropsERC1155, user1, tokenId);
+
+            console.log("nftAmount:", nftAmount);
+
+            assert(nftAmount, '1');
+        });
+
+        it("setProbMap", async () => {
+            await init(ctx, ctxDVM, true, true);
             var probIntervals = [4, 10, 50, 100, 105]
             var tokenIdMaps = [
                 [0],
                 [1, 38],
                 [3, 4, 5],
                 [6, 7],
-                [19,30,35,40]
+                [19, 30, 35, 40]
             ]
             await logGas(await ctx.DropsV2.methods.setProbInfo(probIntervals, tokenIdMaps), ctx.sendParam(ctx.Deployer), "setProbInfo");
             var prob = await ctx.DropsV2.methods._PROB_INTERVAL_(0).call();
@@ -120,13 +249,18 @@ describe("DODODropsV2", () => {
             assert(tokenId, '38')
         })
 
-        it.only("setTokenList", async () => {
+        it("setTokenList", async () => {
-            await init(ctx, false);
+            await init(ctx, ctxDVM, true, false);
             var tokenList = [4, 10, 50, 100, 105]
             await logGas(await ctx.DropsV2.methods.setFixedAmountInfo(tokenList), ctx.sendParam(ctx.Deployer), "setFixedAmountInfo");
             var tokenId = await ctx.DropsV2.methods._TOKEN_ID_LIST_(1).call();
             assert(tokenId, '10')
         })
 
+        //TODO:
+        it("withdraw", async () => {
+
+        })
+
     });
 });

test/DODONFT/nftMainFlow.test.ts

@@ -155,12 +155,12 @@ describe("DODONFT", () => {
             var quoteToken = ctx.USDT.options.address;
             var vaultPreOwner = author;
 
-            var dvmParams = [
+            var symbol = "HAHA"
+
+            var params = [
                 "0", //lpFeeRate
                 mweiStr("1"), // I
-                decimalStr("1") // K
+                decimalStr("1"), // K
-            ];
-            var fragParams = [
                 decimalStr("100000000"), //totalSupply
                 decimalStr("0.2"), //ownerRatio
                 Math.floor(new Date().getTime() / 1000 + 60 * 60), //buyoutTimeStamp 1h later
@@ -169,11 +169,10 @@ describe("DODONFT", () => {
 
             var isOpenTwap = false
             var callData = ctx.NFTProxy.methods.createFragment(
-                quoteToken,
+                [quoteToken,vaultPreOwner],
-                vaultPreOwner,
+                params,
-                dvmParams,
+                isOpenTwap,
-                fragParams,
+                symbol
-                isOpenTwap
             ).encodeABI();
             console.log("data:", callData);
 

test/utils/DropsContext.ts

@@ -93,8 +93,8 @@ export class DropsContext {
             contracts.DROPS_V2
         );
 
-        await this.DropsERC721.methods.addMintAccount(this.DropsProxy.options.address).send(this.sendParam(this.Deployer));
+        await this.DropsERC721.methods.addMintAccount(this.DropsV2.options.address).send(this.sendParam(this.Deployer));
-        await this.DropsERC1155.methods.addMintAccount(this.DropsProxy.options.address).send(this.sendParam(this.Deployer));
+        await this.DropsERC1155.methods.addMintAccount(this.DropsV2.options.address).send(this.sendParam(this.Deployer));
 
         await this.DODOApprove.methods.init(this.Deployer, this.DODOApproveProxy.options.address).send(this.sendParam(this.Deployer));
         await this.DODOApproveProxy.methods.init(this.Deployer, [this.DropsProxy.options.address]).send(this.sendParam(this.Deployer));

test/utils/NFTContext.ts

@@ -185,20 +185,28 @@ export class NFTContext {
         var nftVaultInstance = contracts.getContractWithAddress(contracts.NFT_VAULT, vaultAddress);
         var erc721Instance = contracts.getContractWithAddress(contracts.ERC721, erc721Address);
         await erc721Instance.methods.safeTransferFrom(author, vaultAddress,0).send(ctx.sendParam(author));
+        var params = []
         if (dvmParams == null) {
-            dvmParams = [
+            params.push("0")
-                "0", //lpFeeRate
+            params.push(mweiStr("1"))
-                mweiStr("1"), // I
+            params.push(decimalStr("1"))
-                decimalStr("1") // K
+        } else {
-            ];
+            params.push(dvmParams[0])
+            params.push(dvmParams[1])
+            params.push(dvmParams[2])
         }
         if (fragParams == null) {
-            fragParams = [
+            params.push(decimalStr("100000000"))
-                decimalStr("100000000"), //totalSupply
+            params.push(decimalStr("0.2"))
-                decimalStr("0.2"), //ownerRatio
+            params.push(Math.floor(new Date().getTime() / 1000 + 60 * 60))
-                Math.floor(new Date().getTime() / 1000 + 60 * 60) //buyoutTimeStamp 1h later
+            params.push(decimalStr("0"))
-            ]
+        } else {
+            params.push(fragParams[0])
+            params.push(fragParams[1])
+            params.push(fragParams[2])
+            params.push(fragParams[3])
         }
+
         if (addrs == null) {
             addrs = []
             addrs.push(ctx.USDT.options.address);//quoteToken
@@ -206,11 +214,10 @@ export class NFTContext {
         }
 
         var callData = ctx.NFTProxy.methods.createFragment(
-            addrs[0],
+            addrs,
-            addrs[1],
+            params,
-            dvmParams,
+            false,
-            fragParams,
+            "HAHA"
-            false
         ).encodeABI();
 
         await nftVaultInstance.methods.createFragment(