Add create bounty script

packages/test-support/package.json

@@ -10,5 +10,9 @@
   "dependencies": {
     "@testing-library/react": "^11.2.3",
     "testcontainers": "^6.4.1"
+  },
+  "devDependencies": {
+    "ts-node": "^9.1.1",
+    "tsconfig-paths": "^3.9.0"
   }
 }

packages/test-support/scripts/createBounties.ts

@@ -0,0 +1,48 @@
+// Copyright 2017-2021 @polkadot/test-support authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { createApi } from '@polkadot/test-support/api';
+import { aliceSigner,
+  bobSigner,
+  charlieSigner,
+  daveSigner,
+  eveSigner,
+  ferdieSigner } from '@polkadot/test-support/keyring';
+
+import { multiAcceptCurator,
+  multiApproveBounty,
+  multiAwardBounty,
+  multiClaimBounty,
+  multiProposeBounty,
+  multiProposeCurator,
+  multiWaitForBountyFunded,
+  multiWaitForClaim } from './lib/multiFunctions';
+
+(async () => {
+  const api = await createApi(9944);
+
+  const SIGNERS = [aliceSigner(), bobSigner(), charlieSigner(), daveSigner(), eveSigner(), ferdieSigner()];
+
+  const indexes = await multiProposeBounty(api, 6);
+
+  indexes.pop();
+  await multiApproveBounty(api, indexes);
+
+  await multiWaitForBountyFunded(api, indexes);
+
+  indexes.pop();
+  await multiProposeCurator(api, indexes, SIGNERS);
+
+  indexes.pop();
+  await multiAcceptCurator(api, indexes, SIGNERS);
+
+  indexes.pop();
+  await multiAwardBounty(api, indexes, SIGNERS);
+
+  await multiWaitForClaim(api, indexes);
+
+  indexes.pop();
+  await multiClaimBounty(api, indexes, SIGNERS);
+
+  await api.disconnect();
+})().catch((err) => console.error(err));

packages/test-support/scripts/lib/bountyWaitFunctions.ts

@@ -0,0 +1,34 @@
+// Copyright 2017-2021 @polkadot/test-support authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { ApiPromise } from '@polkadot/api';
+import { DeriveBounty } from '@polkadot/api-derive/types';
+import { waitFor, WaitOptions } from '@polkadot/test-support/utils/waitFor';
+
+type bStatus = 'isFunded' | 'isActive';
+
+async function getBounty (api: ApiPromise, bountyIndex: number): Promise<DeriveBounty> {
+  const bounties = await api.derive.bounties.bounties();
+
+  return bounties.find((bounty) => (bounty.index.toNumber() === bountyIndex)) as DeriveBounty;
+}
+
+export async function waitForBountyState (api: ApiPromise, expectedState: bStatus, index: number, { interval = 500,
+  timeout = 10000 } = {}): Promise<boolean> {
+  return waitFor(async () => {
+    const bounty = await getBounty(api, index);
+
+    return bounty.bounty.status[expectedState];
+  }, { interval, timeout });
+}
+
+export async function waitForClaim (api: ApiPromise, index: number, { interval = 500, timeout = 10000 }: WaitOptions): Promise<boolean> {
+  return waitFor(async () => {
+    const bounty = await getBounty(api, index);
+    const unlockAt = bounty.bounty.status.asPendingPayout.unlockAt;
+
+    const bestNumber = await api.derive.chain.bestNumber();
+
+    return unlockAt.lt(bestNumber);
+  }, { interval, timeout });
+}

packages/test-support/scripts/lib/changeBountyStateFunctions.ts

@@ -0,0 +1,47 @@
+// Copyright 2017-2021 @polkadot/test-support authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { KeyringPair } from '@polkadot/keyring/types';
+
+import BN from 'bn.js';
+
+import { ApiPromise } from '@polkadot/api';
+import { execute } from '@polkadot/test-support/transaction';
+
+import { acceptMotion, fillTreasury, getMotion, proposeMotion } from './helpers';
+
+export async function acceptCurator (api: ApiPromise, id: number, signer: KeyringPair): Promise<void> {
+  await execute(api.tx.bounties.acceptCurator(id), signer);
+}
+
+export async function awardBounty (api: ApiPromise, index: number, signer: KeyringPair): Promise<void> {
+  await execute(api.tx.bounties.awardBounty(index, signer.address), signer);
+}
+
+export async function claimBounty (api: ApiPromise, index: number, signer: KeyringPair): Promise<void> {
+  await execute(api.tx.bounties.claimBounty(index), signer);
+}
+
+export async function proposeBounty (api: ApiPromise, value: BN, title: string, signer: KeyringPair): Promise<number> {
+  await execute(api.tx.bounties.proposeBounty(value, title), signer);
+  const index = await api.query.bounties.bountyCount();
+
+  return index.toNumber() - 1;
+}
+
+export async function proposeCurator (api: ApiPromise, index: number, signer: KeyringPair): Promise<void> {
+  await proposeMotion(api, api.tx.bounties.proposeCurator(index, signer.address, 10), signer);
+
+  const bountyProposal = await getMotion(api, index);
+
+  await acceptMotion(api, bountyProposal.hash, bountyProposal.votes?.index.toNumber() ?? 0);
+}
+
+export async function approveBounty (api: ApiPromise, index: number, signer: KeyringPair): Promise<void> {
+  await proposeMotion(api, api.tx.bounties.approveBounty(index), signer);
+
+  const bountyProposal = await getMotion(api, index);
+
+  await acceptMotion(api, bountyProposal.hash, bountyProposal.votes?.index.toNumber() ?? 0);
+  await fillTreasury(api, signer);
+}

packages/test-support/scripts/lib/constants.ts

@@ -0,0 +1,10 @@
+// Copyright 2017-2021 @polkadot/test-support authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BN from 'bn.js';
+
+export const TREASURY_ADDRESS = '13UVJyLnbVp9RBZYFwFGyDvVd1y27Tt8tkntv6Q7JVPhFsTB';
+export const FUNDING_TIME = 150000;
+export const PAYOUT_TIME = 150000;
+export const WEIGHT_BOUND = new BN('10000000000');
+export const LENGTH_BOUND = 100000;

packages/test-support/scripts/lib/helpers.ts

@@ -0,0 +1,42 @@
+// Copyright 2017-2021 @polkadot/test-support authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BN from 'bn.js';
+
+import { ApiPromise } from '@polkadot/api';
+import { SubmittableExtrinsic } from '@polkadot/api/types';
+import { DeriveCollectiveProposal } from '@polkadot/api-derive/types';
+import { KeyringPair } from '@polkadot/keyring/types';
+import { charlieSigner,
+  daveSigner,
+  eveSigner,
+  ferdieSigner } from '@polkadot/test-support/keyring';
+import { execute } from '@polkadot/test-support/transaction';
+import { Hash } from '@polkadot/types/interfaces';
+
+import { LENGTH_BOUND, TREASURY_ADDRESS, WEIGHT_BOUND } from './constants';
+
+export async function acceptMotion (api: ApiPromise, hash: Hash, index: number): Promise<void> {
+  const charlieVote = execute(api.tx.council.vote(hash, index, true), charlieSigner());
+  const daveVote = execute(api.tx.council.vote(hash, index, true), daveSigner());
+  const eveVote = execute(api.tx.council.vote(hash, index, true), eveSigner());
+  const ferdieVote = execute(api.tx.council.vote(hash, index, true), ferdieSigner());
+
+  await Promise.all([charlieVote, daveVote, eveVote, ferdieVote]);
+  await execute(api.tx.council.close(hash, index, WEIGHT_BOUND, LENGTH_BOUND), charlieSigner());
+}
+
+export async function fillTreasury (api: ApiPromise, signer: KeyringPair): Promise<void> {
+  await execute(api.tx.balances.transfer(TREASURY_ADDRESS, new BN(5_000_000_000_000_000)), signer);
+}
+
+export async function proposeMotion (api: ApiPromise, submittableExtrinsic: SubmittableExtrinsic<'promise'>, signer: KeyringPair): Promise<void> {
+  await execute(api.tx.council.propose(4, submittableExtrinsic, LENGTH_BOUND), signer);
+}
+
+export async function getMotion (api: ApiPromise, index: number): Promise<DeriveCollectiveProposal> {
+  const bounties = await api.derive.bounties.bounties();
+  const bountyProposals = bounties.find((bounty) => (bounty.index.toNumber() === index))?.proposals as DeriveCollectiveProposal[];
+
+  return bountyProposals[0];
+}

packages/test-support/scripts/lib/multiFunctions.ts

@@ -0,0 +1,68 @@
+// Copyright 2017-2021 @polkadot/test-support authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BN from 'bn.js';
+
+import { ApiPromise } from '@polkadot/api';
+import { KeyringPair } from '@polkadot/keyring/types';
+import { aliceSigner } from '@polkadot/test-support/keyring';
+
+import { waitForBountyState, waitForClaim } from './bountyWaitFunctions';
+import { acceptCurator, approveBounty, awardBounty, claimBounty, proposeBounty, proposeCurator } from './changeBountyStateFunctions';
+import { FUNDING_TIME, PAYOUT_TIME } from './constants';
+
+export async function multiProposeBounty (api: ApiPromise, numberOfBounties: number): Promise<number[]> {
+  const indexes = [];
+
+  for (let i = 0; i < numberOfBounties; i++) {
+    indexes.push(await proposeBounty(api, new BN(500_000_000_000_000), `new bounty no ${i}`, aliceSigner()));
+  }
+
+  return indexes;
+}
+
+export async function multiApproveBounty (api: ApiPromise, bountyIndexes: number[]): Promise<void> {
+  for (const bountyIndex of bountyIndexes) {
+    await approveBounty(api, bountyIndex, aliceSigner());
+  }
+}
+
+export async function multiWaitForBountyFunded (api: ApiPromise, bountyIndexes: number[]): Promise<void> {
+  const waitFunctions = bountyIndexes.map((bountyIndex) =>
+    waitForBountyState(api, 'isFunded', bountyIndex, { interval: 2000, timeout: FUNDING_TIME }));
+
+  await Promise.all(waitFunctions);
+}
+
+export async function multiProposeCurator (api: ApiPromise, bountyIndexes: number[], signers: KeyringPair[]): Promise<void> {
+  for (let i = 0; i < bountyIndexes.length; i++) {
+    await proposeCurator(api, bountyIndexes[i], signers[i]);
+  }
+}
+
+export async function multiAcceptCurator (api: ApiPromise, bountyIndexes: number[], signers: KeyringPair[]): Promise<void> {
+  const acceptFunctions = bountyIndexes.map((bountyIndex, index) =>
+    acceptCurator(api, bountyIndex, signers[index]));
+
+  await Promise.all(acceptFunctions);
+}
+
+export async function multiAwardBounty (api: ApiPromise, bountyIndexes: number[], signers: KeyringPair[]): Promise<void> {
+  const awardFunctions = bountyIndexes.map((bountyIndex, index) =>
+    awardBounty(api, bountyIndex, signers[index]));
+
+  await Promise.all(awardFunctions);
+}
+
+export async function multiWaitForClaim (api: ApiPromise, bountyIndexes: number[]): Promise<void> {
+  for (const index of bountyIndexes) {
+    await waitForClaim(api, index, { interval: 2000, timeout: PAYOUT_TIME });
+  }
+}
+
+export async function multiClaimBounty (api: ApiPromise, bountyIndexes: number[], signers: KeyringPair[]): Promise<void> {
+  const awardFunctions = bountyIndexes.map((bountyIndex, index) =>
+    claimBounty(api, bountyIndex, signers[index]));
+
+  await Promise.all(awardFunctions);
+}

packages/test-support/scripts/readme.md

@@ -0,0 +1,18 @@
+## Scripts for bounty testing
+
+The scripts are prepared to run on a local, development version of substrate with following changes:
+- `bin/node/runtime/src/lib.rs`
+  ```
+  pub const SpendPeriod: BlockNumber = 1 * MINUTES;
+  pub const BountyDepositPayoutDelay: BlockNumber = 1 * MINUTES
+  ```
+
+To run a script enter the `packages/test-support` directory and run:
+```
+ts-node scripts/<script-name>
+```
+
+Available scripts:
+- `createBounties` - creates a list of bounties,
+  one in each status ( Proposed, Funded, Curator Proposed, Active, Pending Payout, Closed	)
+

packages/test-support/src/api/createApi.ts

@@ -5,10 +5,10 @@ import { ApiPromise } from '@polkadot/api/promise';
 import { WsProvider } from '@polkadot/rpc-provider';
 import { SUBSTRATE_PORT } from '@polkadot/test-support/substrate';
 
-export async function createApi (): Promise<ApiPromise> {
+export async function createApi (port: number = SUBSTRATE_PORT): Promise<ApiPromise> {
   process.env.NODE_ENV = 'test';
 
-  const provider = new WsProvider(`ws://127.0.0.1:${SUBSTRATE_PORT}`);
+  const provider = new WsProvider(`ws://127.0.0.1:${port}`);
 
   const api = await ApiPromise.create({ provider });
 

packages/test-support/src/keyring/signers.ts

@@ -9,3 +9,33 @@ export function aliceSigner (): KeyringPair {
 
   return keyring.addFromUri('//Alice');
 }
+
+export function bobSigner (): KeyringPair {
+  const keyring = new Keyring({ type: 'sr25519' });
+
+  return keyring.addFromUri('//Bob');
+}
+
+export function charlieSigner (): KeyringPair {
+  const keyring = new Keyring({ type: 'sr25519' });
+
+  return keyring.addFromUri('//Charlie');
+}
+
+export function daveSigner (): KeyringPair {
+  const keyring = new Keyring({ type: 'sr25519' });
+
+  return keyring.addFromUri('//Dave');
+}
+
+export function eveSigner (): KeyringPair {
+  const keyring = new Keyring({ type: 'sr25519' });
+
+  return keyring.addFromUri('//Eve');
+}
+
+export function ferdieSigner (): KeyringPair {
+  const keyring = new Keyring({ type: 'sr25519' });
+
+  return keyring.addFromUri('//Ferdie');
+}

packages/test-support/src/transaction/execute.ts

@@ -1,12 +1,12 @@
 // Copyright 2017-2021 @polkadot/test-support authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { waitFor } from '@testing-library/react';
-
 import { SubmittableExtrinsic } from '@polkadot/api/types';
 import { KeyringPair } from '@polkadot/keyring/types';
 import { EventRecord, ExtrinsicStatus } from '@polkadot/types/interfaces';
 
+import { waitFor } from '../utils/waitFor';
+
 export async function execute (extrinsic: SubmittableExtrinsic<'promise'>, singer: KeyringPair, logger = { info: console.log }): Promise<void> {
   let currentTxDone = false;
 
@@ -36,5 +36,5 @@ export async function execute (extrinsic: SubmittableExtrinsic<'promise'>, singe
   }
 
   await extrinsic.signAndSend(singer, sendStatusCb);
-  await waitFor(() => expect(currentTxDone).toBeTruthy(), { timeout: 20000 });
+  await waitFor(() => currentTxDone, { timeout: 20000 });
 }

packages/test-support/src/utils/waitFor.ts

@@ -0,0 +1,27 @@
+// Copyright 2017-2021 @polkadot/test-support authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export type WaitOptions = { interval?: number, timeout?: number };
+
+export async function waitFor (predicate: () => boolean, { interval, timeout }: WaitOptions): Promise<boolean>;
+export async function waitFor (predicate: () => Promise<boolean>, { interval, timeout }: WaitOptions): Promise<boolean>;
+
+export async function waitFor (predicate: () => Promise<boolean> | boolean, { interval = 500, timeout = 10000 } = {}): Promise<boolean> {
+  const asyncPredicate = () => Promise.resolve(predicate());
+
+  let elapsed = 0;
+
+  while (!(await asyncPredicate())) {
+    if (elapsed > timeout) {
+      throw Error('Timeout');
+    }
+
+    await sleep(interval);
+    elapsed += interval;
+  }
+
+  return true;
+}
+
+export const sleep = (ms: number):Promise<void> =>
+  new Promise((resolve) => setTimeout(resolve, ms));

packages/test-support/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "module": "CommonJS",
+    "target": "es2018"
+  },
+  "ts-node": {
+    "require": ["tsconfig-paths/register"]
+  }
+}