test: airdrop of BB

hardhat.config.ts

@@ -6,6 +6,7 @@ import './tasks/cancelProposal'
 import './tasks/withdrawTreasury'
 import './tasks/airdrop'
 import './tasks/stRifUpgradeV1-v2'
+import './tasks/ownerships'
 
 dotent.config()
 

ignition/modules/BetaBuildersModule.ts

@@ -4,7 +4,7 @@ export const betaBuildersModule = buildModule('BetaBuilders', m => {
   // deploy implementation
   const implementation = m.contract('BetaBuildersRootstockCollective', [], { id: 'Implementation' })
 
-  const deployer = m.getAccount(0)
+  const deployer = m.getParameter('deployer')
   // deploy proxy
   const proxy = m.contract('ERC1967Proxy', [
     implementation,

params/BetaBuildersModule/params.json

@@ -0,0 +1,27 @@
+{
+  "BetaBuilders": {
+    "deployer": "0x0C48e53E5852780Cb0a5Bf168eb92DE3B88Ebe89",
+    "receivers": [
+      {
+        "receiver": "0x0C48e53E5852780Cb0a5Bf168eb92DE3B88Ebe89",
+        "ipfsCid": "bafybeiabgvm3zylkuj24ukfa4aimh3g3nryivhuqr6ztczjlbhqbt3flvm/1.json"
+      },
+      {
+        "receiver": "0x81DF35317dF983E419630908eF6Cb2Bb48CE21Ca",
+        "ipfsCid": "bafybeiabgvm3zylkuj24ukfa4aimh3g3nryivhuqr6ztczjlbhqbt3flvm/2.json"
+      },
+      {
+        "receiver": "0x55A6AA81f8f89e1C14482CE3a6Fb40bAB57971B5",
+        "ipfsCid": "bafybeiabgvm3zylkuj24ukfa4aimh3g3nryivhuqr6ztczjlbhqbt3flvm/3.json"
+      },
+      {
+        "receiver": "0x61cB47ea86430e40Ac1128eA4BC28dEAB66554D5",
+        "ipfsCid": "bafybeiabgvm3zylkuj24ukfa4aimh3g3nryivhuqr6ztczjlbhqbt3flvm/4.json"
+      },
+      {
+        "receiver": "0x9965507D1a55bcC2695C58ba16FB37d819B0A4dc",
+        "ipfsCid": "bafybeiabgvm3zylkuj24ukfa4aimh3g3nryivhuqr6ztczjlbhqbt3flvm/5.json"
+      }
+    ]
+  }
+}

tasks/addresses.json

@@ -0,0 +1,9 @@
+{
+  "addresses": [
+    "0x0C48e53E5852780Cb0a5Bf168eb92DE3B88Ebe89",
+    "0x81DF35317dF983E419630908eF6Cb2Bb48CE21Ca",
+    "0x55A6AA81f8f89e1C14482CE3a6Fb40bAB57971B5",
+    "0x61cB47ea86430e40Ac1128eA4BC28dEAB66554D5",
+    "0x9965507D1a55bcC2695C58ba16FB37d819B0A4dc"
+  ]
+}

tasks/airdrop.ts

@@ -24,16 +24,18 @@ async function airdrop(hre: HardhatRuntimeEnvironment, nftAddress: string, recei
 
 interface Parameters {
   nft: string
-  receivers: string
+  airdropped: string
 }
 
 task('airdrop', 'Execute NFT airdrop')
   .addParam('nft', 'NFT smart contract address')
-  .addParam('receivers', 'JSON file with a list of token receiver addresses and corresponding IPFS CIDs')
-  .setAction(async ({ nft, receivers }: Parameters, hre) => {
+  .addParam('airdropped', 'JSON file with a list of token receiver addresses and corresponding IPFS CIDs')
+  .setAction(async ({ nft, airdropped }: Parameters, hre) => {
     try {
-      const airdropReceivers: AirdropRecipient[] = await fs.readJson(receivers)
-      airdrop(hre, nft, airdropReceivers)
+      const {
+        BetaBuilders: { receivers },
+      }: { BetaBuilders: { receivers: AirdropRecipient[] } } = await fs.readJson(airdropped)
+      await airdrop(hre, nft, receivers)
       console.log('Airdrop was executed')
     } catch (error) {
       console.log(error instanceof Error ? error.message : error)

tasks/ownerships.ts

@@ -0,0 +1,42 @@
+import { task } from 'hardhat/config'
+import fs from 'fs-extra'
+import { BetaBuildersRootstockCollective } from '../typechain-types'
+
+// BetaBuilders#Implementation - 0x3D584161A15CE982eE339cbC28ebb0e1E535A7D3
+// BetaBuilders#ERC1967Proxy - 0xc9B3346a3f151090130b63A28D35875F3C2d6a4d
+// BetaBuilders#Contract - 0xc9B3346a3f151090130b63A28D35875F3C2d6a4d
+
+interface Parameters {
+  addresses: string
+}
+
+async function checkCorrectOwnerships(contract: BetaBuildersRootstockCollective, addresses: string[]) {
+  return await Promise.all(
+    addresses.map(async (addr, i) => {
+      return addr === (await contract.ownerOf(i + 1))
+    }),
+  )
+}
+
+task('ownerships', 'It will check ownerships of airdropped NFTs')
+  .addParam('addresses', 'Path to JSON file with addresses')
+  .setAction(async ({ addresses }: Parameters, hre) => {
+    try {
+      const contract = await hre.ethers.getContractAt(
+        'BetaBuildersRootstockCollective',
+        '0xc9B3346a3f151090130b63A28D35875F3C2d6a4d',
+      )
+
+      const totalSupply = await contract.totalSupply()
+
+      console.log('totalSupply', totalSupply)
+
+      const checkAddresses: { addresses: string[] } = await fs.readJson(addresses)
+      console.log('checkAddresses', checkAddresses)
+      const areTheyOwners = await checkCorrectOwnerships(contract, checkAddresses.addresses)
+
+      console.log('Ownership results:', areTheyOwners)
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : error)
+    }
+  })

test/BetaBuilders.test.ts

@@ -3,7 +3,8 @@ import hre, { ethers, ignition } from 'hardhat'
 import { BetaBuildersRootstockCollective } from '../typechain-types'
 import { SignerWithAddress } from '@nomicfoundation/hardhat-ethers/signers'
 import { betaBuildersModule } from '../ignition/modules/BetaBuildersModule'
-import airdropReceivers from '../params/BetaBuildersModule/airdrop-testnet.json'
+import { BetaBuilders } from '../params/BetaBuildersModule/params.json'
+import { setBalance } from '@nomicfoundation/hardhat-network-helpers'
 
 describe('BetaBuildersRootstockCollective NFT', () => {
   let deployer: SignerWithAddress
@@ -13,15 +14,23 @@ describe('BetaBuildersRootstockCollective NFT', () => {
 
   before(async () => {
     ;[deployer, alice] = await ethers.getSigners()
-    const contract = await ignition.deploy(betaBuildersModule)
+    const contract = await ignition.deploy(betaBuildersModule, {
+      parameters: {
+        BetaBuilders: {
+          deployer: deployer.address,
+        },
+      },
+    })
     betaBuildersEP = contract.ExtBetaBuildersEP as unknown as BetaBuildersRootstockCollective
     // impersonating airdrop receivers
-    for (let i = 0; i < airdropReceivers.length; i++) {
-      const accountAddr = airdropReceivers[i].receiver
+    for (let i = 0; i < BetaBuilders.receivers.length; i++) {
+      const accountAddr = BetaBuilders.receivers[i].receiver
       await hre.network.provider.request({
         method: 'hardhat_impersonateAccount',
         params: [accountAddr],
       })
+
+      await setBalance(accountAddr, ethers.parseEther('2'))
       const account = await ethers.getSigner(accountAddr)
       oldGangsters.push(account)
     }
@@ -44,9 +53,9 @@ describe('BetaBuildersRootstockCollective NFT', () => {
 
   describe('Airdrop', () => {
     it('should execute the initial airdrop after deployment', async () => {
-      await expect(betaBuildersEP.connect(deployer).airdrop(airdropReceivers))
+      await expect(betaBuildersEP.connect(deployer).airdrop(BetaBuilders.receivers))
         .to.emit(betaBuildersEP, 'AirdropExecuted')
-        .withArgs(airdropReceivers.length)
+        .withArgs(BetaBuilders.receivers.length)
     })
     it('the Gangsters should own NFTs after the airdrop', async () => {
       await Promise.all(
@@ -58,26 +67,26 @@ describe('BetaBuildersRootstockCollective NFT', () => {
       )
     })
     it('should top up total supply after the airdrop', async () => {
-      expect(await betaBuildersEP.totalSupply()).to.equal(airdropReceivers.length)
+      expect(await betaBuildersEP.totalSupply()).to.equal(BetaBuilders.receivers.length)
     })
     it('non-owner cannot execute airdrop', async () => {
-      await expect(betaBuildersEP.connect(alice).airdrop(airdropReceivers))
+      await expect(betaBuildersEP.connect(alice).airdrop(BetaBuilders.receivers))
         .to.be.revertedWithCustomError(betaBuildersEP, 'OwnableUnauthorizedAccount')
         .withArgs(alice.address)
     })
     it('should execute the second airdrop to the same addresses', async () => {
-      await expect(betaBuildersEP.connect(deployer).airdrop(airdropReceivers))
+      await expect(betaBuildersEP.connect(deployer).airdrop(BetaBuilders.receivers))
         .to.emit(betaBuildersEP, 'AirdropExecuted')
-        .withArgs(airdropReceivers.length)
+        .withArgs(BetaBuilders.receivers.length)
     })
     it('the Gangsters should own 2 NFTs after the second airdrop', async () => {
       await Promise.all(
         oldGangsters.map(async (gangster, i) => {
-          const tokenId = airdropReceivers.length + i + 1
+          const tokenId = BetaBuilders.receivers.length + i + 1
           expect(await betaBuildersEP.balanceOf(gangster.address)).to.equal(2)
           // token IDs: 6, 7, 8...
           expect(await betaBuildersEP.tokenOfOwnerByIndex(gangster.address, 1)).to.equal(tokenId)
-          const cid = airdropReceivers[i].ipfsCid
+          const cid = BetaBuilders.receivers[i].ipfsCid
           expect(await betaBuildersEP.tokenURI(tokenId)).to.equal(`ipfs://${cid}`)
         }),
       )