From 96e033fd9b70f0338ad683c41182b4ac5649f67b Mon Sep 17 00:00:00 2001 From: Yaroslav Bolyukin Date: Fri, 16 Sep 2022 15:48:55 +0000 Subject: [PATCH] Merge remote-tracking branch 'origin/develop' into feature/multi-assets-redone --- --- a/.docker/Dockerfile-chain-dev +++ b/.docker/Dockerfile-chain-dev @@ -1,17 +1,19 @@ FROM ubuntu:20.04 +ARG RUST_TOOLCHAIN= +ARG FEATURE= + ENV DEBIAN_FRONTEND=noninteractive ENV TZ=Etc/UTC - -RUN apt-get update && apt-get install -y git curl libssl-dev llvm pkg-config libclang-dev clang git make cmake - +ENV FEATURE=$FEATURE ENV CARGO_HOME="/cargo-home" ENV PATH="/cargo-home/bin:$PATH" -RUN curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain none +RUN echo "$FEATURE\n" && echo "$RUST_TOOLCHAIN\n" -ARG RUST_TOOLCHAIN= -ARG FEATURE= +RUN apt-get update && apt-get install -y git curl libssl-dev llvm pkg-config libclang-dev clang git make cmake + +RUN curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain none RUN rustup toolchain uninstall $(rustup toolchain list) && \ rustup toolchain install $RUST_TOOLCHAIN && \ @@ -24,5 +26,6 @@ WORKDIR /dev_chain RUN cargo build --release +RUN echo "$FEATURE" CMD cargo run --release --features=$FEATURE -- --dev -linfo --unsafe-ws-external --rpc-cors=all --unsafe-rpc-external --- a/.docker/docker-compose.tmp-dev.j2 +++ b/.docker/docker-compose.tmp-dev.j2 @@ -18,4 +18,4 @@ options: max-size: "1m" max-file: "3" - command: cargo run --release --features=$FEATURE -- --dev -linfo --unsafe-ws-external --rpc-cors=all --unsafe-rpc-external + command: cargo run --release --features={{ FEATURE }} -- --dev -linfo --unsafe-ws-external --rpc-cors=all --unsafe-rpc-external --- a/.github/workflows/ci-master.yml +++ b/.github/workflows/ci-master.yml @@ -18,16 +18,13 @@ uses: ./.github/workflows/node-only-update_v2.yml forkless: - if: ${{ contains( github.event.pull_request.labels.*.name, 'forkless') }} uses: ./.github/workflows/forkless.yml canary: - if: ${{ contains( github.event.pull_request.labels.*.name, 'canary') }} uses: ./.github/workflows/canary.yml secrets: inherit # pass all secrets xcm: - if: ${{ contains( github.event.pull_request.labels.*.name, 'xcm') }} uses: ./.github/workflows/xcm.yml secrets: inherit # pass all secrets --- a/.github/workflows/dev-build-tests_v2.yml +++ b/.github/workflows/dev-build-tests_v2.yml @@ -95,3 +95,10 @@ - name: Stop running containers if: always() # run this step always run: docker-compose -f ".docker/docker-compose-dev.yaml" -f ".docker/docker-compose.${{ matrix.network }}.yml" down + + - name: Remove builder cache + if: always() # run this step always + run: | + docker builder prune -f -a + docker system prune -f + docker image prune -f -a \ No newline at end of file --- a/.github/workflows/market-test.yml +++ /dev/null @@ -1,227 +0,0 @@ -name: market api tests - -# Controls when the action will run. -on: - # Triggers the workflow on push or pull request events but only for the master branch - pull_request: - branches: - - master - types: - - opened - - reopened - - synchronize #commit(s) pushed to the pull request - - ready_for_review - - # Allows you to run this workflow manually from the Actions tab - workflow_dispatch: - - -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: true - -# A workflow run is made up of one or more jobs that can run sequentially or in parallel -jobs: - - market_test: - # The type of runner that the job will run on - runs-on: [self-hosted-ci,large] - timeout-minutes: 1380 - - strategy: - matrix: - include: - - network: "opal" - features: "opal-runtime" - - network: "quartz" - features: "quartz-runtime" - - network: "unique" - features: "unique-runtime" - - name: draft job - - continue-on-error: true #Do not stop testing of matrix runs failed. As it decided during PR review - it required 50/50& Let's check it with false. - - - steps: -# - name: Skip if pull request is in Draft - # `if: github.event.pull_request.draft == true` should be kept here, at - # the step level, rather than at the job level. The latter is not - # recommended because when the PR is moved from "Draft" to "Ready to - # review" the workflow will immediately be passing (since it was skipped), - # even though it hasn't actually ran, since it takes a few seconds for - # the workflow to start. This is also disclosed in: - # https://github.community/t/dont-run-actions-on-draft-pull-requests/16817/17 - # That scenario would open an opportunity for the check to be bypassed: - # 1. Get your PR approved - # 2. Move it to Draft - # 3. Push whatever commits you want - # 4. Move it to "Ready for review"; now the workflow is passing (it was - # skipped) and "Check reviews" is also passing (it won't be updated - # until the workflow is finished) -# if: github.event.pull_request.draft == true -# run: exit 1 - - - name: Clean Workspace - uses: AutoModality/action-clean@v1.1.0 - - # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it - - name: Checkout master repo - uses: actions/checkout@master - with: - ref: ${{ github.head_ref }} #Checking out head commit - - - name: Checkout Market e2e tests - uses: actions/checkout@v3 - with: - repository: 'UniqueNetwork/market-e2e-tests' - ssh-key: '${{ secrets.GH_PAT }}' - path: 'qa-tests' - ref: 'QA-65_maxandreev' - - - name: Read .env file - uses: xom9ikk/dotenv@v1.0.2 - - - name: Copy qa-tests/.env.example to qa-tests/.env - working-directory: qa-tests - run: cp .env.docker .env - - - name: Show content of qa-test/.env - working-directory: qa-tests - run: cat .env - - - name: Read qa -test .env file - uses: xom9ikk/dotenv@v1.0.2 - with: - path: qa-tests/ - - - name: Generate ENV related extend file for docker-compose - uses: cuchi/jinja2-action@v1.2.0 - with: - template: qa-tests/.docker/docker-compose.tmp-market.j2 - output_file: qa-tests/.docker/docker-compose.${{ matrix.network }}.yml - variables: | - REPO_URL=${{ github.server_url }}/${{ github.repository }}.git - RUST_TOOLCHAIN=${{ env.RUST_TOOLCHAIN }} - POLKADOT_BUILD_BRANCH=${{ env.POLKADOT_BUILD_BRANCH }} - FEATURE=${{ matrix.features }} - BRANCH=${{ github.head_ref }} - - - - name: Show build configuration - working-directory: qa-tests - run: cat .docker/docker-compose.${{ matrix.network }}.yml - - - name: Start node-parachain - working-directory: qa-tests - run: docker-compose -f ".docker/docker-compose.market.yml" -f ".docker/docker-compose.${{ matrix.network }}.yml" up -d --build --remove-orphans --force-recreate node-parachain - - - name: Start nonce-app - working-directory: qa-tests - run: docker-compose -f ".docker/docker-compose.market.yml" up -d --build --remove-orphans --force-recreate nonce-app - - - uses: actions/setup-node@v3 - with: - node-version: 16 - - - name: Setup TypeScript - working-directory: qa-tests - run: | - npm install - npm install -g ts-node - - - name: Copy qa-tests/.env.example to qa-tests/.env - working-directory: qa-tests - run: | - rm -rf .env - cp .env.example .env - - - - name: Show content of qa-test/.env - working-directory: qa-tests - run: cat .env - - - - name: Read qa -test .env file - uses: xom9ikk/dotenv@v1.0.2 - with: - path: qa-tests/ - - - name: Generate accounts - working-directory: qa-tests - run: ts-node ./src/scripts/create-market-accounts.ts - - - name: Deploy contracts - run: | - cd qa-tests - ts-node ./src/scripts/deploy-contract.ts - - - name: Import test data - working-directory: qa-tests - run: ts-node ./src/scripts/create-test-collections.ts - - - name: Show content of qa-test .env - working-directory: qa-tests - run: cat .env - - - name: Copy qa-tests/.env.example to qa-tests/.env - working-directory: qa-tests - run: | - rm -rf .env.docker - cp .env .env.docker - sed -i '/UNIQUE_WS_ENDPOINT/c UNIQUE_WS_ENDPOINT=ws://node-parachain:9944' .env.docker - - - name: Read qa -test .env file - uses: xom9ikk/dotenv@v1.0.2 - with: - path: qa-tests/ - - - name: local-market:start - run: docker-compose -f "qa-tests/.docker/docker-compose.market.yml" -f "qa-tests/.docker/docker-compose.${{ matrix.network }}.yml" up -d --build - - - name: Wait for market readyness - working-directory: qa-tests - run: src/scripts/wait-market-ready.sh - shell: bash - - - name: Install dependecies - working-directory: qa-tests - run: | - npm ci - npm install -D @playwright/test - npx playwright install-deps - npx playwright install - - - name: - working-directory: qa-tests - run: | - npx playwright test --workers=8 --quiet .*.api.test.ts --reporter=github --config playwright.config.ts - - - name: Show env variables - if: success() || failure() - run: printenv - - - name: look up for report - if: success() || failure() - run: | - ls -la - ls -la qa-tests/ - - - - name: Stop running containers - if: always() # run this step always - run: docker-compose -f "qa-tests/.docker/docker-compose.market.yml" -f "qa-tests/.docker/docker-compose.${{ matrix.network }}.yml" down --volumes - - - name: Remove builder cache - if: always() # run this step always - run: | - docker builder prune -f - docker system prune -f - - - name: Clean Workspace - if: always() - uses: AutoModality/action-clean@v1.1.0 - - - - --- a/.github/workflows/market-test_v2.yml +++ b/.github/workflows/market-test_v2.yml @@ -45,7 +45,7 @@ repository: 'UniqueNetwork/market-e2e-tests' ssh-key: ${{ secrets.GH_PAT }} path: 'qa-tests' - ref: 'ci_test_v2' + ref: 'master' - name: Read .env file uses: xom9ikk/dotenv@v1.0.2 --- a/.github/workflows/node-only-update_v2.yml +++ b/.github/workflows/node-only-update_v2.yml @@ -10,7 +10,7 @@ # A workflow run is made up of one or more jobs that can run sequentially or in parallel jobs: - execution-marix: + nodes-execution-matrix: name: execution matrix @@ -42,8 +42,8 @@ - forkless-update-nodata: - needs: execution-marix + nodes-only-update: + needs: nodes-execution-matrix # The type of runner that the job will run on runs-on: [self-hosted-ci,large] @@ -57,7 +57,7 @@ strategy: matrix: - include: ${{fromJson(needs.prepare-execution-marix.outputs.matrix)}} + include: ${{fromJson(needs.nodes-execution-matrix.outputs.matrix)}} steps: @@ -156,12 +156,18 @@ exit 0 shell: bash + - name: Checkout at '${{ matrix.mainnet_branch }}' branch + uses: actions/checkout@master + with: + ref: ${{ matrix.mainnet_branch }} #Checking out head commit + path: ${{ matrix.mainnet_branch }} + + - name: Run tests before Node Parachain upgrade - working-directory: tests + working-directory: ${{ matrix.mainnet_branch }}/tests run: | yarn install yarn add mochawesome - node scripts/readyness.js echo "Ready to start tests" yarn polkadot-types NOW=$(date +%s) && yarn test --reporter mochawesome --reporter-options reportFilename=test-${NOW} @@ -174,7 +180,7 @@ if: success() || failure() # run this step even if previous step failed with: name: Tests before node upgrade ${{ matrix.network }} # Name of the check run which will be created - path: tests/mochawesome-report/test-*.json # Path to test results + path: ${{ matrix.mainnet_branch }}/tests/mochawesome-report/test-*.json # Path to test results reporter: mochawesome-json fail-on-error: 'false' @@ -263,8 +269,9 @@ - name: Remove builder cache if: always() # run this step always run: | - docker builder prune -f + docker builder prune -f -a docker system prune -f + docker image prune -f -a - name: Clean Workspace if: always() --- a/pallets/app-promotion/Cargo.toml +++ b/pallets/app-promotion/Cargo.toml @@ -68,4 +68,6 @@ pallet-evm-contract-helpers ={ default-features = false, path = "../evm-contract-helpers" } pallet-evm-migration ={ default-features = false, path = "../evm-migration" } +# [dev-dependencies] + ################################################################################ --- a/pallets/app-promotion/src/lib.rs +++ b/pallets/app-promotion/src/lib.rs @@ -594,14 +594,14 @@ last_id, *income_acc.borrow(), ExistenceRequirement::KeepAlive, - ) - .and_then(|_| { - Self::add_lock_balance(last_id, *income_acc.borrow())?; - >::try_mutate(|staked| { - staked - .checked_add(&*income_acc.borrow()) - .ok_or(ArithmeticError::Overflow.into()) - }) + )?; + + Self::add_lock_balance(last_id, *income_acc.borrow())?; + >::try_mutate(|staked| -> DispatchResult { + *staked = staked + .checked_add(&*income_acc.borrow()) + .ok_or(ArithmeticError::Overflow)?; + Ok(()) })?; Self::deposit_event(Event::StakingRecalculation( --- a/runtime/common/mod.rs +++ b/runtime/common/mod.rs @@ -82,7 +82,7 @@ pub type SignedExtra = ( frame_system::CheckSpecVersion, - // system::CheckTxVersion, + frame_system::CheckTxVersion, frame_system::CheckGenesis, frame_system::CheckEra, frame_system::CheckNonce, --- a/runtime/opal/src/lib.rs +++ b/runtime/opal/src/lib.rs @@ -50,7 +50,7 @@ spec_name: create_runtime_str!(RUNTIME_NAME), impl_name: create_runtime_str!(RUNTIME_NAME), authoring_version: 1, - spec_version: 927020, + spec_version: 927030, impl_version: 0, apis: RUNTIME_API_VERSIONS, transaction_version: 2, --- a/runtime/quartz/src/lib.rs +++ b/runtime/quartz/src/lib.rs @@ -50,7 +50,7 @@ spec_name: create_runtime_str!(RUNTIME_NAME), impl_name: create_runtime_str!(RUNTIME_NAME), authoring_version: 1, - spec_version: 927020, + spec_version: 927030, impl_version: 0, apis: RUNTIME_API_VERSIONS, transaction_version: 2, --- a/runtime/unique/src/lib.rs +++ b/runtime/unique/src/lib.rs @@ -50,7 +50,7 @@ spec_name: create_runtime_str!(RUNTIME_NAME), impl_name: create_runtime_str!(RUNTIME_NAME), authoring_version: 1, - spec_version: 927020, + spec_version: 927030, impl_version: 0, apis: RUNTIME_API_VERSIONS, transaction_version: 2, --- a/tests/src/adminTransferAndBurn.test.ts +++ b/tests/src/adminTransferAndBurn.test.ts @@ -24,19 +24,14 @@ let donor: IKeyringPair; -before(async () => { - await usingPlaygrounds(async (_, privateKey) => { - donor = privateKey('//Alice'); - }); -}); - describe('Integration Test: ownerCanTransfer allows admins to use only transferFrom/burnFrom:', () => { let alice: IKeyringPair; let bob: IKeyringPair; let charlie: IKeyringPair; before(async () => { - await usingPlaygrounds(async (helper) => { + await usingPlaygrounds(async (helper, privateKey) => { + donor = privateKey('//Alice'); [alice, bob, charlie] = await helper.arrange.createAccounts([10n, 10n, 10n], donor); }); }); --- a/tests/src/allowLists.test.ts +++ b/tests/src/allowLists.test.ts @@ -24,12 +24,6 @@ let donor: IKeyringPair; -before(async () => { - await usingPlaygrounds(async (_, privateKey) => { - donor = privateKey('//Alice'); - }); -}); - let alice: IKeyringPair; let bob: IKeyringPair; let charlie: IKeyringPair; @@ -37,7 +31,8 @@ describe('Integration Test ext. Allow list tests', () => { before(async () => { - await usingPlaygrounds(async (helper) => { + await usingPlaygrounds(async (helper, privateKey) => { + donor = privateKey('//Alice'); [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor); }); }); --- a/tests/src/app-promotion.test.ts +++ b/tests/src/app-promotion.test.ts @@ -20,17 +20,12 @@ getModuleNames, Pallets, } from './util/helpers'; - -import chai from 'chai'; -import chaiAsPromised from 'chai-as-promised'; -import {usingPlaygrounds} from './util/playgrounds'; - +import {itSub, usingPlaygrounds} from './util/playgrounds'; import {encodeAddress} from '@polkadot/util-crypto'; import {stringToU8a} from '@polkadot/util'; -import {SponsoringMode, contractHelpers, createEthAccountWithBalance, deployFlipper, itWeb3, transferBalanceToEth} from './eth/util/helpers'; +import {SponsoringMode} from './eth/util/helpers'; import {DevUniqueHelper} from './util/playgrounds/unique.dev'; -chai.use(chaiAsPromised); -const expect = chai.expect; +import {itEth, expect} from './eth/util/playgrounds'; let alice: IKeyringPair; let palletAdmin: IKeyringPair; @@ -38,723 +33,652 @@ const palletAddress = calculatePalleteAddress('appstake'); let accounts: IKeyringPair[] = []; const LOCKING_PERIOD = 20n; // 20 blocks of relay -const UNLOCKING_PERIOD = 10n; // 20 blocks of parachain +const UNLOCKING_PERIOD = 10n; // 10 blocks of parachain const rewardAvailableInBlock = (stakedInBlock: bigint) => (stakedInBlock - stakedInBlock % LOCKING_PERIOD) + (LOCKING_PERIOD * 2n); -const beforeEach = async (context: Mocha.Context) => { - await usingPlaygrounds(async (helper, privateKey) => { - if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) context.skip(); - alice = privateKey('//Alice'); - palletAdmin = privateKey('//Charlie'); // TODO use custom address - await helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address}))); - nominal = helper.balance.getOneTokenNominal(); - await helper.balance.transferToSubstrate(alice, palletAdmin.address, 1000n * nominal); - await helper.balance.transferToSubstrate(alice, palletAddress, 1000n * nominal); - accounts = await helper.arrange.createCrowd(100, 1000n, alice); // create accounts-pool to speed up tests - }); -}; - -describe('app-promotions.stake extrinsic', () => { +describe('App promotion', () => { before(async function () { - await beforeEach(this); + await usingPlaygrounds(async (helper, privateKey) => { + if (!getModuleNames(helper.api!).includes(Pallets.AppPromotion)) this.skip(); + alice = privateKey('//Alice'); + palletAdmin = privateKey('//Charlie'); // TODO use custom address + await helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address}))); + nominal = helper.balance.getOneTokenNominal(); + await helper.balance.transferToSubstrate(alice, palletAdmin.address, 1000n * nominal); + await helper.balance.transferToSubstrate(alice, palletAddress, 1000n * nominal); + accounts = await helper.arrange.createCrowd(100, 1000n, alice); // create accounts-pool to speed up tests + }); }); - it('should "lock" staking balance, add it to "staked" map, and increase "totalStaked" amount', async () => { - await usingPlaygrounds(async (helper) => { + describe('stake extrinsic', () => { + itSub('should "lock" staking balance, add it to "staked" map, and increase "totalStaked" amount', async ({helper}) => { const [staker, recepient] = [accounts.pop()!, accounts.pop()!]; const totalStakedBefore = await helper.staking.getTotalStaked(); - + // Minimum stake amount is 100: - await expect(helper.staking.stake(staker, 100n * nominal - 1n)).to.be.eventually.rejected; + await expect(helper.staking.stake(staker, 100n * nominal - 1n)).to.be.rejected; await helper.staking.stake(staker, 100n * nominal); - + // Staker balance is: miscFrozen: 100, feeFrozen: 100, reserved: 0n... // ...so he can not transfer 900 expect (await helper.balance.getSubstrateFull(staker.address)).to.contain({miscFrozen: 100n * nominal, feeFrozen: 100n * nominal, reserved: 0n}); - await expect(helper.balance.transferToSubstrate(staker, recepient.address, 900n * nominal)).to.be.rejected; + await expect(helper.balance.transferToSubstrate(staker, recepient.address, 900n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions'); expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(100n * nominal); expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n); // it is potentially flaky test. Promotion can credited some tokens. Maybe we need to use closeTo? expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore + 100n * nominal); // total tokens amount staked in app-promotion increased - + await helper.staking.stake(staker, 200n * nominal); expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(300n * nominal); - expect((await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map((x) => x[1])).to.be.deep.equal([100n * nominal, 200n * nominal]); + const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}); + expect(totalStakedPerBlock[0].amount).to.equal(100n * nominal); + expect(totalStakedPerBlock[1].amount).to.equal(200n * nominal); }); - }); - - it('should allow to create maximum 10 stakes for account', async () => { - await usingPlaygrounds(async (helper) => { + + itSub('should allow to create maximum 10 stakes for account', async ({helper}) => { const [staker] = await helper.arrange.createAccounts([2000n], alice); for (let i = 0; i < 10; i++) { await helper.staking.stake(staker, 100n * nominal); } - + // can have 10 stakes expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(1000n * nominal); expect(await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).to.have.length(10); - - await expect(helper.staking.stake(staker, 100n * nominal)).to.be.rejected; - + + await expect(helper.staking.stake(staker, 100n * nominal)).to.be.rejectedWith('appPromotion.NoPermission'); + // After unstake can stake again await helper.staking.unstake(staker); await helper.staking.stake(staker, 100n * nominal); expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.equal(100n * nominal); }); - }); + + itSub('should reject transaction if stake amount is more than total free balance minus frozen', async ({helper}) => { + const staker = accounts.pop()!; - it('should reject transaction if stake amount is more than total free balance minus frozen', async () => { - await usingPlaygrounds(async helper => { - const staker = accounts.pop()!; - // Can't stake full balance because Alice needs to pay some fee - await expect(helper.staking.stake(staker, 1000n * nominal)).to.be.eventually.rejected; + await expect(helper.staking.stake(staker, 1000n * nominal)).to.be.rejected; await helper.staking.stake(staker, 500n * nominal); - + // Can't stake 500 tkn because Alice has Less than 500 transferable; - await expect(helper.staking.stake(staker, 500n * nominal)).to.be.eventually.rejected; + await expect(helper.staking.stake(staker, 500n * nominal)).to.be.rejectedWith('balances.LiquidityRestrictions'); expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(500n * nominal); }); - }); - - it('for different accounts in one block is possible', async () => { - await usingPlaygrounds(async helper => { + + itSub('for different accounts in one block is possible', async ({helper}) => { const crowd = [accounts.pop()!, accounts.pop()!, accounts.pop()!, accounts.pop()!]; - + const crowdStartsToStake = crowd.map(user => helper.staking.stake(user, 100n * nominal)); - await expect(Promise.all(crowdStartsToStake)).to.be.eventually.fulfilled; - + await expect(Promise.all(crowdStartsToStake)).to.be.fulfilled; + const crowdStakes = await Promise.all(crowd.map(address => helper.staking.getTotalStaked({Substrate: address.address}))); expect(crowdStakes).to.deep.equal([100n * nominal, 100n * nominal, 100n * nominal, 100n * nominal]); }); }); -}); - -describe('unstake balance extrinsic', () => { - before(async function () { - await beforeEach(this); - }); - - it('should change balance state from "frozen" to "reserved", add it to "pendingUnstake" map, and subtract it from totalStaked', async () => { - await usingPlaygrounds(async helper => { + + describe('unstake extrinsic', () => { + itSub('should change balance state from "frozen" to "reserved", add it to "pendingUnstake" map, and subtract it from totalStaked', async ({helper}) => { const [staker, recepient] = [accounts.pop()!, accounts.pop()!]; const totalStakedBefore = await helper.staking.getTotalStaked(); await helper.staking.stake(staker, 900n * nominal); await helper.staking.unstake(staker); - + // Right after unstake balance is reserved // Staker can not transfer expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 900n * nominal, miscFrozen: 0n, feeFrozen: 0n}); - await expect(helper.balance.transferToSubstrate(staker, recepient.address, 100n * nominal)).to.be.rejected; + await expect(helper.balance.transferToSubstrate(staker, recepient.address, 100n * nominal)).to.be.rejectedWith('balances.InsufficientBalance'); expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(900n * nominal); expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n); expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedBefore); }); - }); - - it('should unlock balance after unlocking period ends and remove it from "pendingUnstake"', async () => { - await usingPlaygrounds(async (helper) => { + + itSub('should unlock balance after unlocking period ends and remove it from "pendingUnstake"', async ({helper}) => { const staker = accounts.pop()!; await helper.staking.stake(staker, 100n * nominal); await helper.staking.unstake(staker); - const unstakedInBlock = (await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address}))[0][0]; - + const [pendingUnstake] = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address}); + // Wait for unstaking period. Balance now free ~1000; reserved, frozen, miscFrozeb: 0n - await helper.wait.forParachainBlockNumber(unstakedInBlock); + await helper.wait.forParachainBlockNumber(pendingUnstake.block); expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, miscFrozen: 0n, feeFrozen: 0n}); expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n); - + // staker can transfer: await helper.balance.transferToSubstrate(staker, alice.address, 998n * nominal); expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(1n); }); - }); - - it('should successfully unstake multiple stakes', async () => { - await usingPlaygrounds(async helper => { + + itSub('should successfully unstake multiple stakes', async ({helper}) => { const staker = accounts.pop()!; await helper.staking.stake(staker, 100n * nominal); await helper.staking.stake(staker, 200n * nominal); await helper.staking.stake(staker, 300n * nominal); - + // staked: [100, 200, 300]; unstaked: 0 - let pendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address}); - let unstakedPerBlock = (await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address})).map(stake => stake[1]); - let stakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(stake => stake[1]); - expect(pendingUnstake).to.be.deep.equal(0n); - expect(unstakedPerBlock).to.be.deep.equal([]); - expect(stakedPerBlock).to.be.deep.equal([100n * nominal, 200n * nominal, 300n * nominal]); - + let totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address}); + let pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address}); + let stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}); + expect(totalPendingUnstake).to.be.deep.equal(0n); + expect(pendingUnstake).to.be.deep.equal([]); + expect(stakes[0].amount).to.equal(100n * nominal); + expect(stakes[1].amount).to.equal(200n * nominal); + expect(stakes[2].amount).to.equal(300n * nominal); + // Can unstake multiple stakes await helper.staking.unstake(staker); - const unstakingBlock = (await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address}))[0][0]; - pendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address}); - unstakedPerBlock = (await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address})).map(stake => stake[1]); - stakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(stake => stake[1]); - expect(pendingUnstake).to.be.equal(600n * nominal); - expect(stakedPerBlock).to.be.deep.equal([]); - expect(unstakedPerBlock).to.be.deep.equal([600n * nominal]); - + pendingUnstake = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address}); + totalPendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address}); + stakes = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}); + expect(totalPendingUnstake).to.be.equal(600n * nominal); + expect(stakes).to.be.deep.equal([]); + expect(pendingUnstake[0].amount).to.equal(600n * nominal); + expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 600n * nominal, feeFrozen: 0n, miscFrozen: 0n}); - await helper.wait.forParachainBlockNumber(unstakingBlock); + await helper.wait.forParachainBlockNumber(pendingUnstake[0].block); expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, feeFrozen: 0n, miscFrozen: 0n}); expect (await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n); }); - }); - - it('should not have any effects if no active stakes', async () => { - await usingPlaygrounds(async (helper) => { + + itSub('should not have any effects if no active stakes', async ({helper}) => { const staker = accounts.pop()!; - + // unstake has no effect if no stakes at all await helper.staking.unstake(staker); expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(0n); expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n); // TODO bigint closeTo helper - + // TODO stake() unstake() waitUnstaked() unstake(); - + // can't unstake if there are only pendingUnstakes await helper.staking.stake(staker, 100n * nominal); await helper.staking.unstake(staker); await helper.staking.unstake(staker); - + expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal); expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n); }); - }); - - it('should keep different unlocking block for each unlocking stake', async () => { - await usingPlaygrounds(async (helper) => { + + itSub('should keep different unlocking block for each unlocking stake', async ({helper}) => { const staker = accounts.pop()!; await helper.staking.stake(staker, 100n * nominal); await helper.staking.unstake(staker); await helper.staking.stake(staker, 120n * nominal); await helper.staking.unstake(staker); - + const unstakingPerBlock = await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address}); expect(unstakingPerBlock).has.length(2); - expect(unstakingPerBlock[0][1]).to.equal(100n * nominal); - expect(unstakingPerBlock[1][1]).to.equal(120n * nominal); + expect(unstakingPerBlock[0].amount).to.equal(100n * nominal); + expect(unstakingPerBlock[1].amount).to.equal(120n * nominal); }); - }); - - it('should be possible for different accounts in one block', async () => { - await usingPlaygrounds(async (helper) => { + + itSub('should be possible for different accounts in one block', async ({helper}) => { const stakers = [accounts.pop()!, accounts.pop()!, accounts.pop()!]; - + await Promise.all(stakers.map(staker => helper.staking.stake(staker, 100n * nominal))); await Promise.all(stakers.map(staker => helper.staking.unstake(staker))); - + await Promise.all(stakers.map(async (staker) => { expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal); expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n); })); }); }); -}); - -describe('Admin adress', () => { - before(async function () { - await beforeEach(this); - }); - - it('can be set by sudo only', async () => { - await usingPlaygrounds(async (helper) => { + + describe('admin adress', () => { + itSub('can be set by sudo only', async ({helper}) => { const nonAdmin = accounts.pop()!; // nonAdmin can not set admin not from himself nor as a sudo - await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address}))).to.be.eventually.rejected; - await expect(helper.signTransaction(nonAdmin, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address})))).to.be.eventually.rejected; - + await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address}))).to.be.rejected; + await expect(helper.signTransaction(nonAdmin, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: nonAdmin.address})))).to.be.rejected; + // Alice can - await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.eventually.fulfilled; + await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.fulfilled; }); - }); - - it('can be any valid CrossAccountId', async () => { - // We are not going to set an eth address as a sponsor, - // but we do want to check, it doesn't break anything; - await usingPlaygrounds(async (helper) => { + + itSub('can be any valid CrossAccountId', async ({helper}) => { + // We are not going to set an eth address as a sponsor, + // but we do want to check, it doesn't break anything; const account = accounts.pop()!; const ethAccount = helper.address.substrateToEth(account.address); // Alice sets Ethereum address as a sudo. Then Substrate address back... - await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Ethereum: ethAccount})))).to.be.eventually.fulfilled; - await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.eventually.fulfilled; - + await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Ethereum: ethAccount})))).to.be.fulfilled; + await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})))).to.be.fulfilled; + // ...It doesn't break anything; const collection = await helper.nft.mintCollection(account, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'}); - await expect(helper.signTransaction(account, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected; + await expect(helper.signTransaction(account, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected; }); - }); - - it('can be reassigned', async () => { - await usingPlaygrounds(async (helper) => { + + itSub('can be reassigned', async ({helper}) => { const [oldAdmin, newAdmin, collectionOwner] = [accounts.pop()!, accounts.pop()!, accounts.pop()!]; const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'}); - - await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress(normalizeAccountId(oldAdmin))))).to.be.eventually.fulfilled; - await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress(normalizeAccountId(newAdmin))))).to.be.eventually.fulfilled; - await expect(helper.signTransaction(oldAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected; - - await expect(helper.signTransaction(newAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled; + + await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress(normalizeAccountId(oldAdmin))))).to.be.fulfilled; + await expect(helper.signTransaction(alice, helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress(normalizeAccountId(newAdmin))))).to.be.fulfilled; + await expect(helper.signTransaction(oldAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected; + + await expect(helper.signTransaction(newAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.fulfilled; }); }); -}); - -describe('App-promotion collection sponsoring', () => { - before(async function () { - await beforeEach(this); - await usingPlaygrounds(async (helper) => { - const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})); - await helper.signTransaction(alice, tx); + + describe('collection sponsoring', () => { + before(async function () { + await usingPlaygrounds(async (helper) => { + const tx = helper.api!.tx.sudo.sudo(helper.api!.tx.appPromotion.setAdminAddress({Substrate: palletAdmin.address})); + await helper.signTransaction(alice, tx); + }); }); - }); - - it('should actually sponsor transactions', async () => { - await usingPlaygrounds(async (helper) => { + + itSub('should actually sponsor transactions', async ({helper}) => { const [collectionOwner, tokenSender, receiver] = [accounts.pop()!, accounts.pop()!, accounts.pop()!]; const collection = await helper.nft.mintCollection(collectionOwner, {name: 'Name', description: 'Description', tokenPrefix: 'Prefix', limits: {sponsorTransferTimeout: 0}}); const token = await collection.mintToken(collectionOwner, {Substrate: tokenSender.address}); await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId)); const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress); - + await token.transfer(tokenSender, {Substrate: receiver.address}); expect (await token.getOwner()).to.be.deep.equal({Substrate: receiver.address}); const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress); - + // senders balance the same, transaction has sponsored expect (await helper.balance.getSubstrate(tokenSender.address)).to.be.equal(1000n * nominal); expect (palletBalanceBefore > palletBalanceAfter).to.be.true; }); - }); - - it('can not be set by non admin', async () => { - await usingPlaygrounds(async (helper) => { + + itSub('can not be set by non admin', async ({helper}) => { const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!]; - + const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'}); - - await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected; + + await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected; expect((await collection.getData())?.raw.sponsorship).to.equal('Disabled'); }); - }); - - it('should set pallet address as confirmed admin', async () => { - await usingPlaygrounds(async (helper) => { + + itSub('should set pallet address as confirmed admin', async ({helper}) => { const [collectionOwner, oldSponsor] = [accounts.pop()!, accounts.pop()!]; - + // Can set sponsoring for collection without sponsor const collectionWithoutSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'No-sponsor', description: 'New Collection', tokenPrefix: 'Promotion'}); - await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.eventually.fulfilled; + await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithoutSponsor.collectionId))).to.be.fulfilled; expect((await collectionWithoutSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress}); - + // Can set sponsoring for collection with unconfirmed sponsor const collectionWithUnconfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Unconfirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address}); expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: oldSponsor.address}); - await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.eventually.fulfilled; + await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithUnconfirmedSponsor.collectionId))).to.be.fulfilled; expect((await collectionWithUnconfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress}); - + // Can set sponsoring for collection with confirmed sponsor const collectionWithConfirmedSponsor = await helper.nft.mintCollection(collectionOwner, {name: 'Confirmed', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: oldSponsor.address}); await collectionWithConfirmedSponsor.confirmSponsorship(oldSponsor); - await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.eventually.fulfilled; + await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithConfirmedSponsor.collectionId))).to.be.fulfilled; expect((await collectionWithConfirmedSponsor.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress}); }); - }); - - it('can be overwritten by collection owner', async () => { - await usingPlaygrounds(async (helper) => { + + itSub('can be overwritten by collection owner', async ({helper}) => { const [collectionOwner, newSponsor] = [accounts.pop()!, accounts.pop()!]; const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'}); const collectionId = collection.collectionId; - - await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionId))).to.be.eventually.fulfilled; - + + await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionId))).to.be.fulfilled; + // Collection limits still can be changed by the owner expect(await collection.setLimits(collectionOwner, {sponsorTransferTimeout: 0})).to.be.true; expect((await collection.getData())?.raw.limits.sponsorTransferTimeout).to.be.equal(0); expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress}); - + // Collection sponsor can be changed too expect((await collection.setSponsor(collectionOwner, newSponsor.address))).to.be.true; expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Unconfirmed: newSponsor.address}); }); - }); - - it('should not overwrite collection limits set by the owner earlier', async () => { - await usingPlaygrounds(async (helper) => { + + itSub('should not overwrite collection limits set by the owner earlier', async ({helper}) => { const limits = {ownerCanDestroy: true, ownerCanTransfer: true, sponsorTransferTimeout: 0}; const collectionWithLimits = await helper.nft.mintCollection(alice, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits}); - - await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.eventually.fulfilled; + + await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collectionWithLimits.collectionId))).to.be.fulfilled; expect((await collectionWithLimits.getData())?.raw.limits).to.be.deep.contain(limits); }); - }); - - it('should reject transaction if collection doesn\'t exist', async () => { - await usingPlaygrounds(async (helper) => { + + itSub('should reject transaction if collection doesn\'t exist', async ({helper}) => { const collectionOwner = accounts.pop()!; - + // collection has never existed - await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(999999999))).to.be.eventually.rejected; + await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(999999999))).to.be.rejected; // collection has been burned const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'}); await collection.burn(collectionOwner); - - await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.rejected; + + await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.rejected; }); }); -}); - -describe('app-promotion stopSponsoringCollection', () => { - before(async function () { - await beforeEach(this); - }); - - it('can not be called by non-admin', async () => { - await usingPlaygrounds(async (helper) => { + + describe('stopSponsoringCollection', () => { + itSub('can not be called by non-admin', async ({helper}) => { const [collectionOwner, nonAdmin] = [accounts.pop()!, accounts.pop()!]; const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'}); - - await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.eventually.fulfilled; - - await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected; + + await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId))).to.be.fulfilled; + + await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected; expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: palletAddress}); }); - }); - - it('should set sponsoring as disabled', async () => { - await usingPlaygrounds(async (helper) => { + + itSub('should set sponsoring as disabled', async ({helper}) => { const [collectionOwner, recepient] = [accounts.pop()!, accounts.pop()!]; const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', limits: {sponsorTransferTimeout: 0}}); const token = await collection.mintToken(collectionOwner, {Substrate: collectionOwner.address}); - + await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorCollection(collection.collectionId)); await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId)); - + expect((await collection.getData())?.raw.sponsorship).to.be.equal('Disabled'); - + // Transactions are not sponsored anymore: const ownerBalanceBefore = await helper.balance.getSubstrate(collectionOwner.address); await token.transfer(collectionOwner, {Substrate: recepient.address}); const ownerBalanceAfter = await helper.balance.getSubstrate(collectionOwner.address); expect(ownerBalanceAfter < ownerBalanceBefore).to.be.equal(true); }); - }); - - it('should not affect collection which is not sponsored by pallete', async () => { - await usingPlaygrounds(async (helper) => { + + itSub('should not affect collection which is not sponsored by pallete', async ({helper}) => { const collectionOwner = accounts.pop()!; const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion', pendingSponsor: collectionOwner.address}); await collection.confirmSponsorship(collectionOwner); - - await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected; - + + await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.rejected; + expect((await collection.getData())?.raw.sponsorship).to.be.deep.equal({Confirmed: collectionOwner.address}); }); - }); - - it('should reject transaction if collection does not exist', async () => { - await usingPlaygrounds(async (helper) => { + + itSub('should reject transaction if collection does not exist', async ({helper}) => { const collectionOwner = accounts.pop()!; const collection = await helper.nft.mintCollection(collectionOwner, {name: 'New', description: 'New Collection', tokenPrefix: 'Promotion'}); - + await collection.burn(collectionOwner); - await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(collection.collectionId))).to.be.eventually.rejected; - await expect(helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.stopSponsoringCollection(999999999))).to.be.eventually.rejected; + await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [collection.collectionId], true)).to.be.rejectedWith('common.CollectionNotFound'); + await expect(helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringCollection', [999_999_999], true)).to.be.rejectedWith('common.CollectionNotFound'); }); }); -}); - -describe('app-promotion contract sponsoring', () => { - before(async function () { - await beforeEach(this); - }); - - itWeb3('should set palletes address as a sponsor', async ({api, web3, privateKeyWrapper}) => { - await usingPlaygrounds(async (helper) => { - const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase(); - const flipper = await deployFlipper(web3, contractOwner); - const contractMethods = contractHelpers(web3, contractOwner); - - await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address)); + + describe('contract sponsoring', () => { + itEth('should set palletes address as a sponsor', async ({helper}) => { + const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase(); + const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner); + const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner); + + await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]); - expect(await contractMethods.methods.hasSponsor(flipper.options.address).call()).to.be.true; - expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner); - expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({ + expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true; + expect((await helper.api!.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner); + expect((await helper.api!.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({ confirmed: { substrate: palletAddress, }, }); }); - }); - - itWeb3('should overwrite sponsoring mode and existed sponsor', async ({api, web3, privateKeyWrapper}) => { - await usingPlaygrounds(async (helper) => { - const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase(); - const flipper = await deployFlipper(web3, contractOwner); - const contractMethods = contractHelpers(web3, contractOwner); - - await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected; - + + itEth('should overwrite sponsoring mode and existed sponsor', async ({helper}) => { + const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase(); + const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner); + const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner); + + await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled; + // Contract is self sponsored - expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.be.deep.equal({ + expect((await helper.api!.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.be.deep.equal({ confirmed: { ethereum: flipper.options.address.toLowerCase(), }, }); - + // set promotion sponsoring - await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address)); - + await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true); + // new sponsor is pallet address - expect(await contractMethods.methods.hasSponsor(flipper.options.address).call()).to.be.true; - expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner); - expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({ + expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true; + expect((await helper.callRpc('api.query.evmContractHelpers.owner', [flipper.options.address])).toJSON()).to.be.equal(contractOwner); + expect((await helper.callRpc('api.query.evmContractHelpers.sponsoring', [flipper.options.address])).toJSON()).to.deep.equal({ confirmed: { substrate: palletAddress, }, }); }); - }); - - itWeb3('can be overwritten by contract owner', async ({api, web3, privateKeyWrapper}) => { - await usingPlaygrounds(async (helper) => { - const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase(); - const flipper = await deployFlipper(web3, contractOwner); - const contractMethods = contractHelpers(web3, contractOwner); - + + itEth('can be overwritten by contract owner', async ({helper}) => { + const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase(); + const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner); + const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner); + // contract sponsored by pallet - await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address)); - + await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true); + // owner sets self sponsoring - await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected; - - expect(await contractMethods.methods.hasSponsor(flipper.options.address).call()).to.be.true; - expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner); - expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({ + await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected; + + expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.true; + expect((await helper.api!.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner); + expect((await helper.api!.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({ confirmed: { ethereum: flipper.options.address.toLowerCase(), }, }); }); - }); - - itWeb3('can not be set by non admin', async ({api, web3, privateKeyWrapper}) => { - await usingPlaygrounds(async (helper) => { + + itEth('can not be set by non admin', async ({helper}) => { const nonAdmin = accounts.pop()!; - const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase(); - const flipper = await deployFlipper(web3, contractOwner); - const contractMethods = contractHelpers(web3, contractOwner); - - await expect(contractMethods.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected; - + const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase(); + const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner); + const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner); + + await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled; + // nonAdmin calls sponsorContract - await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address))).to.be.rejected; - + await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission'); + // contract still self-sponsored - expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({ + expect((await helper.api!.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({ confirmed: { ethereum: flipper.options.address.toLowerCase(), }, }); }); - - itWeb3('should be rejected for non-contract address', async ({api, web3, privateKeyWrapper}) => { - await usingPlaygrounds(async (helper) => { - - }); - }); - }); - - itWeb3('should actually sponsor transactions', async ({api, web3, privateKeyWrapper}) => { - await usingPlaygrounds(async (helper) => { - const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper); - const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase(); - const flipper = await deployFlipper(web3, contractOwner); - const contractHelper = contractHelpers(web3, contractOwner); + + itEth('should actually sponsor transactions', async ({helper}) => { + // Contract caller + const caller = await helper.eth.createAccountWithBalance(alice, 1000n); + const palletBalanceBefore = await helper.balance.getSubstrate(palletAddress); + + // Deploy flipper + const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase(); + const flipper = await helper.eth.deployFlipper(contractOwner); // await deployFlipper(web3, contractOwner); + const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner); + + // Owner sets to sponsor every tx await contractHelper.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: contractOwner}); await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner}); - await transferBalanceToEth(api, alice, flipper.options.address, 1000n); - - await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address)); + await helper.eth.transferBalanceFromSubstrate(alice, flipper.options.address, 1000n); // transferBalanceToEth(api, alice, flipper.options.address, 1000n); + + // Set promotion to the Flipper + await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.sponsorContract(flipper.options.address)); + + // Caller calls Flipper await flipper.methods.flip().send({from: caller}); expect(await flipper.methods.getValue().call()).to.be.true; - + + // The contracts and caller balances have not changed const callerBalance = await helper.balance.getEthereum(caller); const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address); - expect(callerBalance).to.be.equal(1000n * nominal); - expect(1000n * nominal > contractBalanceAfter).to.be.true; + expect(1000n * nominal === contractBalanceAfter).to.be.true; + + // The pallet balance has decreased + const palletBalanceAfter = await helper.balance.getSubstrate(palletAddress); + expect(palletBalanceAfter < palletBalanceBefore).to.be.true; }); - }); -}); - -describe('app-promotion stopSponsoringContract', () => { - before(async function () { - await beforeEach(this); }); - - itWeb3('should remove pallet address from contract sponsors', async ({api, web3, privateKeyWrapper}) => { - await usingPlaygrounds(async (helper) => { - const caller = await createEthAccountWithBalance(api, web3, privateKeyWrapper); - const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase(); - const flipper = await deployFlipper(web3, contractOwner); - await transferBalanceToEth(api, alice, flipper.options.address); - const contractHelper = contractHelpers(web3, contractOwner); + + describe('stopSponsoringContract', () => { + itEth('should remove pallet address from contract sponsors', async ({helper}) => { + const caller = await helper.eth.createAccountWithBalance(alice, 1000n); + const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase(); + const flipper = await helper.eth.deployFlipper(contractOwner); + await helper.eth.transferBalanceFromSubstrate(alice, flipper.options.address); + const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner); + await contractHelper.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: contractOwner}); - await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address)); - await helper.signTransaction(palletAdmin, api.tx.appPromotion.stopSponsoringContract(flipper.options.address)); - + await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address], true); + await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true); + expect(await contractHelper.methods.hasSponsor(flipper.options.address).call()).to.be.false; - expect((await api.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner); - expect((await api.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({ + expect((await helper.api!.query.evmContractHelpers.owner(flipper.options.address)).toJSON()).to.be.equal(contractOwner); + expect((await helper.api!.query.evmContractHelpers.sponsoring(flipper.options.address)).toJSON()).to.deep.equal({ disabled: null, }); - + await flipper.methods.flip().send({from: caller}); expect(await flipper.methods.getValue().call()).to.be.true; - + const callerBalance = await helper.balance.getEthereum(caller); const contractBalanceAfter = await helper.balance.getEthereum(flipper.options.address); - + // caller payed for call expect(1000n * nominal > callerBalance).to.be.true; expect(contractBalanceAfter).to.be.equal(1000n * nominal); }); - }); - - itWeb3('can not be called by non-admin', async ({api, web3, privateKeyWrapper}) => { - await usingPlaygrounds(async (helper) => { + + itEth('can not be called by non-admin', async ({helper}) => { const nonAdmin = accounts.pop()!; - const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase(); - const flipper = await deployFlipper(web3, contractOwner); - - await helper.signTransaction(palletAdmin, api.tx.appPromotion.sponsorContract(flipper.options.address)); - await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.stopSponsoringContract(flipper.options.address))).to.be.rejected; + const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase(); + const flipper = await helper.eth.deployFlipper(contractOwner); + + await helper.executeExtrinsic(palletAdmin, 'api.tx.appPromotion.sponsorContract', [flipper.options.address]); + const stopSponsoringResult = await helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address]); + expect(stopSponsoringResult.status).to.equal('Fail'); + expect(stopSponsoringResult.moduleError).to.equal('appPromotion.NoPermission'); }); - }); - - itWeb3('should not affect a contract which is not sponsored by pallete', async ({api, web3, privateKeyWrapper}) => { - await usingPlaygrounds(async (helper) => { + + itEth('should not affect a contract which is not sponsored by pallete', async ({helper}) => { const nonAdmin = accounts.pop()!; - const contractOwner = (await createEthAccountWithBalance(api, web3, privateKeyWrapper)).toLowerCase(); - const flipper = await deployFlipper(web3, contractOwner); - const contractHelper = contractHelpers(web3, contractOwner); - await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected; - - await expect(helper.signTransaction(nonAdmin, api.tx.appPromotion.stopSponsoringContract(flipper.options.address))).to.be.rejected; + const contractOwner = (await helper.eth.createAccountWithBalance(alice, 1000n)).toLowerCase(); + const flipper = await helper.eth.deployFlipper(contractOwner); + const contractHelper = helper.ethNativeContract.contractHelpers(contractOwner); + await expect(contractHelper.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.fulfilled; + + await expect(helper.executeExtrinsic(nonAdmin, 'api.tx.appPromotion.stopSponsoringContract', [flipper.options.address], true)).to.be.rejectedWith('appPromotion.NoPermission'); }); }); -}); - -describe('app-promotion rewards', () => { - before(async function () { - await beforeEach(this); - }); - - it('can not be called by non admin', async () => { - await usingPlaygrounds(async (helper) => { + + describe('rewards', () => { + itSub('can not be called by non admin', async ({helper}) => { const nonAdmin = accounts.pop()!; - await expect(helper.signTransaction(nonAdmin, helper.api!.tx.appPromotion.payoutStakers(100))).to.be.rejected; + await expect(helper.admin.payoutStakers(nonAdmin, 100)).to.be.rejectedWith('appPromotion.NoPermission'); }); - }); - - it('should credit 0.05% for staking period', async () => { - await usingPlaygrounds(async helper => { + + itSub('should increase total staked', async ({helper}) => { const staker = accounts.pop()!; - + const totalStakedBefore = await helper.staking.getTotalStaked(); + await helper.staking.stake(staker, 100n * nominal); + + // Wait for rewards and pay + const [stakedInBlock] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}); + await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock.block)); + const totalPayout = (await helper.admin.payoutStakers(palletAdmin, 100)).reduce((prev, payout) => prev + payout.payout, 0n); + + const totalStakedAfter = await helper.staking.getTotalStaked(); + expect(totalStakedAfter).to.equal(totalStakedBefore + (100n * nominal) + totalPayout); + // staker can unstake + await helper.staking.unstake(staker); + expect(await helper.staking.getTotalStaked()).to.be.equal(totalStakedAfter - calculateIncome(100n * nominal, 10n)); + }); + + itSub('should credit 0.05% for staking period', async ({helper}) => { + const staker = accounts.pop()!; + await waitPromotionPeriodDoesntEnd(helper); - + await helper.staking.stake(staker, 100n * nominal); await helper.staking.stake(staker, 200n * nominal); - + // wait rewards are available: - const stakedInBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}))[1][0]; - await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock)); - - await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100)); - - const totalStakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(s => s[1]); - expect(totalStakedPerBlock).to.be.deep.equal([calculateIncome(100n * nominal, 10n), calculateIncome(200n * nominal, 10n)]); + const [_, stake2] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}); + await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake2.block)); + + const payoutToStaker = (await helper.admin.payoutStakers(palletAdmin, 100)).find((payout) => payout.staker === staker.address)?.payout; + expect(payoutToStaker + 300n * nominal).to.equal(calculateIncome(300n * nominal, 10n)); + + const totalStakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}); + expect(totalStakedPerBlock[0].amount).to.equal(calculateIncome(100n * nominal, 10n)); + expect(totalStakedPerBlock[1].amount).to.equal(calculateIncome(200n * nominal, 10n)); }); - }); - - it('shoud be paid for more than one period if payments was missed', async () => { - await usingPlaygrounds(async (helper) => { + + itSub('shoud be paid for more than one period if payments was missed', async ({helper}) => { const staker = accounts.pop()!; - + await helper.staking.stake(staker, 100n * nominal); // wait for two rewards are available: - const stakedInBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}))[0][0]; - await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock) + LOCKING_PERIOD); - - await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100)); - const stakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}); + let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}); + await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD); + + await helper.admin.payoutStakers(palletAdmin, 100); + [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}); const frozenBalanceShouldBe = calculateIncome(100n * nominal, 10n, 2); - expect(stakedPerBlock[0][1]).to.be.equal(frozenBalanceShouldBe); - + expect(stake.amount).to.be.equal(frozenBalanceShouldBe); + const stakerFullBalance = await helper.balance.getSubstrateFull(staker.address); - + expect(stakerFullBalance).to.contain({reserved: 0n, feeFrozen: frozenBalanceShouldBe, miscFrozen: frozenBalanceShouldBe}); }); - }); - - it('should not be credited for unstaked (reserved) balance', async () => { - await usingPlaygrounds(async helper => { + + itSub('should not be credited for unstaked (reserved) balance', async ({helper}) => { // staker unstakes before rewards has been payed const staker = accounts.pop()!; await helper.staking.stake(staker, 100n * nominal); - const stakedInBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}))[0][0]; - await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock) + LOCKING_PERIOD); + const [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}); + await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD); await helper.staking.unstake(staker); - + // so he did not receive any rewards const totalBalanceBefore = await helper.balance.getSubstrate(staker.address); - await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100)); + await helper.admin.payoutStakers(palletAdmin, 100); const totalBalanceAfter = await helper.balance.getSubstrate(staker.address); - + expect(totalBalanceBefore).to.be.equal(totalBalanceAfter); }); - }); - - it('should bring compound interest', async () => { - await usingPlaygrounds(async helper => { + + itSub('should bring compound interest', async ({helper}) => { const staker = accounts.pop()!; - + await helper.staking.stake(staker, 100n * nominal); - - const stakedInBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}))[0][0]; - await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock)); - - await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100)); - let totalStakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(s => s[1]); - expect(totalStakedPerBlock).to.deep.equal([calculateIncome(100n * nominal, 10n)]); - - await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock) + LOCKING_PERIOD); - await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100)); - totalStakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(s => s[1]); - expect(totalStakedPerBlock).to.deep.equal([calculateIncome(100n * nominal, 10n, 2)]); + + let [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}); + await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block)); + + await helper.admin.payoutStakers(palletAdmin, 100); + [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}); + expect(stake.amount).to.equal(calculateIncome(100n * nominal, 10n)); + + await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stake.block) + LOCKING_PERIOD); + await helper.admin.payoutStakers(palletAdmin, 100); + [stake] = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}); + expect(stake.amount).to.equal(calculateIncome(100n * nominal, 10n, 2)); }); - }); - - it.skip('can be paid 1000 rewards in a time', async () => { - // all other stakes should be unstaked - await usingPlaygrounds(async (helper) => { + + itSub.skip('can be paid 1000 rewards in a time', async ({helper}) => { + // all other stakes should be unstaked const oneHundredStakers = await helper.arrange.createCrowd(100, 1050n, alice); - + // stakers stakes 10 times each for (let i = 0; i < 10; i++) { await Promise.all(oneHundredStakers.map(staker => helper.staking.stake(staker, 100n * nominal))); } await helper.wait.newBlocks(40); - const result = await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100)); + await helper.admin.payoutStakers(palletAdmin, 100); }); - }); - - it.skip('can handle 40.000 rewards', async () => { - await usingPlaygrounds(async (helper) => { + + itSub.skip('can handle 40.000 rewards', async ({helper}) => { const [donor] = await helper.arrange.createAccounts([7_000_000n], alice); const crowdStakes = async () => { // each account in the crowd stakes 2 times @@ -763,11 +687,11 @@ await Promise.all(crowd.map(account => helper.staking.stake(account, 100n * nominal))); // }; - + for (let i = 0; i < 40; i++) { await crowdStakes(); } - + // TODO pay rewards for some period }); }); --- a/tests/src/eth/util/playgrounds/unique.dev.ts +++ b/tests/src/eth/util/playgrounds/unique.dev.ts @@ -198,8 +198,24 @@ } `); } -} - + + async deployFlipper(signer: string): Promise { + return await this.helper.ethContract.deployByCode(signer, 'Flipper', ` + // SPDX-License-Identifier: UNLICENSED + pragma solidity ^0.8.6; + + contract Flipper { + bool value = false; + function flip() public { + value = !value; + } + function getValue() public view returns (bool) { + return value; + } + } + `); + } +} class EthAddressGroup extends EthGroupBase { extractCollectionId(address: string): number { --- /dev/null +++ b/tests/src/tx-version-presence.test.ts @@ -0,0 +1,32 @@ +// Copyright 2019-2022 Unique Network (Gibraltar) Ltd. +// This file is part of Unique Network. + +// Unique Network is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// Unique Network is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with Unique Network. If not, see . + +import { Metadata } from '@polkadot/types'; +import {itSub, usingPlaygrounds, expect} from './util/playgrounds'; + +let metadata: Metadata; + +describe('TxVersion is present', () => { + before(async () => { + await usingPlaygrounds(async helper => { + metadata = await helper.api!.rpc.state.getMetadata(); + }); + }); + + itSub('Signed extension CheckTxVersion is present', async () => { + expect(metadata.asLatest.extrinsic.signedExtensions.map(se => se.identifier.toString())).to.include('CheckTxVersion'); + }); +}); --- a/tests/src/util/playgrounds/types.ts +++ b/tests/src/util/playgrounds/types.ts @@ -147,6 +147,11 @@ feeFrozen: bigint } +export interface IStakingInfo { + block: bigint, + amount: bigint, +} + export type TSubstrateAccount = string; export type TEthereumAccount = string; export type TApiAllowedListeners = 'connected' | 'disconnected' | 'error' | 'ready' | 'decorated'; --- a/tests/src/util/playgrounds/unique.dev.ts +++ b/tests/src/util/playgrounds/unique.dev.ts @@ -60,11 +60,13 @@ */ arrange: ArrangeGroup; wait: WaitGroup; + admin: AdminGroup; constructor(logger: { log: (msg: any, level: any) => void, level: any }) { super(logger); this.arrange = new ArrangeGroup(this); this.wait = new WaitGroup(this); + this.admin = new AdminGroup(this); } async connect(wsEndpoint: string, _listeners?: any): Promise { @@ -120,6 +122,7 @@ */ createAccounts = async (balances: bigint[], donor: IKeyringPair): Promise => { let nonce = await this.helper.chain.getNonce(donor.address); + const wait = new WaitGroup(this.helper); const ss58Format = this.helper.chain.getChainProperties().ss58Format; const tokenNominal = this.helper.balance.getOneTokenNominal(); const transactions = []; @@ -154,7 +157,7 @@ for (let index = 0; index < 5; index++) { accountsCreated = await checkBalances(); if(accountsCreated) break; - + await wait.newBlocks(1); } if (!accountsCreated) throw Error('Accounts generation failed'); @@ -281,3 +284,22 @@ }); } } + +class AdminGroup { + helper: UniqueHelper; + + constructor(helper: UniqueHelper) { + this.helper = helper; + } + + async payoutStakers(signer: IKeyringPair, stakersToPayout: number) { + const payoutResult = await this.helper.executeExtrinsic(signer, 'api.tx.appPromotion.payoutStakers', [stakersToPayout], true); + return payoutResult.result.events.filter(e => e.event.method === 'StakingRecalculation').map(e => { + return { + staker: e.event.data[0].toString(), + stake: e.event.data[1].toBigInt(), + payout: e.event.data[2].toBigInt(), + }; + }); + } +} --- a/tests/src/util/playgrounds/unique.ts +++ b/tests/src/util/playgrounds/unique.ts @@ -9,7 +9,7 @@ import {ApiInterfaceEvents} from '@polkadot/api/types'; import {encodeAddress, decodeAddress, keccakAsHex, evmToAddress, addressToEvm} from '@polkadot/util-crypto'; import {IKeyringPair} from '@polkadot/types/types'; -import {IApiListeners, IBlock, IChainEvent, IChainProperties, ICollectionCreationOptions, ICollectionLimits, ICollectionPermissions, ICrossAccountId, ICrossAccountIdLower, ILogger, INestingPermissions, IProperty, ISubstrateBalance, IToken, ITokenPropertyPermission, ITransactionResult, IUniqueHelperLog, TApiAllowedListeners, TEthereumAccount, TSigner, TSubstrateAccount, TUniqueNetworks} from './types'; +import {IApiListeners, IBlock, IChainEvent, IChainProperties, ICollectionCreationOptions, ICollectionLimits, ICollectionPermissions, ICrossAccountId, ICrossAccountIdLower, ILogger, INestingPermissions, IProperty, IStakingInfo, ISubstrateBalance, IToken, ITokenPropertyPermission, ITransactionResult, IUniqueHelperLog, TApiAllowedListeners, TEthereumAccount, TSigner, TSubstrateAccount, TUniqueNetworks} from './types'; export const crossAccountIdFromLower = (lowerAddress: ICrossAccountIdLower): ICrossAccountId => { const address = {} as ICrossAccountId; @@ -2029,21 +2029,54 @@ return 1; } + /** + * Get total staked amount for address + * @param address substrate or ethereum address + * @returns total staked amount + */ async getTotalStaked(address?: ICrossAccountId): Promise { if (address) return (await this.helper.callRpc('api.rpc.appPromotion.totalStaked', [address])).toBigInt(); return (await this.helper.callRpc('api.rpc.appPromotion.totalStaked')).toBigInt(); } - async getTotalStakedPerBlock(address: ICrossAccountId): Promise { - return (await this.helper.callRpc('api.rpc.appPromotion.totalStakedPerBlock', [address])).map(([block, amount]: any[]) => [block.toBigInt(), amount.toBigInt()]); + /** + * Get total staked per block + * @param address substrate or ethereum address + * @returns array of stakes. `block` – the number of the block in which the stake was made. `amount` - the number of tokens staked in the block + */ + async getTotalStakedPerBlock(address: ICrossAccountId): Promise { + const rawTotalStakerdPerBlock = await this.helper.callRpc('api.rpc.appPromotion.totalStakedPerBlock', [address]); + return rawTotalStakerdPerBlock.map(([block, amount]: any[]) => { + return { + block: block.toBigInt(), + amount: amount.toBigInt(), + }; + }); } + /** + * Get total pending unstake amount for address + * @param address substrate or ethereum address + * @returns total pending unstake amount + */ async getPendingUnstake(address: ICrossAccountId): Promise { return (await this.helper.callRpc('api.rpc.appPromotion.pendingUnstake', [address])).toBigInt(); } - async getPendingUnstakePerBlock(address: ICrossAccountId): Promise { - return (await this.helper.callRpc('api.rpc.appPromotion.pendingUnstakePerBlock', [address])).map(([block, amount]: any[]) => [block.toBigInt(), amount.toBigInt()]); + /** + * Get pending unstake amount per block for address + * @param address substrate or ethereum address + * @returns array of pending stakes. `block` – the number of the block in which the unstake was made. `amount` - the number of tokens unstaked in the block + */ + async getPendingUnstakePerBlock(address: ICrossAccountId): Promise { + const rawUnstakedPerBlock = await this.helper.callRpc('api.rpc.appPromotion.pendingUnstakePerBlock', [address]); + const result = rawUnstakedPerBlock.map(([block, amount]: any[]) => { + return { + block: block.toBigInt(), + amount: amount.toBigInt(), + }; + }); + return result; } } -- gitstuff