git.delta.rocks / unique-network / refs/commits / e6b5df49e9b9

--- a/tests/package.json
+++ b/tests/package.json
@@ -30,6 +30,7 @@
     "testEth": "mocha --timeout 9999999 -r ts-node/register './**/eth/**/*.test.ts'",
     "testEthMarketplace": "mocha --timeout 9999999 -r ts-node/register './**/eth/marketplace/**/*.test.ts'",
     "testEthNesting": "mocha --timeout 9999999 -r ts-node/register './**/eth/nesting/**/*.test.ts'",
+    "testEthPayable": "mocha --timeout 9999999 -r ts-node/register './**/eth/payable.test.ts'",
     "load": "mocha --timeout 9999999 -r ts-node/register './**/*.load.ts'",
     "loadTransfer": "ts-node src/transfer.nload.ts",
     "testCollision": "mocha --timeout 9999999 -r ts-node/register ./src/collision-tests/*.test.ts",

--- a/tests/src/eth/payable.test.ts
+++ b/tests/src/eth/payable.test.ts
@@ -14,97 +14,91 @@
 // You should have received a copy of the GNU General Public License
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
-import {expect} from 'chai';
-import {submitTransactionAsync} from '../substrate/substrate-api';
-import {createEthAccountWithBalance, deployCollector, GAS_ARGS, itWeb3, subToEth, transferBalanceToEth} from './util/helpers';
-import {evmToAddress} from '@polkadot/util-crypto';
-import {getGenericResult, UNIQUE} from '../util/helpers';
-import {getBalanceSingle, transferBalanceExpectSuccess} from '../substrate/get-balance';
+import {IKeyringPair} from '@polkadot/types/types';
+
+import {itEth, expect, usingEthPlaygrounds} from './util/playgrounds';
 
 describe('EVM payable contracts', () => {
-  itWeb3('Evm contract can receive wei from eth account', async ({api, web3, privateKeyWrapper}) => {
-    const deployer = await createEthAccountWithBalance(api, web3, privateKeyWrapper);
-    const contract = await deployCollector(web3, deployer);
+  let donor: IKeyringPair;
 
-    await web3.eth.sendTransaction({from: deployer, to: contract.options.address, value: '10000', ...GAS_ARGS});
+  before(async function() {
+    await usingEthPlaygrounds(async (helper, privateKey) => {
+      donor = privateKey('//Alice');
+    });
+  });
+
+  itEth('Evm contract can receive wei from eth account', async ({helper}) => {
+    const deployer = await helper.eth.createAccountWithBalance(donor);
+    const contract = await helper.eth.deployCollectorContract(deployer);
+
+    const web3 = helper.getWeb3();
+
+    await web3.eth.sendTransaction({from: deployer, to: contract.options.address, value: '10000', gas: helper.eth.DEFAULT_GAS});
 
     expect(await contract.methods.getCollected().call()).to.be.equal('10000');
   });
 
-  itWeb3('Evm contract can receive wei from substrate account', async ({api, web3, privateKeyWrapper}) => {
-    const deployer = await createEthAccountWithBalance(api, web3, privateKeyWrapper);
-    const contract = await deployCollector(web3, deployer);
-    const alice = privateKeyWrapper('//Alice');
+  itEth('Evm contract can receive wei from substrate account', async ({helper}) => {
+    const deployer = await helper.eth.createAccountWithBalance(donor);
+    const contract = await helper.eth.deployCollectorContract(deployer);
+    const [alice] = await helper.arrange.createAccounts([10n], donor);
+
+    const weiCount = '10000';
 
     // Transaction fee/value will be payed from subToEth(sender) evm balance,
     // which is backed by evmToAddress(subToEth(sender)) substrate balance
-    await transferBalanceToEth(api, alice, subToEth(alice.address));
+    await helper.eth.transferBalanceFromSubstrate(alice, helper.address.substrateToEth(alice.address), 5n);
+
 
-    {
-      const tx = api.tx.evm.call(
-        subToEth(alice.address),
-        contract.options.address,
-        contract.methods.giveMoney().encodeABI(),
-        '10000',
-        GAS_ARGS.gas,
-        await web3.eth.getGasPrice(),
-        null,
-        null,
-        [],
-      );
-      const events = await submitTransactionAsync(alice, tx);
-      const result = getGenericResult(events);
-      expect(result.success).to.be.true;
-    }
+    await helper.eth.callEVM(alice, contract.options.address, contract.methods.giveMoney().encodeABI(), weiCount);
 
-    expect(await contract.methods.getCollected().call()).to.be.equal('10000');
+    expect(await contract.methods.getCollected().call()).to.be.equal(weiCount);
   });
 
   // We can't handle sending balance to backing storage of evm balance, because evmToAddress operation is irreversible
-  itWeb3('Wei sent directly to backing storage of evm contract balance is unaccounted', async({api, web3, privateKeyWrapper}) => {
-    const deployer = await createEthAccountWithBalance(api, web3, privateKeyWrapper);
-    const contract = await deployCollector(web3, deployer);
-    const alice = privateKeyWrapper('//Alice');
+  itEth('Wei sent directly to backing storage of evm contract balance is unaccounted', async({helper}) => {
+    const deployer = await helper.eth.createAccountWithBalance(donor);
+    const contract = await helper.eth.deployCollectorContract(deployer);
+    const [alice] = await helper.arrange.createAccounts([10n], donor);
+
+    const weiCount = 10_000n;
 
-    await transferBalanceExpectSuccess(api, alice, evmToAddress(contract.options.address), '10000');
+    await helper.eth.transferBalanceFromSubstrate(alice, contract.options.address, weiCount, false);
 
-    expect(await contract.methods.getUnaccounted().call()).to.be.equal('10000');
+    expect(await contract.methods.getUnaccounted().call()).to.be.equal(weiCount.toString());
   });
 
-  itWeb3('Balance can be retrieved from evm contract', async({api, web3, privateKeyWrapper}) => {
-    const FEE_BALANCE = 1000n * UNIQUE;
-    const CONTRACT_BALANCE = 1n * UNIQUE;
+  itEth('Balance can be retrieved from evm contract', async({helper, privateKey}) => {
+    const FEE_BALANCE = 10n * helper.balance.getOneTokenNominal();
+    const CONTRACT_BALANCE = 1n * helper.balance.getOneTokenNominal();
+
+    const deployer = await helper.eth.createAccountWithBalance(donor);
+    const contract = await helper.eth.deployCollectorContract(deployer);
+    const [alice] = await helper.arrange.createAccounts([20n], donor);
 
-    const deployer = await createEthAccountWithBalance(api, web3, privateKeyWrapper);
-    const contract = await deployCollector(web3, deployer);
-    const alice = privateKeyWrapper('//Alice');
+    const web3 = helper.getWeb3();
 
-    await web3.eth.sendTransaction({from: deployer, to: contract.options.address, value: CONTRACT_BALANCE.toString(), ...GAS_ARGS});
+    await web3.eth.sendTransaction({from: deployer, to: contract.options.address, value: CONTRACT_BALANCE.toString(), gas: helper.eth.DEFAULT_GAS});
 
-    const receiver = privateKeyWrapper(`//Receiver${Date.now()}`);
+    const receiver = privateKey(`//Receiver${Date.now()}`);
 
     // First receive balance on eth balance of bob
     {
-      const ethReceiver = subToEth(receiver.address);
+      const ethReceiver = helper.address.substrateToEth(receiver.address);
       expect(await web3.eth.getBalance(ethReceiver)).to.be.equal('0');
       await contract.methods.withdraw(ethReceiver).send({from: deployer});
       expect(await web3.eth.getBalance(ethReceiver)).to.be.equal(CONTRACT_BALANCE.toString());
     }
 
     // Some balance is required to pay fee for evm.withdraw call
-    await transferBalanceExpectSuccess(api, alice, receiver.address, FEE_BALANCE.toString());
+    await helper.balance.transferToSubstrate(alice, receiver.address, FEE_BALANCE);
+    // await transferBalanceExpectSuccess(api, alice, receiver.address, FEE_BALANCE.toString());
 
     // Withdraw balance from eth to substrate
     {
-      const initialReceiverBalance = await getBalanceSingle(api, receiver.address);
-      const tx = api.tx.evm.withdraw(
-        subToEth(receiver.address),
-        CONTRACT_BALANCE.toString(),
-      );
-      const events = await submitTransactionAsync(receiver, tx);
-      const result = getGenericResult(events);
-      expect(result.success).to.be.true;
-      const finalReceiverBalance = await getBalanceSingle(api, receiver.address);
+      const initialReceiverBalance = await helper.balance.getSubstrate(receiver.address);
+      await helper.executeExtrinsic(receiver, 'api.tx.evm.withdraw', [helper.address.substrateToEth(receiver.address), CONTRACT_BALANCE.toString()], true);
+      const finalReceiverBalance = await helper.balance.getSubstrate(receiver.address);
 
       expect(finalReceiverBalance > initialReceiverBalance).to.be.true;
     }

33
4/* eslint-disable function-call-argument-newline */4/* eslint-disable function-call-argument-newline */
5
6import {readFile} from 'fs/promises';
57
6import Web3 from 'web3';8import Web3 from 'web3';
7import {WebsocketProvider} from 'web3-core';9import {WebsocketProvider} from 'web3-core';
8import {Contract} from 'web3-eth-contract';10import {Contract} from 'web3-eth-contract';
11
12import * as solc from 'solc';
913
10import {evmToAddress} from '@polkadot/util-crypto';14import {evmToAddress} from '@polkadot/util-crypto';
11import {IKeyringPair} from '@polkadot/types/types';15import {IKeyringPair} from '@polkadot/types/types';
1216
13import {DevUniqueHelper} from '../../../util/playgrounds/unique.dev';17import {DevUniqueHelper} from '../../../util/playgrounds/unique.dev';
18
19import {ContractImports, CompiledContract} from './types';
1420
15// Native contracts ABI21// Native contracts ABI
16import collectionHelpersAbi from '../../collectionHelpersAbi.json';22import collectionHelpersAbi from '../../collectionHelpersAbi.json';
29}35}
30  36
31  37
38class ContractGroup extends EthGroupBase {
39  async findImports(imports?: ContractImports[]){
40    if(!imports) return function(path: string) {
41      return {error: 'File not found'};
42    };
43  
44    const knownImports = {} as any;
45    for(let imp of imports) {
46      knownImports[imp.solPath] = (await readFile(imp.fsPath)).toString();
47    }
48  
49    return function(path: string) {
50      if(knownImports.hasOwnProperty(path)) return {contents: knownImports[path]};
51      return {error: 'File not found'};
52    }
53  }
54
55  async compile(name: string, src: string, imports?: ContractImports[]): Promise<CompiledContract> {
56    const out = JSON.parse(solc.compile(JSON.stringify({
57      language: 'Solidity',
58      sources: {
59        [`${name}.sol`]: {
60          content: src,
61        },
62      },
63      settings: {
64        outputSelection: {
65          '*': {
66            '*': ['*'],
67          },
68        },
69      },
70    }), {import: await this.findImports(imports)})).contracts[`${name}.sol`][name];
71  
72    return {
73      abi: out.abi,
74      object: '0x' + out.evm.bytecode.object,
75    };
76  }
77
78  async deployByCode(signer: string, name: string, src: string, imports?: ContractImports[]): Promise<Contract> {
79    const compiledContract = await this.compile(name, src, imports);
80    return this.deployByAbi(signer, compiledContract.abi, compiledContract.object);
81  }
82
83  async deployByAbi(signer: string, abi: any, object: string): Promise<Contract> {
84    const web3 = this.helper.getWeb3();
85    const contract = new web3.eth.Contract(abi, undefined, {
86      data: object,
87      from: signer,
88      gas: this.helper.eth.DEFAULT_GAS
89    });
90    return await contract.deploy({data: object}).send({from: signer});
91  }
92
93}
94  
32class NativeContractGroup extends EthGroupBase {95class NativeContractGroup extends EthGroupBase {
33  DEFAULT_GAS = 2_500_000;
3496
35  contractHelpers(caller: string): Contract {97  contractHelpers(caller: string): Contract {
36    const web3 = this.helper.getWeb3();98    const web3 = this.helper.getWeb3();
37    return new web3.eth.Contract(contractHelpersAbi as any, '0x842899ECF380553E8a4de75bF534cdf6fBF64049', {from: caller, gas: this.DEFAULT_GAS});99    return new web3.eth.Contract(contractHelpersAbi as any, '0x842899ECF380553E8a4de75bF534cdf6fBF64049', {from: caller, gas: this.helper.eth.DEFAULT_GAS});
38  }100  }
39101
40  collectionHelpers(caller: string) {102  collectionHelpers(caller: string) {
41    const web3 = this.helper.getWeb3();103    const web3 = this.helper.getWeb3();
42    return new web3.eth.Contract(collectionHelpersAbi as any, '0x6c4e9fe1ae37a41e93cee429e8e1881abdcbb54f', {from: caller, gas: this.DEFAULT_GAS});104    return new web3.eth.Contract(collectionHelpersAbi as any, '0x6c4e9fe1ae37a41e93cee429e8e1881abdcbb54f', {from: caller, gas: this.helper.eth.DEFAULT_GAS});
43  }105  }
44106
45  collection(address: string, mode: 'nft' | 'rft' | 'ft', caller?: string): Contract {107  collection(address: string, mode: 'nft' | 'rft' | 'ft', caller?: string): Contract {
49      'ft': fungibleAbi111      'ft': fungibleAbi
50    }[mode];112    }[mode];
51    const web3 = this.helper.getWeb3();113    const web3 = this.helper.getWeb3();
52    return new web3.eth.Contract(abi as any, address, {gas: this.DEFAULT_GAS, ...(caller ? {from: caller} : {})});114    return new web3.eth.Contract(abi as any, address, {gas: this.helper.eth.DEFAULT_GAS, ...(caller ? {from: caller} : {})});
53  }115  }
54116
55  rftTokenByAddress(address: string, caller?: string): Contract {117  rftTokenByAddress(address: string, caller?: string): Contract {
56    const web3 = this.helper.getWeb3();118    const web3 = this.helper.getWeb3();
57    return new web3.eth.Contract(refungibleTokenAbi as any, address, {gas: this.DEFAULT_GAS, ...(caller ? {from: caller} : {})});119    return new web3.eth.Contract(refungibleTokenAbi as any, address, {gas: this.helper.eth.DEFAULT_GAS, ...(caller ? {from: caller} : {})});
58  }120  }
59121
60  rftToken(collectionId: number, tokenId: number, caller?: string): Contract {122  rftToken(collectionId: number, tokenId: number, caller?: string): Contract {
64126
65  127  
66class EthGroup extends EthGroupBase {128class EthGroup extends EthGroupBase {
129  DEFAULT_GAS = 2_500_000;
130
67  createAccount() {131  createAccount() {
68    const web3 = this.helper.getWeb3();132    const web3 = this.helper.getWeb3();
78    return account;142    return account;
79  }143  }
80144
81  async transferBalanceFromSubstrate(donor: IKeyringPair, recepient: string, amount=1000n) {145  async transferBalanceFromSubstrate(donor: IKeyringPair, recepient: string, amount=1000n, inTokens=true) {
82    return await this.helper.balance.transferToSubstrate(donor, evmToAddress(recepient), amount * this.helper.balance.getOneTokenNominal());146    return await this.helper.balance.transferToSubstrate(donor, evmToAddress(recepient), amount * (inTokens ? this.helper.balance.getOneTokenNominal() : 1n));
83  }147  }
148
149  async callEVM(signer: IKeyringPair, contractAddress: string, abi: any, value: string, gasLimit?: number) {
150    if(!gasLimit) gasLimit = this.DEFAULT_GAS;
151    const web3 = this.helper.getWeb3();
152    const gasPrice = await web3.eth.getGasPrice();
153    // TODO: check execution status
154    await this.helper.executeExtrinsic(
155      signer,
156      'api.tx.evm.call', [this.helper.address.substrateToEth(signer.address), contractAddress, abi, value, gasLimit, gasPrice, null, null, []],
157      true, `Unable to perform evm.call`
158    );
159  }
84160
85  async createNonfungibleCollection(signer: string, name: string, description: string, tokenPrefix: string): Promise<{collectionId: number, collectionAddress: string}> {161  async createNonfungibleCollection(signer: string, name: string, description: string, tokenPrefix: string): Promise<{collectionId: number, collectionAddress: string}> {
86    const collectionHelper = this.helper.ethNativeContract.collectionHelpers(signer);162    const collectionHelper = this.helper.ethNativeContract.collectionHelpers(signer);
93    return {collectionId, collectionAddress};169    return {collectionId, collectionAddress};
94  }170  }
171
172  async deployCollectorContract(signer: string): Promise<Contract> {
173    return await this.helper.ethContract.deployByCode(signer, 'Collector', `
174    // SPDX-License-Identifier: UNLICENSED
175    pragma solidity ^0.8.6;
176
177    contract Collector {
178      uint256 collected;
179      fallback() external payable {
180        giveMoney();
181      }
182      function giveMoney() public payable {
183        collected += msg.value;
184      }
185      function getCollected() public view returns (uint256) {
186        return collected;
187      }
188      function getUnaccounted() public view returns (uint256) {
189        return address(this).balance - collected;
190      }
191
192      function withdraw(address payable target) public {
193        target.transfer(collected);
194        collected = 0;
195      }
196    }
197  `);
198  }
95}199}
96  200  
97  201  
134  eth: EthGroup;238  eth: EthGroup;
135  ethAddress: EthAddressGroup;239  ethAddress: EthAddressGroup;
136  ethNativeContract: NativeContractGroup;240  ethNativeContract: NativeContractGroup;
241  ethContract: ContractGroup;
137242
138  constructor(logger: { log: (msg: any, level: any) => void, level: any }) {243  constructor(logger: { log: (msg: any, level: any) => void, level: any }) {
139    super(logger);244    super(logger);
140    this.eth = new EthGroup(this);245    this.eth = new EthGroup(this);
141    this.ethAddress = new EthAddressGroup(this);246    this.ethAddress = new EthAddressGroup(this);
142    this.ethNativeContract = new NativeContractGroup(this);247    this.ethNativeContract = new NativeContractGroup(this);
248    this.ethContract = new ContractGroup(this);
143  }249  }
144250
145  getWeb3(): Web3 {251  getWeb3(): Web3 {

--- a/tests/src/util/playgrounds/unique.ts
+++ b/tests/src/util/playgrounds/unique.ts
@@ -388,6 +388,7 @@
       type: this.chainLogType.EXTRINSIC,
       status: result.status,
       call: extrinsic,
+      signer: this.getSignerAddress(sender),
       params,
     } as IUniqueHelperLog;