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

1import {EthUniqueHelper, SponsoringMode, usingEthPlaygrounds} from '../../eth/util';1import {EthUniqueHelper, usingEthPlaygrounds} from '../../eth/util';
2import {readFile} from 'fs/promises';2import {readFile} from 'fs/promises';
3import {CollectionLimitField, ContractImports, TokenPermissionField} from '../../eth/util/playgrounds/types';3import {CollectionLimitField, ContractImports, TokenPermissionField} from '../../eth/util/playgrounds/types';
4import {4import {
5  ICrossAccountId,5  ICrossAccountId,
6  ITokenPropertyPermission,6  ITokenPropertyPermission,
7  TCollectionMode,
7} from '../../util/playgrounds/types';8} from '../../util/playgrounds/types';
8import {IKeyringPair} from '@polkadot/types/types';9import {IKeyringPair} from '@polkadot/types/types';
9import {UniqueNFTCollection} from '../../util/playgrounds/unique';10import {UniqueFTCollection, UniqueNFTCollection, UniqueRFTCollection} from '../../util/playgrounds/unique';
10import {Contract} from 'web3-eth-contract';11import {Contract} from 'web3-eth-contract';
11import {createObjectCsvWriter} from 'csv-writer';12import {createObjectCsvWriter} from 'csv-writer';
13import {FunctionFeeVM, IFunctionFee} from './types';
1214
13const CONTRACT_IMPORT: ContractImports[] = [15const CONTRACT_IMPORT: ContractImports[] = [
14  {16  {
71	evmProxyContractFee: number;73	evmProxyContractFee: number;
72	evmProxyContractBulkFee: number;74	evmProxyContractBulkFee: number;
73}75}
74interface IBenchmarkCollection {76
75  createFee: number,
76  mintFee: number,
77  transferFee: number,
78}
79const main = async () => {77const main = async () => {
80  const benchmarks = [78  const benchmarks = [
81    'substrateFee',79    'substrateFee',
101    const CONTRACT_SOURCE = (99    const CONTRACT_SOURCE = (
102      await readFile(`${__dirname}/proxyContract.sol`)100      await readFile(`${__dirname}/proxyContract.sol`)
103    ).toString();101    ).toString();
104    const ZEPPELIN_OBJECT = '0x' + (await readFile(`${__dirname}/openZeppelin/bin/ZeppelinContract.bin`)).toString();
105    const ZEPPELIN_ABI = JSON.parse((await readFile(`${__dirname}/openZeppelin/bin/ZeppelinContract.abi`)).toString());
106102
103    console.log('\n ERC20 ops fees');
104    console.table(FunctionFeeVM.fromModel(await erc20CalculateFeeGas(helper, privateKey)));
105
107    console.log('\n ERC721 ops fees');106    console.log('\n ERC721 ops fees');
108    console.table(await ERC721CalculateFeeGas(helper, privateKey), ['fee', 'gas', 'substrate']);107    const erc721 = await erc721CalculateFeeGas(helper, privateKey);
108    console.table(FunctionFeeVM.fromModel(erc721));
109109
110    const donor = await privateKey('//Alice'); // Seed from account with balance on this network110    const donor = await privateKey('//Alice'); // Seed from account with balance on this network
111    const [substrateReceiver] = await helper.arrange.createAccounts([10n], donor);
112
113    const ethSigner = await helper.eth.createAccountWithBalance(donor, 100n);111    const ethSigner = await helper.eth.createAccountWithBalance(donor, 100n);
114    const ethReceiver = await helper.eth.createAccountWithBalance(donor, 5n);
115112
116    let susbtrateCollection: UniqueNFTCollection | null;
117    const createCollectionSubstrateFee = convertToTokens(
118      await helper.arrange.calculcateFee({Substrate: donor.address}, async () => {
119        susbtrateCollection = await helper.nft.mintCollection(donor, {tokenPropertyPermissions: [
120          {
121            key: 'url',
122            permission: {
123              tokenOwner: true,
124              collectionAdmin: true,
125              mutable: true,
126            },
127          },
128        ]});
129      }),
130      NOMINAL,
131    );
132
133    const susbstrateMintFee = convertToTokens(
134      await helper.arrange.calculcateFee(
135        {Substrate: donor.address},
136        () => susbtrateCollection!.mintToken(donor, {Substrate: substrateReceiver.address}, [{key: 'url', value: 'test'}]),
137      ),
138      NOMINAL,
139    );
140    const susbstrateTransferFee = convertToTokens(
141      await helper.arrange.calculcateFee(
142        {Substrate: substrateReceiver.address},
143        () => susbtrateCollection!.transferToken(substrateReceiver, 1, {Substrate: donor.address}),
144      ),
145      NOMINAL,
146    );
147    const substrateFee: IBenchmarkCollection = {
148      createFee: createCollectionSubstrateFee,
149      mintFee: susbstrateMintFee,
150      transferFee: susbstrateTransferFee,
151    };
152
153    const helperContract = await helper.ethNativeContract.collectionHelpers(ethSigner);
154
155    let ethContract: Contract | null = null;
156
157    const createCollectionEthFee = convertToTokens(
158      await helper.arrange.calculcateFee({Ethereum: ethSigner}, async () => {
159        const result = await helperContract.methods.createNFTCollection('a', 'b', 'c').send({from: ethSigner, value: Number(2n * helper.balance.getOneTokenNominal())});
160        ethContract = await helper.ethNativeContract.collection(helper.ethAddress.normalizeAddress(result.events.CollectionCreated.returnValues.collectionId), 'nft', ethSigner);
161      }),
162      NOMINAL,
163    );
164
165    await ethContract!.methods.setTokenPropertyPermissions([
166      ['url', [
167        [TokenPermissionField.Mutable, true],
168        [TokenPermissionField.TokenOwner, true],
169        [TokenPermissionField.CollectionAdmin, true]],
170      ],
171    ]).send({from: ethSigner});
172
173    const ethMintFee = convertToTokens(await helper.arrange.calculcateFee(
174      {Ethereum: ethSigner},
175      () => ethContract!.methods.mintCross(
176        helper.ethCrossAccount.fromAddress(ethReceiver),
177        [{key: 'url', value: Buffer.from('test')}],
178      )
179        .send({from: ethSigner}),
180    ), NOMINAL);
181
182    const ethTransferFee = convertToTokens(await helper.arrange.calculcateFee(
183      {Ethereum: ethReceiver},
184      () => ethContract!.methods.transferFrom(ethReceiver, ethSigner, 1)
185        .send({from: ethReceiver}),
186    ), NOMINAL);
187
188    const ethFee: IBenchmarkCollection = {
189      createFee: createCollectionEthFee,
190      mintFee: ethMintFee,
191      transferFee: ethTransferFee,
192    };
193
194    let zeppelelinContract: Contract | null = null;
195
196    const zeppelinDeployFee = convertToTokens(
197      await helper.arrange.calculcateFee({Ethereum: ethSigner}, async () => {
198        zeppelelinContract = await helper.ethContract.deployByAbi(
199          ethSigner,
200          ZEPPELIN_ABI,
201          ZEPPELIN_OBJECT,
202        );
203      }),
204      NOMINAL,
205    );
206
207    const zeppelinMintFee = convertToTokens(await helper.arrange.calculcateFee(
208      {Ethereum: ethSigner},
209      () => zeppelelinContract!.methods.safeMint(ethReceiver, 'test').send({from: ethSigner}),
210    ), NOMINAL);
211
212
213    const zeppelinTransferFee = convertToTokens(await helper.arrange.calculcateFee(
214      {Ethereum: ethReceiver},
215      () => zeppelelinContract!.methods.safeTransferFrom(ethReceiver, ethSigner, 0).send({from: ethReceiver}),
216    ), NOMINAL);
217
218    const zeppelinFee: IBenchmarkCollection = {
219      createFee: zeppelinDeployFee,
220      mintFee: zeppelinMintFee,
221      transferFee: zeppelinTransferFee,
222    };
223
224    console.log('collection ops fees');
225    const results = {substrate: substrateFee, eth: ethFee, zeppelin: zeppelinFee};
226    console.table(results);
227
228    const contract = await helper.ethContract.deployByCode(113    const contract = await helper.ethContract.deployByCode(
229      ethSigner,114      ethSigner,
270  });155  });
271156
272async function createCollectionForBenchmarks(157async function createCollectionForBenchmarks(
158  mode : TCollectionMode,
273  helper: EthUniqueHelper,159  helper: EthUniqueHelper,
274  privateKey: (seed: string) => Promise<IKeyringPair>,160  privateKey: (seed: string) => Promise<IKeyringPair>,
275  ethSigner: string,161  ethSigner: string,
278) {164) {
279  const donor = await privateKey('//Alice');165  const donor = await privateKey('//Alice');
280166
281  const collection = await helper.nft.mintCollection(donor, {167  const collection = await helper[mode].mintCollection(donor, {
282    name: 'test mintToSubstrate',168    name: 'test mintToSubstrate',
283    description: 'EVMHelpers',169    description: 'EVMHelpers',
284    tokenPrefix: 'ap',170    tokenPrefix: mode,
171    ...(mode != 'ft' ? {
285    tokenPropertyPermissions: [172      tokenPropertyPermissions: [
286      {173        {
287        key: 'url',174          key: 'url',
288        permission: {175          permission: {
289          tokenOwner: true,176            tokenOwner: true,
290          collectionAdmin: true,177            collectionAdmin: true,
291          mutable: true,178            mutable: true,
179          },
292        },180        },
293      },181        {
294      {182          key: 'URI',
295        key: 'URI',
296        permission: {183          permission: {
297          tokenOwner: true,184            tokenOwner: true,
298          collectionAdmin: true,185            collectionAdmin: true,
299          mutable: true,186            mutable: true,
187          },
300        },188        },
301      },189      ],
302    ],190    } : {}),
303    limits: {sponsorTransferTimeout: 0, sponsorApproveTimeout: 0},191    limits: {sponsorTransferTimeout: 0, sponsorApproveTimeout: 0},
304    permissions: {mintMode: true},192    permissions: {mintMode: true},
305  });193  });
317    await collection.addToAllowList(donor, {Ethereum: proxyContract});205    await collection.addToAllowList(donor, {Ethereum: proxyContract});
318    await collection.addAdmin(donor, {Ethereum: proxyContract});206    await collection.addAdmin(donor, {Ethereum: proxyContract});
319  }207  }
208  if (collection instanceof UniqueNFTCollection || collection instanceof UniqueRFTCollection)
209    await collection.setTokenPropertyPermissions(donor, permissions);
320210
321  await collection.setTokenPropertyPermissions(donor, permissions);
322
323  return collection;211  return collection;
324}212}
325213
344    100n,232    100n,
345  );233  );
346234
347  const collection = await createCollectionForBenchmarks(235  const collection = (await createCollectionForBenchmarks(
236    'nft',
348    helper,237    helper,
349    privateKey,238    privateKey,
350    ethSigner,239    ethSigner,
351    proxyContract.options.address,240    proxyContract.options.address,
352    PERMISSIONS,241    PERMISSIONS,
353  );242  )) as UniqueNFTCollection;
354243
355  const substrateFee = await helper.arrange.calculcateFee(244  const substrateFee = await helper.arrange.calculcateFee(
356    {Substrate: donor.address},245    {Substrate: donor.address},
587  proxyContractAddress: string,476  proxyContractAddress: string,
588  calculatedCall: (collection: UniqueNFTCollection) => Promise<any>,477  calculatedCall: (collection: UniqueNFTCollection) => Promise<any>,
589): Promise<bigint> {478): Promise<bigint> {
590  const collection = await createCollectionForBenchmarks(479  const collection = (await createCollectionForBenchmarks(
480    'nft',
591    helper,481    helper,
592    privateKey,482    privateKey,
593    ethSigner,483    ethSigner,
594    proxyContractAddress,484    proxyContractAddress,
595    PERMISSIONS,485    PERMISSIONS,
596  );486  )) as UniqueNFTCollection;
597  return helper.arrange.calculcateFee(payer, async () => {487  return helper.arrange.calculcateFee(payer, async () => {
598    await calculatedCall(collection);488    await calculatedCall(collection);
599  });489  });
600}490}
491
601function convertToTokens(value: bigint, nominal = 1000_000_000_000_000_000n): number {492function convertToTokens(value: bigint, nominal = 1000_000_000_000_000_000n): number {
602  return Number((value * 1000n) / nominal) / 1000;493  return Number((value * 1000n) / nominal) / 1000;
603}494}
604495
605interface IFeeGas {
606  fee: number | bigint,
607  gas: number | bigint,
608  substrate?: number,
609}
610interface IFunctionFee {
611  [name: string]: IFeeGas
612}
613
614async function ERC721CalculateFeeGas(496async function erc721CalculateFeeGas(
615  helper: EthUniqueHelper,497  helper: EthUniqueHelper,
616  privateKey: (seed: string) => Promise<IKeyringPair>,498  privateKey: (seed: string) => Promise<IKeyringPair>,
617499
623  const ethReceiver = await helper.eth.createAccountWithBalance(donor, 10n);505  const ethReceiver = await helper.eth.createAccountWithBalance(donor, 10n);
624  const crossSigner = helper.ethCrossAccount.fromAddress(ethSigner);506  const crossSigner = helper.ethCrossAccount.fromAddress(ethSigner);
625  const crossReceiver = helper.ethCrossAccount.fromAddress(ethReceiver);507  const crossReceiver = helper.ethCrossAccount.fromAddress(ethReceiver);
626  const collection = await createCollectionForBenchmarks(508  const collection = (await createCollectionForBenchmarks(
509    'nft',
627    helper,510    helper,
628    privateKey,511    privateKey,
629    ethSigner,512    ethSigner,
630    null,513    null,
631    PERMISSIONS,514    PERMISSIONS,
632  );515  )) as UniqueNFTCollection;
633516
517  const helperContract = await helper.ethNativeContract.collectionHelpers(ethSigner);
518  let zeppelelinContract: Contract | null = null;
519  const ZEPPELIN_OBJECT = '0x' + (await readFile(`${__dirname}/openZeppelin/ERC721/bin/ZeppelinContract.bin`)).toString();
520  const ZEPPELIN_ABI = JSON.parse((await readFile(`${__dirname}/openZeppelin/ERC721/bin/ZeppelinContract.abi`)).toString());
521
634  const evmContract = await helper.ethNativeContract.collection(522  const evmContract = await helper.ethNativeContract.collection(
635    helper.ethAddress.fromCollectionId(collection.collectionId),523    helper.ethAddress.fromCollectionId(collection.collectionId),
636    'nft',524    'nft',
637    ethSigner,525    ethSigner,
638    true,526    true,
639  );527  );
640528
529  res['createCollection'] = await helper.arrange.calculcateFeeGas(
530    {Ethereum: ethSigner},
531    () => helperContract.methods.createNFTCollection('test','test','test').send({from: ethSigner, value: Number(2n * helper.balance.getOneTokenNominal())}),
532  );
533
534  res['createCollection'].substrate = convertToTokens((await helper.arrange.calculcateFee(
535    {Substrate: donor.address},
536    () => helper.nft.mintCollection(
537      donor,
538      {name: 'test', description: 'test', tokenPrefix: 'test'},
539    ),
540  )));
541
542  res['createCollection'].zeppelin = await helper.arrange.calculcateFeeGas(
543    {Ethereum: ethSigner},
544    async () => {
545      zeppelelinContract = await helper.ethContract.deployByAbi(
546        ethSigner,
547        ZEPPELIN_ABI,
548        ZEPPELIN_OBJECT,
549      );
550    },
551  );
552
641  res['mint'] =553  res['mint'] =
642    await helper.arrange.calculcateFeeGas(554    await helper.arrange.calculcateFeeGas(
643      {Ethereum: ethSigner},555      {Ethereum: ethSigner},
644      () => evmContract.methods.mint(ethSigner).send(),556      () => evmContract.methods.mint(ethSigner).send(),
645    );557    );
646558
559  res['mint'].zeppelin =
560    await helper.arrange.calculcateFeeGas(
561      {Ethereum: ethSigner},
562      () => zeppelelinContract!.methods.safeMint(ethSigner, 'test').send({from: ethSigner}),
563    );
564
647  res['mintCross'] =565  res['mintCross'] =
648    await helper.arrange.calculcateFeeGas(566    await helper.arrange.calculcateFeeGas(
649      {Ethereum: ethSigner},567      {Ethereum: ethSigner},
717      () => evmContract.methods.transfer(ethReceiver, 1).send(),635      () => evmContract.methods.transfer(ethReceiver, 1).send(),
718    );636    );
719637
638  res['safeTransferFrom*'] = {
639    zeppelin:
640      await helper.arrange.calculcateFeeGas(
641        {Ethereum: ethSigner},
642        () => zeppelelinContract!.methods.safeTransferFrom(ethSigner, ethReceiver, 0).send({from: ethSigner}),
643      ),
644  };
645
720  res['transferCross'] =646  res['transferCross'] =
721    await helper.arrange.calculcateFeeGas(647    await helper.arrange.calculcateFeeGas(
722      {Ethereum: ethReceiver},648      {Ethereum: ethReceiver},
733  )));659  )));
734  await collection.approveToken(subReceiver, 3, {Substrate: donor.address});660  await collection.approveToken(subReceiver, 3, {Substrate: donor.address});
735661
736  res['transferFrom'] =662  res['transferFrom*'] =
737    await helper.arrange.calculcateFeeGas(663    await helper.arrange.calculcateFeeGas(
738      {Ethereum: ethSigner},664      {Ethereum: ethSigner},
739      () => evmContract.methods.transferFrom(ethSigner, ethReceiver, 1).send(),665      () => evmContract.methods.transferFrom(ethSigner, ethReceiver, 1).send(),
740    );666    );
741667
668  res['transferFrom*'].zeppelin =
669    await helper.arrange.calculcateFeeGas(
670      {Ethereum: ethReceiver},
671      () => zeppelelinContract!.methods.transferFrom(ethReceiver, ethSigner, 0).send({from: ethReceiver}),
672    );
673
674
742  res['transferFromCross'] =675  res['transferFromCross'] =
743    await helper.arrange.calculcateFeeGas(676    await helper.arrange.calculcateFeeGas(
744      {Ethereum: ethReceiver},677      {Ethereum: ethReceiver},
761    () => collection.burnToken(donor, 3),694    () => collection.burnToken(donor, 3),
762  )));695  )));
763696
697  res['approve*'] =
698    await helper.arrange.calculcateFeeGas(
699      {Ethereum: ethSigner},
700      () => evmContract.methods.approve(ethReceiver, 2).send(),
701    );
764702
703  res['approve*'].zeppelin =
704    await helper.arrange.calculcateFeeGas(
705      {Ethereum: ethSigner},
706      () => zeppelelinContract!.methods.approve(ethReceiver, 0).send({from: ethSigner}),
707    );
708
765  res['approveCross'] =709  res['approveCross'] =
766    await helper.arrange.calculcateFeeGas(710    await helper.arrange.calculcateFeeGas(
767      {Ethereum: ethSigner},711      {Ethereum: ethSigner},
773    () => collection.approveToken(donor, 4, {Substrate: subReceiver.address}),717    () => collection.approveToken(donor, 4, {Substrate: subReceiver.address}),
774  )));718  )));
775719
720  res['setApprovalForAll*'] =
721    await helper.arrange.calculcateFeeGas(
722      {Ethereum: ethSigner},
723      () => evmContract.methods.setApprovalForAll(ethReceiver, true).send(),
724    );
725
726  res['setApprovalForAll*'].zeppelin =
727    await helper.arrange.calculcateFeeGas(
728      {Ethereum: ethSigner},
729      () => zeppelelinContract!.methods.setApprovalForAll(ethReceiver, true).send({from: ethSigner}),
730    );
731
732  res['setApprovalForAll*'].substrate = convertToTokens((await helper.arrange.calculcateFee(
733    {Substrate: donor.address},
734    () => helper.nft.setAllowanceForAll(donor, collection.collectionId, {Substrate: subReceiver.address}, true),
735  )));
736
776  res['burnFromCross'] =737  res['burnFromCross'] =
777    await helper.arrange.calculcateFeeGas(738    await helper.arrange.calculcateFeeGas(
778      {Ethereum: ethReceiver},739      {Ethereum: ethReceiver},
803      collectionAdmin: true,764      collectionAdmin: true,
804      mutable: true,765      mutable: true,
805    }}]),766    }}]),
767  )));
768
769  res['setCollectionSponsorCross'] =
770    await helper.arrange.calculcateFeeGas(
771      {Ethereum: ethSigner},
772      () =>  evmContract.methods.setCollectionSponsorCross(crossReceiver).send(),
773    );
774
775  res['confirmCollectionSponsorship'] =
776    await helper.arrange.calculcateFeeGas(
777      {Ethereum: ethReceiver},
778      () =>  evmContract.methods.confirmCollectionSponsorship().send({from: ethReceiver}),
779    );
780
781  res['removeCollectionSponsor'] =
782    await helper.arrange.calculcateFeeGas(
783      {Ethereum: ethSigner},
784      () =>  evmContract.methods.removeCollectionSponsor().send(),
785    );
786
787  res['setCollectionSponsorCross'].substrate = convertToTokens((await helper.arrange.calculcateFee(
788    {Substrate: donor.address},
789    () => collection.setSponsor(donor, subReceiver.address),
790  )));
791
792  res['confirmCollectionSponsorship'].substrate = convertToTokens((await helper.arrange.calculcateFee(
793    {Substrate: subReceiver.address},
794    () => collection.confirmSponsorship(subReceiver),
795  )));
796
797  res['removeCollectionSponsor'].substrate = convertToTokens((await helper.arrange.calculcateFee(
798    {Substrate: donor.address},
799    () => collection.removeSponsor(donor),
800  )));
801
802  res['setCollectionProperties'] =
803    await helper.arrange.calculcateFeeGas(
804      {Ethereum: ethSigner},
805      () => evmContract.methods.setCollectionProperties(PROPERTIES.slice(0, 1)).send(),
806    );
807
808  res['deleteCollectionProperties'] =
809    await helper.arrange.calculcateFeeGas(
810      {Ethereum: ethSigner},
811      () =>  evmContract.methods.deleteCollectionProperties(PROPERTIES.slice(0,1).map(p => p.key)).send(),
812    );
813  res['setCollectionProperties'].substrate = convertToTokens((await helper.arrange.calculcateFee(
814    {Substrate: donor.address},
815    () => collection.setProperties(donor, PROPERTIES.slice(0, 1)
816      .map(p => { return {key: p.key, value: p.value.toString()}; })),
817  )));
818
819  res['deleteCollectionProperties'].substrate = convertToTokens((await helper.arrange.calculcateFee(
820    {Substrate: donor.address},
821    () => collection.deleteProperties(donor, PROPERTIES.slice(0, 1)
822      .map(p => p.key)),
823  )));
824
825  res['setCollectionLimit'] =
826    await helper.arrange.calculcateFeeGas(
827      {Ethereum: ethSigner},
828      () =>  evmContract.methods.setCollectionLimit({field: CollectionLimitField.AccountTokenOwnership, value: {status: true, value: 1000}}).send(),
829    );
830
831  res['setCollectionLimit'].substrate = convertToTokens((await helper.arrange.calculcateFee(
832    {Substrate: donor.address},
833    () => collection.setLimits(donor, {accountTokenOwnershipLimit: 1000}),
834  )));
835
836  const {collectionAddress} = await helper.eth.createCollection('nft', ethSigner, 'A', 'B', 'C');
837  const collectionWithEthOwner = await helper.ethNativeContract.collection(collectionAddress, 'nft', ethSigner, true);
838
839
840  res['addCollectionAdminCross'] =
841    await helper.arrange.calculcateFeeGas(
842      {Ethereum: ethSigner},
843      () =>  collectionWithEthOwner.methods.addCollectionAdminCross(crossReceiver).send(),
844    );
845
846  res['removeCollectionAdminCross'] =
847    await helper.arrange.calculcateFeeGas(
848      {Ethereum: ethSigner},
849      () =>  collectionWithEthOwner.methods.removeCollectionAdminCross(crossReceiver).send(),
850    );
851
852  res['addCollectionAdminCross'].substrate = convertToTokens((await helper.arrange.calculcateFee(
853    {Substrate: donor.address},
854    () => collection.addAdmin(donor, {Ethereum: ethReceiver}),
855  )));
856
857  res['removeCollectionAdminCross'].substrate = convertToTokens((await helper.arrange.calculcateFee(
858    {Substrate: donor.address},
859    () => collection.removeAdmin(donor, {Ethereum: ethReceiver}),
860  )));
861
862  res['setCollectionNesting'] =
863    await helper.arrange.calculcateFeeGas(
864      {Ethereum: ethSigner},
865      () =>  evmContract.methods.setCollectionNesting(true).send(),
866    );
867
868  res['setCollectionNesting[]'] =
869    await helper.arrange.calculcateFeeGas(
870      {Ethereum: ethSigner},
871      () =>  evmContract.methods.setCollectionNesting(true, [collectionAddress]).send(),
872    );
873
874  res['setCollectionNesting'].substrate = convertToTokens((await helper.arrange.calculcateFee(
875    {Substrate: donor.address},
876    () => collection.disableNesting(donor),
877  )));
878
879  res['setCollectionNesting[]'].substrate = convertToTokens((await helper.arrange.calculcateFee(
880    {Substrate: donor.address},
881    () => collection.setPermissions(
882      donor,
883      {
884        nesting: {
885          tokenOwner: true,
886          restricted: [collection.collectionId],
887        },
888      },
889    ),
890  )));
891
892  res['setCollectionAccess'] =
893    await helper.arrange.calculcateFeeGas(
894      {Ethereum: ethSigner},
895      () =>  evmContract.methods.setCollectionAccess(1).send(),
896    );
897
898  res['setCollectionAccess'].substrate = convertToTokens((await helper.arrange.calculcateFee(
899    {Substrate: donor.address},
900    () => collection.setPermissions(donor, {access: 'AllowList'}),
901  )));
902
903  res['addToCollectionAllowListCross'] =
904    await helper.arrange.calculcateFeeGas(
905      {Ethereum: ethSigner},
906      () =>  evmContract.methods.addToCollectionAllowListCross(crossReceiver).send(),
907    );
908
909  res['removeFromCollectionAllowListCross'] =
910    await helper.arrange.calculcateFeeGas(
911      {Ethereum: ethSigner},
912      () =>  evmContract.methods.removeFromCollectionAllowListCross(crossReceiver).send(),
913    );
914
915  res['addToCollectionAllowListCross'].substrate = convertToTokens((await helper.arrange.calculcateFee(
916    {Substrate: donor.address},
917    () => collection.addToAllowList(donor, {Ethereum: ethReceiver}),
918  )));
919
920  res['removeFromCollectionAllowListCross'].substrate = convertToTokens((await helper.arrange.calculcateFee(
921    {Substrate: donor.address},
922    () => collection.removeFromAllowList(donor, {Ethereum: ethReceiver}),
923  )));
924
925  res['setCollectionMintMode'] =
926    await helper.arrange.calculcateFeeGas(
927      {Ethereum: ethSigner},
928      () =>  evmContract.methods.setCollectionMintMode(true).send(),
929    );
930
931  res['setCollectionMintMode'].substrate = convertToTokens((await helper.arrange.calculcateFee(
932    {Substrate: donor.address},
933    () => collection.setPermissions(donor, {mintMode: false}),
934  )));
935
936  res['changeCollectionOwnerCross'] =
937    await helper.arrange.calculcateFeeGas(
938      {Ethereum: ethSigner},
939      () =>  collectionWithEthOwner.methods.changeCollectionOwnerCross(crossReceiver).send(),
940    );
941
942  res['changeCollectionOwnerCross'].substrate = convertToTokens((await helper.arrange.calculcateFee(
943    {Substrate: donor.address},
944    () => collection.changeOwner(donor, subReceiver.address),
945  )));
946
947  return res;
948}
949
950async function erc20CalculateFeeGas(
951  helper: EthUniqueHelper,
952  privateKey: (seed: string) => Promise<IKeyringPair>,
953
954): Promise<IFunctionFee> {
955  const res: IFunctionFee = {};
956  const donor = await privateKey('//Alice');
957  const [subReceiver] = await helper.arrange.createAccounts([10n], donor);
958  const ethSigner = await helper.eth.createAccountWithBalance(donor, 100n);
959  const ethReceiver = await helper.eth.createAccountWithBalance(donor, 10n);
960  const crossSigner = helper.ethCrossAccount.fromAddress(ethSigner);
961  const crossReceiver = helper.ethCrossAccount.fromAddress(ethReceiver);
962  const collection = (await createCollectionForBenchmarks(
963    'ft',
964    helper,
965    privateKey,
966    ethSigner,
967    null,
968    PERMISSIONS,
969  )) as UniqueFTCollection;
970
971  const helperContract = await helper.ethNativeContract.collectionHelpers(ethSigner);
972  let zeppelelinContract: Contract | null = null;
973  const ZEPPELIN_OBJECT = '0x' + (await readFile(`${__dirname}/openZeppelin/ERC20/bin/ZeppelinContract.bin`)).toString();
974  const ZEPPELIN_ABI = JSON.parse((await readFile(`${__dirname}/openZeppelin/ERC20/bin/ZeppelinContract.abi`)).toString());
975
976  const evmContract = await helper.ethNativeContract.collection(
977    helper.ethAddress.fromCollectionId(collection.collectionId),
978    'ft',
979    ethSigner,
980    true,
981  );
982
983  res['createCollection'] = await helper.arrange.calculcateFeeGas(
984    {Ethereum: ethSigner},
985    () => helperContract.methods.createFTCollection('test', 18,'test','test').send({from: ethSigner, value: Number(2n * helper.balance.getOneTokenNominal())}),
986  );
987
988  res['createCollection'].substrate = convertToTokens((await helper.arrange.calculcateFee(
989    {Substrate: donor.address},
990    () => helper.ft.mintCollection(
991      donor,
992      {name: 'test', description: 'test', tokenPrefix: 'test'},
993      18,
994    ),
995  )));
996
997  res['createCollection'].zeppelin = await helper.arrange.calculcateFeeGas(
998    {Ethereum: ethSigner},
999    async () => {
1000      zeppelelinContract = await helper.ethContract.deployByAbi(
1001        ethSigner,
1002        ZEPPELIN_ABI,
1003        ZEPPELIN_OBJECT,
1004      );
1005    },
1006  );
1007
1008  res['mint'] =
1009    await helper.arrange.calculcateFeeGas(
1010      {Ethereum: ethSigner},
1011      () => evmContract.methods.mint(ethSigner, 1).send(),
1012    );
1013
1014  res['mint'].zeppelin =
1015    await helper.arrange.calculcateFeeGas(
1016      {Ethereum: ethSigner},
1017      () => zeppelelinContract!.methods.mint(ethSigner, 1).send(),
1018    );
1019
1020  res['mintCross'] =
1021    await helper.arrange.calculcateFeeGas(
1022      {Ethereum: ethSigner},
1023      () => evmContract.methods.mintCross(crossSigner, 1).send(),
1024    );
1025
1026  res['mintCross'].substrate = convertToTokens((await helper.arrange.calculcateFee(
1027    {Substrate: donor.address},
1028    () => collection.mint(
1029      donor,
1030      10n,
1031      {Substrate: donor.address},
1032    ),
1033  )));
1034
1035  res['mintBulk'] =
1036    await helper.arrange.calculcateFeeGas(
1037      {Ethereum: ethSigner},
1038      () => evmContract.methods.mintBulk([{field_0: ethSigner, field_1: 1}]).send(),
1039    );
1040
1041  res['mintBulk'].substrate = convertToTokens((await helper.arrange.calculcateFee(
1042    {Substrate: donor.address},
1043    () => helper.executeExtrinsic(donor, 'api.tx.unique.createMultipleItemsEx',[collection.collectionId, {
1044      Fungible: new Map([
1045        [JSON.stringify({Ethereum: ethSigner}), 1],
1046
1047      ]),
1048    }], true),
1049  )));
1050
1051  res['transfer*'] =
1052    await helper.arrange.calculcateFeeGas(
1053      {Ethereum: ethSigner},
1054      () => evmContract.methods.transfer(ethReceiver, 1).send(),
1055    );
1056
1057  res['transfer*'].zeppelin =
1058    await helper.arrange.calculcateFeeGas(
1059      {Ethereum: ethSigner},
1060      () => zeppelelinContract!.methods.transfer(ethReceiver, 1).send(),
1061    );
1062
1063  res['transferCross'] =
1064    await helper.arrange.calculcateFeeGas(
1065      {Ethereum: ethReceiver},
1066      () => evmContract.methods.transferCross(crossSigner, 1).send({from: ethReceiver}),
1067    );
1068
1069  res['transferCross'].substrate = convertToTokens((await helper.arrange.calculcateFee(
1070    {Substrate: donor.address},
1071    () => collection.transfer(
1072      donor,
1073      {Substrate: subReceiver.address},
1074      1n,
1075    ),
1076  )));
1077  await collection.approveTokens(subReceiver, {Substrate: donor.address}, 1n);
1078
1079  res['transferFrom*'] =
1080    await helper.arrange.calculcateFeeGas(
1081      {Ethereum: ethSigner},
1082      () => evmContract.methods.transferFrom(ethSigner, ethReceiver, 1).send(),
1083    );
1084
1085  res['transferFrom*'].zeppelin =
1086    await helper.arrange.calculcateFeeGas(
1087      {Ethereum: ethReceiver},
1088      () => zeppelelinContract!.methods.transferFrom(ethReceiver, ethSigner, 0).send({from: ethReceiver}),
1089    );
1090
1091  res['transferFromCross'] =
1092    await helper.arrange.calculcateFeeGas(
1093      {Ethereum: ethReceiver},
1094      () => evmContract.methods.transferFromCross(crossReceiver, crossSigner, 1).send({from:ethReceiver}),
1095    );
1096
1097  res['transferFromCross'].substrate = convertToTokens((await helper.arrange.calculcateFee(
1098    {Substrate: donor.address},
1099    () => collection.transferFrom(donor, {Substrate: subReceiver.address}, {Substrate: donor.address}, 1n),
1100  )));
1101
1102
1103  res['burnTokens'] = {fee: 0n, gas: 0n};
1104  res['burnTokens'].substrate = convertToTokens((await helper.arrange.calculcateFee(
1105    {Substrate: donor.address},
1106    () => collection.burnTokens(donor, 1n),
1107  )));
1108
1109
1110  res['approve*'] =
1111    await helper.arrange.calculcateFeeGas(
1112      {Ethereum: ethSigner},
1113      () => evmContract.methods.approve(ethReceiver, 2).send(),
1114    );
1115
1116  res['approve*'].zeppelin =
1117    await helper.arrange.calculcateFeeGas(
1118      {Ethereum: ethSigner},
1119      () => zeppelelinContract!.methods.approve(ethReceiver, 0).send(),
1120    );
1121
1122  res['approveCross'] =
1123    await helper.arrange.calculcateFeeGas(
1124      {Ethereum: ethSigner},
1125      () => evmContract.methods.approveCross(crossReceiver, 2).send(),
1126    );
1127
1128  res['approveCross'].substrate = convertToTokens((await helper.arrange.calculcateFee(
1129    {Substrate: donor.address},
1130    () => collection.approveTokens(donor, {Substrate: subReceiver.address}, 1n),
1131  )));
1132
1133  res['burnFromCross'] =
1134    await helper.arrange.calculcateFeeGas(
1135      {Ethereum: ethReceiver},
1136      () => evmContract.methods.burnFromCross(crossSigner, 1).send({from:ethReceiver}),
1137    );
1138
1139  res['burnFromCross'].substrate = convertToTokens((await helper.arrange.calculcateFee(
1140    {Substrate: subReceiver.address},
1141    () => collection.burnTokensFrom(subReceiver, {Substrate: donor.address}, 1n),
806  )));1142  )));
8071143
808  res['setCollectionSponsorCross'] =1144  res['setCollectionSponsorCross'] =