git.delta.rocks / unique-network / refs/commits / 516483006d10

--- a/docker-compose-tests-parachain.yml
+++ b/docker-compose-tests-parachain.yml
@@ -7,7 +7,7 @@
     ports:
       - 9944:9944
       - 9844:9844
-      - 9933:9934
+      - 9933:9933
     build:
       context: ./
       dockerfile: Dockerfile-parachain
@@ -19,7 +19,6 @@
     volumes:
 #      - ./chain-data:/chain-data
       - ./launch-config.json:/polkadot-launch/launch-config.json
-      - ./runtime_types.json:/polkadot-launch/runtime_types.json
     env_file:
       - ./.env
     networks:
@@ -34,11 +33,10 @@
       context: tests/
       dockerfile: Dockerfile-tests
     environment:
-      RPC_URL: http://blockchain_nodes:9934/
+      RPC_URL: http://blockchain_nodes:9933/
     volumes:
       - ./tests/src/config_docker.ts:/nft_parachain/src/config.ts
       - /home/ubuntu/mochawesome-report:/nft_parachain/mochawesome-report
-      - ./runtime_types.json:/runtime_types.json
 #    command: bash -c 'while true; do sleep 20; df -h; done'
     networks:
       - node_test_network

--- a/examples/re-fungible/create_collection.js
+++ b/examples/re-fungible/create_collection.js
@@ -8,7 +8,7 @@
       const unsub = await transaction
       .signAndSend(sender, (result) => {
         console.log(`Current tx status is ${result.status}`);
-    
+
         if (result.status.isInBlock) {
           console.log(`Transaction included at blockHash ${result.status.asInBlock}`);
           resolve();
@@ -33,7 +33,7 @@
   const description = [67, 111, 108, 108, 101, 99, 116, 105, 111, 110, 32, 111, 102, 32, 112, 104, 111, 116, 111, 115];
   // ART
   const tokenPrefix = [65, 82, 84];
-  
+
   // Mode: Re-Fungible
   const tx = api.tx.nft.createCollection(name, description, tokenPrefix, {"ReFungible": [config.collectionDataSize, config.decimalPoints]});
   await submitTransaction(alice, tx);
@@ -45,18 +45,15 @@
 async function main() {
   // Initialise the provider to connect to the node
   const wsProvider = new WsProvider(config.wsEndpoint);
-  const rtt = JSON.parse(fs.readFileSync("runtime_types.json"));
-
   // Create the API and wait until ready
-  const api = await ApiPromise.create({ 
+  const api = await ApiPromise.create({
     provider: wsProvider,
-    types: rtt
   });
 
   // Owners's keypair
   const keyring = new Keyring({ type: 'sr25519' });
   const owner = keyring.addFromUri(config.ownerSeed);
-  console.log("Collection owner address: ", owner.address);  
+  console.log("Collection owner address: ", owner.address);
 
   // Create collection as owner
   console.log("=== Create collection ===");

--- a/examples/testnft/create_collection.js
+++ b/examples/testnft/create_collection.js
@@ -9,7 +9,7 @@
       const unsub = await transaction
       .signAndSend(sender, (result) => {
         console.log(`Current tx status is ${result.status}`);
-    
+
         if (result.status.isInBlock) {
           console.log(`Transaction included at blockHash ${result.status.asInBlock}`);
           resolve();
@@ -34,7 +34,7 @@
   const description = [0x54, 0x65, 0x73, 0x74, 0x20, 0x4e, 0x46, 0x54, 0x20, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e];
   // TestNFT
   const tokenPrefix = [0x54, 0x65, 0x73, 0x74, 0x4e, 0x46, 0x54];
-  
+
   // Mode: NFT
   const tx = api.tx.nft.createCollection(name, description, tokenPrefix, {"NFT": config.collectionDataSize});
   await submitTransaction(alice, tx);
@@ -48,18 +48,16 @@
 async function main() {
   // Initialise the provider to connect to the node
   const wsProvider = new WsProvider(config.wsEndpoint);
-  const rtt = JSON.parse(fs.readFileSync("runtime_types.json"));
 
   // Create the API and wait until ready
-  const api = await ApiPromise.create({ 
+  const api = await ApiPromise.create({
     provider: wsProvider,
-    types: rtt
   });
 
   // Owners's keypair
   const keyring = new Keyring({ type: 'sr25519' });
   const owner = keyring.addFromUri(config.ownerSeed);
-  console.log("Collection owner address: ", owner.address);  
+  console.log("Collection owner address: ", owner.address);
 
   // Create collection as owner
   console.log("=== Create collection ===");

--- a/examples/testnft/create_tokens.js
+++ b/examples/testnft/create_tokens.js
@@ -17,7 +17,7 @@
       .createItem(collectionId, "0x", admin.address)
       .signAndSend(admin, (result) => {
         console.log(`Current tx status is ${result.status}`);
-    
+
         if (result.status.isInBlock) {
           console.log(`Transaction included at blockHash ${result.status.asInBlock}`);
           resolve();
@@ -34,12 +34,10 @@
 async function main() {
   // Initialise the provider to connect to the node
   const wsProvider = new WsProvider(config.wsEndpoint);
-  const rtt = require("./runtime_types.json");
 
   // Create the API and wait until ready
-  const api = await ApiPromise.create({ 
+  const api = await ApiPromise.create({
     provider: wsProvider,
-    types: rtt
   });
 
   // Retrieve the chain & node information information via rpc calls
@@ -53,7 +51,7 @@
   console.log(`You are connected to chain ${chain} using ${nodeName} v${nodeVersion}`);
   console.log(`Collection: ${collection}`);
 
-  if (checkOwner(collection.Owner.toString())) {
+  if (checkOwner(collection.owner.toString())) {
     // Import account from mnemonic phrase in config file
     const keyring = new Keyring({ type: 'sr25519' });
     const owner = keyring.addFromUri(config.ownerSeed);

--- a/launch-config.json
+++ b/launch-config.json
@@ -88,6 +88,5 @@
     ],
     "simpleParachains": [],
     "hrmpChannels": [],
-    "types": "./runtime_types.json",
     "finalization": false
 }

--- a/launch-test-env.sh
+++ b/launch-test-env.sh
@@ -1,7 +1,6 @@
 cp launch-config.json ../polkadot-launch/launch-config.json
-cp runtime_types.json ../polkadot-launch/runtime_types.json
 
 cd ../polkadot-launch
 yarn install
 yarn build
-yarn start launch-config.json
\ No newline at end of file
+yarn start launch-config.json

--- a/tests/src/addCollectionAdmin.test.ts
+++ b/tests/src/addCollectionAdmin.test.ts
@@ -21,7 +21,7 @@
       const bob = privateKey('//Bob');
 
       const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();
-      expect(collection.Owner).to.be.equal(alice.address);
+      expect(collection.owner).to.be.equal(alice.address);
 
       const changeAdminTx = api.tx.nft.addCollectionAdmin(collectionId, normalizeAccountId(bob.address));
       await submitTransactionAsync(alice, changeAdminTx);
@@ -39,7 +39,7 @@
       const Charlie = privateKey('//CHARLIE');
 
       const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();
-      expect(collection.Owner).to.be.equal(Alice.address);
+      expect(collection.owner).to.be.equal(Alice.address);
 
       const changeAdminTx = api.tx.nft.addCollectionAdmin(collectionId, normalizeAccountId(Bob.address));
       await submitTransactionAsync(Alice, changeAdminTx);

--- a/tests/src/approve.test.ts
+++ b/tests/src/approve.test.ts
@@ -173,7 +173,7 @@
   it('fails when called by collection owner on non-owned item when OwnerCanTransfer == false', async () => {
     const collectionId = await createCollectionExpectSuccess();
     const itemId = await createItemExpectSuccess(Alice, collectionId, 'NFT', Bob.address);
-    await setCollectionLimitsExpectSuccess(Alice, collectionId, { OwnerCanTransfer: false });
+    await setCollectionLimitsExpectSuccess(Alice, collectionId, { ownerCanTransfer: false });
 
     await approveExpectFail(collectionId, itemId, Alice, Charlie);
   });

--- a/tests/src/burnItem.test.ts
+++ b/tests/src/burnItem.test.ts
@@ -6,8 +6,8 @@
 import { default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync } from './substrate/substrate-api';
 import { Keyring } from '@polkadot/api';
 import { IKeyringPair } from '@polkadot/types/types';
-import { 
-  createCollectionExpectSuccess, 
+import {
+  createCollectionExpectSuccess,
   createItemExpectSuccess,
   getGenericResult,
   destroyCollectionExpectSuccess,
@@ -62,14 +62,14 @@
       const tx = api.tx.nft.burnItem(collectionId, tokenId, 1);
       const events = await submitTransactionAsync(alice, tx);
       const result = getGenericResult(events);
-  
-      // Get alice balance 
+
+      // Get alice balance
       const balance: any = (await api.query.nft.fungibleItemList(collectionId, alice.address)).toJSON();
- 
+
       // What to expect
       expect(result.success).to.be.true;
       expect(balance).to.be.not.null;
-      expect(balance.Value).to.be.equal(9);
+      expect(balance.value).to.be.equal(9);
     });
   });
 
@@ -82,10 +82,10 @@
       const tx = api.tx.nft.burnItem(collectionId, tokenId, 1);
       const events = await submitTransactionAsync(alice, tx);
       const result = getGenericResult(events);
-  
-      // Get alice balance 
+
+      // Get alice balance
       const balance: any = (await api.query.nft.reFungibleItemList(collectionId, tokenId)).toJSON();
-      
+
       // What to expect
       expect(result.success).to.be.true;
       expect(balance).to.be.null;
@@ -111,25 +111,25 @@
       const events2 = await submitTransactionAsync(bob, tx);
       const result2 = getGenericResult(events2);
 
-      // Get balances 
+      // Get balances
       const balance: any = (await api.query.nft.reFungibleItemList(collectionId, tokenId)).toJSON();
       // console.log(balance);
-      
+
       // What to expect before burning
       expect(result1.success).to.be.true;
       expect(balanceBefore).to.be.not.null;
-      expect(balanceBefore.Owner.length).to.be.equal(2);
-      expect(balanceBefore.Owner[0].Owner).to.be.deep.equal(normalizeAccountId(alice.address));
-      expect(balanceBefore.Owner[0].Fraction).to.be.equal(99);
-      expect(balanceBefore.Owner[1].Owner).to.be.deep.equal(normalizeAccountId(bob.address));
-      expect(balanceBefore.Owner[1].Fraction).to.be.equal(1);
+      expect(balanceBefore.owner.length).to.be.equal(2);
+      expect(balanceBefore.owner[0].owner).to.be.deep.equal(normalizeAccountId(alice.address));
+      expect(balanceBefore.owner[0].fraction).to.be.equal(99);
+      expect(balanceBefore.owner[1].owner).to.be.deep.equal(normalizeAccountId(bob.address));
+      expect(balanceBefore.owner[1].fraction).to.be.equal(1);
 
       // What to expect after burning
       expect(result2.success).to.be.true;
       expect(balance).to.be.not.null;
-      expect(balance.Owner.length).to.be.equal(1);
-      expect(balance.Owner[0].Fraction).to.be.equal(99);
-      expect(balance.Owner[0].Owner).to.be.deep.equal(normalizeAccountId(alice.address));
+      expect(balance.owner.length).to.be.equal(1);
+      expect(balance.owner[0].fraction).to.be.equal(99);
+      expect(balance.owner[0].owner).to.be.deep.equal(normalizeAccountId(alice.address));
     });
 
   });
@@ -183,7 +183,7 @@
 
     await usingApi(async (api) => {
       const tx = api.tx.nft.burnItem(collectionId, tokenId, 0);
-      const badTransaction = async function () { 
+      const badTransaction = async function () {
         await submitTransactionExpectFailAsync(alice, tx);
       };
       await expect(badTransaction()).to.be.rejected;
@@ -198,7 +198,7 @@
 
     await usingApi(async (api) => {
       const tx = api.tx.nft.burnItem(collectionId, tokenId, 0);
-      const badTransaction = async function () { 
+      const badTransaction = async function () {
         await submitTransactionExpectFailAsync(alice, tx);
       };
       await expect(badTransaction()).to.be.rejected;
@@ -213,7 +213,7 @@
 
     await usingApi(async (api) => {
       const tx = api.tx.nft.burnItem(collectionId, tokenId, 0);
-      const badTransaction = async function () { 
+      const badTransaction = async function () {
         await submitTransactionExpectFailAsync(bob, tx);
       };
       await expect(badTransaction()).to.be.rejected;
@@ -232,9 +232,9 @@
       const events1 = await submitTransactionAsync(alice, burntx);
       const result1 = getGenericResult(events1);
       expect(result1.success).to.be.true;
-  
+
       const tx = api.tx.nft.transfer(normalizeAccountId(bob.address), collectionId, tokenId, 0);
-      const badTransaction = async function () { 
+      const badTransaction = async function () {
         await submitTransactionExpectFailAsync(alice, tx);
       };
       await expect(badTransaction()).to.be.rejected;
@@ -252,17 +252,17 @@
     await usingApi(async (api) => {
       // Destroy 11 of 10
       const tx = api.tx.nft.burnItem(collectionId, tokenId, 11);
-      const badTransaction = async function () { 
+      const badTransaction = async function () {
         await submitTransactionExpectFailAsync(alice, tx);
       };
       await expect(badTransaction()).to.be.rejected;
-      
-      // Get alice balance 
+
+      // Get alice balance
       const balance: any = (await api.query.nft.fungibleItemList(collectionId, alice.address)).toJSON();
- 
+
       // What to expect
       expect(balance).to.be.not.null;
-      expect(balance.Value).to.be.equal(10);
+      expect(balance.value).to.be.equal(10);
     });
 
   });

--- a/tests/src/change-collection-owner.test.ts
+++ b/tests/src/change-collection-owner.test.ts
@@ -7,7 +7,7 @@
 import chaiAsPromised from 'chai-as-promised';
 import privateKey from './substrate/privateKey';
 import { default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync } from './substrate/substrate-api';
-import { createCollectionExpectSuccess, 
+import { createCollectionExpectSuccess,
   addCollectionAdminExpectSuccess,
   setCollectionSponsorExpectSuccess,
   confirmSponsorshipExpectSuccess,
@@ -35,13 +35,13 @@
       const bob = privateKey('//Bob');
 
       const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();
-      expect(collection.Owner).to.be.deep.eq(alice.address);
+      expect(collection.owner).to.be.deep.eq(alice.address);
 
       const changeOwnerTx = api.tx.nft.changeCollectionOwner(collectionId, bob.address);
       await submitTransactionAsync(alice, changeOwnerTx);
 
       const collectionAfterOwnerChange: any = (await api.query.nft.collectionById(collectionId)).toJSON();
-      expect(collectionAfterOwnerChange.Owner).to.be.deep.eq(bob.address);
+      expect(collectionAfterOwnerChange.owner).to.be.deep.eq(bob.address);
     });
   });
 });
@@ -54,7 +54,7 @@
       const bob = privateKey('//Bob');
 
       const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();
-      expect(collection.Owner).to.be.deep.eq(alice.address);
+      expect(collection.owner).to.be.deep.eq(alice.address);
 
       const changeOwnerTx = api.tx.nft.changeCollectionOwner(collectionId, bob.address);
       await submitTransactionAsync(alice, changeOwnerTx);
@@ -63,7 +63,7 @@
       await expect(submitTransactionExpectFailAsync(alice, badChangeOwnerTx)).to.be.rejected;
 
       const collectionAfterOwnerChange: any = (await api.query.nft.collectionById(collectionId)).toJSON();
-      expect(collectionAfterOwnerChange.Owner).to.be.deep.eq(bob.address);
+      expect(collectionAfterOwnerChange.owner).to.be.deep.eq(bob.address);
     });
   });
 
@@ -75,13 +75,13 @@
       const charlie = privateKey('//Charlie');
 
       const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();
-      expect(collection.Owner).to.be.deep.eq(alice.address);
+      expect(collection.owner).to.be.deep.eq(alice.address);
 
       const changeOwnerTx = api.tx.nft.changeCollectionOwner(collectionId, bob.address);
       await submitTransactionAsync(alice, changeOwnerTx);
 
       const collectionAfterOwnerChange: any = (await api.query.nft.collectionById(collectionId)).toJSON();
-      expect(collectionAfterOwnerChange.Owner).to.be.deep.eq(bob.address);
+      expect(collectionAfterOwnerChange.owner).to.be.deep.eq(bob.address);
 
       // After changing the owner of the collection, all privileged methods are available to the new owner
       // The new owner of the collection has access to sponsorship management operations in the collection
@@ -91,12 +91,12 @@
 
       // The new owner of the collection has access to operations for managing the collection parameters
       const collectionLimits = {
-        AccountTokenOwnershipLimit: 1,
-        SponsoredMintSize: 1,
-        TokenLimit: 1,
-        SponsorTimeout: 1,
-        OwnerCanTransfer: true,
-        OwnerCanDestroy: true,
+        accountTokenOwnershipLimit: 1,
+        sponsoredMintSize: 1,
+        tokenLimit: 1,
+        sponsorTimeout: 1,
+        ownerCanTransfer: true,
+        ownerCanDestroy: true,
       };
       const tx1 = api.tx.nft.setCollectionLimits(
         collectionId,
@@ -117,22 +117,22 @@
       const alice = privateKey('//Alice');
       const bob = privateKey('//Bob');
       const charlie = privateKey('//Charlie');
-  
+
       const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();
-      expect(collection.Owner).to.be.deep.eq(alice.address);
-  
+      expect(collection.owner).to.be.deep.eq(alice.address);
+
       const changeOwnerTx = api.tx.nft.changeCollectionOwner(collectionId, bob.address);
       await submitTransactionAsync(alice, changeOwnerTx);
-  
+
       const collectionAfterOwnerChange: any = (await api.query.nft.collectionById(collectionId)).toJSON();
-      expect(collectionAfterOwnerChange.Owner).to.be.deep.eq(bob.address);
+      expect(collectionAfterOwnerChange.owner).to.be.deep.eq(bob.address);
 
       const changeOwnerTx2 = api.tx.nft.changeCollectionOwner(collectionId, charlie.address);
       await submitTransactionAsync(bob, changeOwnerTx2);
-  
+
       // ownership lost
       const collectionAfterOwnerChange2: any = (await api.query.nft.collectionById(collectionId)).toJSON();
-      expect(collectionAfterOwnerChange2.Owner).to.be.deep.eq(charlie.address);
+      expect(collectionAfterOwnerChange2.owner).to.be.deep.eq(charlie.address);
     });
   });
 });
@@ -148,7 +148,7 @@
       await expect(submitTransactionExpectFailAsync(bob, changeOwnerTx)).to.be.rejected;
 
       const collectionAfterOwnerChange: any = (await api.query.nft.collectionById(collectionId)).toJSON();
-      expect(collectionAfterOwnerChange.Owner).to.be.deep.eq(alice.address);
+      expect(collectionAfterOwnerChange.owner).to.be.deep.eq(alice.address);
 
       // Verifying that nothing bad happened (network is live, new collections can be created, etc.)
       await createCollectionExpectSuccess();
@@ -167,7 +167,7 @@
       await expect(submitTransactionExpectFailAsync(bob, changeOwnerTx)).to.be.rejected;
 
       const collectionAfterOwnerChange: any = (await api.query.nft.collectionById(collectionId)).toJSON();
-      expect(collectionAfterOwnerChange.Owner).to.be.deep.eq(alice.address);
+      expect(collectionAfterOwnerChange.owner).to.be.deep.eq(alice.address);
 
       // Verifying that nothing bad happened (network is live, new collections can be created, etc.)
       await createCollectionExpectSuccess();
@@ -196,7 +196,7 @@
       const charlie = privateKey('//Charlie');
 
       const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();
-      expect(collection.Owner).to.be.deep.eq(alice.address);
+      expect(collection.owner).to.be.deep.eq(alice.address);
 
       const changeOwnerTx = api.tx.nft.changeCollectionOwner(collectionId, bob.address);
       await submitTransactionAsync(alice, changeOwnerTx);
@@ -205,19 +205,19 @@
       await expect(submitTransactionExpectFailAsync(alice, badChangeOwnerTx)).to.be.rejected;
 
       const collectionAfterOwnerChange: any = (await api.query.nft.collectionById(collectionId)).toJSON();
-      expect(collectionAfterOwnerChange.Owner).to.be.deep.eq(bob.address);
+      expect(collectionAfterOwnerChange.owner).to.be.deep.eq(bob.address);
 
       await setCollectionSponsorExpectFailure(collectionId, charlie.address, '//Alice');
       await confirmSponsorshipExpectFailure(collectionId, '//Alice');
       await removeCollectionSponsorExpectFailure(collectionId, '//Alice');
 
       const collectionLimits = {
-        AccountTokenOwnershipLimit: 1,
-        SponsoredMintSize: 1,
-        TokenLimit: 1,
-        SponsorTimeout: 1,
-        OwnerCanTransfer: true,
-        OwnerCanDestroy: true,
+        accountTokenOwnershipLimit: 1,
+        sponsoredMintSize: 1,
+        tokenLimit: 1,
+        sponsorTimeout: 1,
+        ownerCanTransfer: true,
+        ownerCanDestroy: true,
       };
       const tx1 = api.tx.nft.setCollectionLimits(
         collectionId,

--- a/tests/src/collision-tests/admVsOwnerChanges.test.ts
+++ b/tests/src/collision-tests/admVsOwnerChanges.test.ts
@@ -27,7 +27,7 @@
 describe('Admin vs Owner changes token: ', () => {
   // tslint:disable-next-line: max-line-length
   it('The collection admin changes the owner of the token and in the same block the current owner transfers the token to another address ', async () => {
-    
+
     await usingApi(async (api) => {
       const collectionId = await createCollectionExpectSuccess();
       const changeAdminTxBob = api.tx.nft.addCollectionAdmin(collectionId, normalizeAccountId(Bob.address));
@@ -35,7 +35,7 @@
       const changeAdminTxFerdie = api.tx.nft.addCollectionAdmin(collectionId, normalizeAccountId(Ferdie.address));
       await submitTransactionAsync(Bob, changeAdminTxFerdie);
       const itemId = await createItemExpectSuccess(Ferdie, collectionId, 'NFT');
-      
+
       const changeOwner = api.tx.nft.transferFrom(normalizeAccountId(Ferdie.address), normalizeAccountId(Bob.address), collectionId, itemId, 1);
       const approve = api.tx.nft.approve(normalizeAccountId(Bob.address), collectionId, itemId, 1);
       const sendItem = api.tx.nft.transfer(normalizeAccountId(Alice.address), collectionId, itemId, 1);
@@ -45,7 +45,7 @@
         sendItem.signAndSend(Ferdie),
       ]);
       const itemBefore: any = await api.query.nft.nftItemList(collectionId, itemId);
-      expect(itemBefore.Owner).not.to.be.eq(Bob.address);
+      expect(itemBefore.owner).not.to.be.eq(Bob.address);
       await waitNewBlocks(2);
     });
   });

--- a/tests/src/collision-tests/admVsOwnerData.test.ts
+++ b/tests/src/collision-tests/admVsOwnerData.test.ts
@@ -41,7 +41,7 @@
         BobTx.signAndSend(Bob),
       ]);
       const item: any = await api.query.nft.nftItemList(collectionId, itemId);
-      expect(item.VariableData).not.to.be.eq(null); // Pseudo-random selection of one of two values
+      expect(item.variableData).not.to.be.eq(null); // Pseudo-random selection of one of two values
       await waitNewBlocks(2);
     });
   });

--- a/tests/src/collision-tests/setSponsorNewOwner.test.ts
+++ b/tests/src/collision-tests/setSponsorNewOwner.test.ts
@@ -4,7 +4,7 @@
 import privateKey from '../substrate/privateKey';
 import usingApi from '../substrate/substrate-api';
 import {
-  createCollectionExpectSuccess, 
+  createCollectionExpectSuccess,
   setCollectionSponsorExpectSuccess,
   waitNewBlocks,
 } from '../util/helpers';
@@ -38,8 +38,8 @@
       ]);
       await waitNewBlocks(2);
       const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();
-      expect(collection.Sponsorship.confirmed).to.be.eq(Bob.address);
-      expect(collection.Owner).to.be.eq(Ferdie.address);
+      expect(collection.sponsorship.confirmed).to.be.eq(Bob.address);
+      expect(collection.owner).to.be.eq(Ferdie.address);
       await waitNewBlocks(2);
     });
   });

--- a/tests/src/collision-tests/tokenLimitsOff.test.ts
+++ b/tests/src/collision-tests/tokenLimitsOff.test.ts
@@ -19,12 +19,12 @@
 let Bob: IKeyringPair;
 let Ferdie: IKeyringPair;
 
-const AccountTokenOwnershipLimit = 4;
-const SponsoredMintSize = 4294967295;
-const TokenLimit = 4;
-const SponsorTimeout = 14400;
-const OwnerCanTransfer = false;
-const OwnerCanDestroy = false;
+const accountTokenOwnershipLimit = 4;
+const sponsoredMintSize = 4294967295;
+const tokenLimit = 4;
+const sponsorTimeout = 14400;
+const ownerCanTransfer = false;
+const ownerCanDestroy = false;
 
 before(async () => {
   await usingApi(async () => {
@@ -45,13 +45,13 @@
       const setCollectionLim = api.tx.nft.setCollectionLimits(
         collectionId,
         {
-          AccountTokenOwnershipLimit,
-          SponsoredMintSize,
-          TokenLimit,
+          accountTokenOwnershipLimit,
+          sponsoredMintSize,
+          tokenLimit,
           // tslint:disable-next-line: object-literal-sort-keys
-          SponsorTimeout,
-          OwnerCanTransfer,
-          OwnerCanDestroy,
+          sponsorTimeout,
+          ownerCanTransfer,
+          ownerCanDestroy,
         },
       );
       const subTx = await submitTransactionAsync(Alice, setCollectionLim);

--- a/tests/src/contracts.test.ts
+++ b/tests/src/contracts.test.ts
@@ -76,7 +76,7 @@
       await submitTransactionAsync(alice, changeAdminTx);
 
       const tokenBefore: any = (await api.query.nft.nftItemList(collectionId, tokenId) as any).toJSON();
-      
+
       // Transfer
       const transferTx = contract.tx.transfer(value, gasLimit, bob.address, collectionId, tokenId, 1);
       const events = await submitTransactionAsync(alice, transferTx);
@@ -85,8 +85,8 @@
 
       // tslint:disable-next-line:no-unused-expression
       expect(result.success).to.be.true;
-      expect(tokenBefore.Owner).to.be.deep.equal(normalizeAccountId(alice.address));
-      expect(tokenAfter.Owner).to.be.deep.equal(normalizeAccountId(bob.address));
+      expect(tokenBefore.owner).to.be.deep.equal(normalizeAccountId(alice.address));
+      expect(tokenAfter.owner).to.be.deep.equal(normalizeAccountId(bob.address));
     });
   });
 
@@ -141,7 +141,7 @@
 
       const tokensAfter: any = (await api.query.nft.nftItemList.entries(collectionId) as any)
         .map((kv: any) => kv[1].toJSON())
-        .sort((a: any, b: any) => a.ConstData.localeCompare(b.ConstData));
+        .sort((a: any, b: any) => a.constData.localeCompare(b.constData));
       expect(tokensAfter).to.be.deep.equal([
         {
           Owner: bob.address,
@@ -198,7 +198,7 @@
       expect(result.success).to.be.true;
 
       const token: any = (await api.query.nft.nftItemList(collectionId, tokenId) as any).unwrap();
-      expect(token.Owner.toString()).to.be.equal(charlie.address);
+      expect(token.owner.toString()).to.be.equal(charlie.address);
     });
   });
 
@@ -216,7 +216,7 @@
       expect(result.success).to.be.true;
 
       const token: any = (await api.query.nft.nftItemList(collectionId, tokenId) as any).unwrap();
-      expect(token.VariableData.toString()).to.be.equal('0x121314');
+      expect(token.variableData.toString()).to.be.equal('0x121314');
     });
   });
 
@@ -228,7 +228,7 @@
       const collectionId = await createCollectionExpectSuccess();
       const [contract] = await deployTransferContract(api);
       const changeAdminTx = api.tx.nft.addCollectionAdmin(collectionId, contract.address);
-      await submitTransactionAsync(alice, changeAdminTx);      
+      await submitTransactionAsync(alice, changeAdminTx);
 
       expect(await isWhitelisted(collectionId, bob.address)).to.be.false;
 

--- a/tests/src/createMultipleItems.test.ts
+++ b/tests/src/createMultipleItems.test.ts
@@ -24,9 +24,9 @@
 const expect = chai.expect;
 
 interface ITokenDataType {
-  Owner: number[];
-  ConstData: number[];
-  VariableData: number[];
+  owner: number[];
+  constData: number[];
+  variableData: number[];
 }
 
 describe('Integration Test createMultipleItems(collection_id, owner, items_data):', () => {
@@ -46,17 +46,17 @@
       const token2Data = (await api.query.nft.nftItemList(collectionId, 2)).toJSON() as unknown as ITokenDataType;
       const token3Data = (await api.query.nft.nftItemList(collectionId, 3)).toJSON() as unknown as ITokenDataType;
 
-      expect(token1Data.Owner).to.be.deep.equal(normalizeAccountId(Alice.address));
-      expect(token2Data.Owner).to.be.deep.equal(normalizeAccountId(Alice.address));
-      expect(token3Data.Owner).to.be.deep.equal(normalizeAccountId(Alice.address));
+      expect(token1Data.owner).to.be.deep.equal(normalizeAccountId(Alice.address));
+      expect(token2Data.owner).to.be.deep.equal(normalizeAccountId(Alice.address));
+      expect(token3Data.owner).to.be.deep.equal(normalizeAccountId(Alice.address));
 
-      expect(token1Data.ConstData.toString()).to.be.equal('0x31');
-      expect(token2Data.ConstData.toString()).to.be.equal('0x32');
-      expect(token3Data.ConstData.toString()).to.be.equal('0x33');
+      expect(token1Data.constData.toString()).to.be.equal('0x31');
+      expect(token2Data.constData.toString()).to.be.equal('0x32');
+      expect(token3Data.constData.toString()).to.be.equal('0x33');
 
-      expect(token1Data.VariableData.toString()).to.be.equal('0x31');
-      expect(token2Data.VariableData.toString()).to.be.equal('0x32');
-      expect(token3Data.VariableData.toString()).to.be.equal('0x33');
+      expect(token1Data.variableData.toString()).to.be.equal('0x31');
+      expect(token2Data.variableData.toString()).to.be.equal('0x32');
+      expect(token3Data.variableData.toString()).to.be.equal('0x33');
     });
   });
 
@@ -76,7 +76,7 @@
       await submitTransactionAsync(Alice, createMultipleItemsTx);
       const token1Data = (await api.query.nft.fungibleItemList(collectionId, Alice.address) as any).toJSON() as unknown as IFungibleTokenDataType;
 
-      expect(token1Data.Value).to.be.equal(6); // 1 + 2 + 3
+      expect(token1Data.value).to.be.equal(6); // 1 + 2 + 3
     });
   });
 
@@ -100,22 +100,22 @@
       const token2Data = (await api.query.nft.reFungibleItemList(collectionId, 2) as any).toJSON() as unknown as IReFungibleTokenDataType;
       const token3Data = (await api.query.nft.reFungibleItemList(collectionId, 3) as any).toJSON() as unknown as IReFungibleTokenDataType;
 
-      expect(token1Data.Owner[0].Owner).to.be.deep.equal(normalizeAccountId(Alice.address));
-      expect(token1Data.Owner[0].Fraction).to.be.equal(1);
+      expect(token1Data.owner[0].owner).to.be.deep.equal(normalizeAccountId(Alice.address));
+      expect(token1Data.owner[0].fraction).to.be.equal(1);
 
-      expect(token2Data.Owner[0].Owner).to.be.deep.equal(normalizeAccountId(Alice.address));
-      expect(token2Data.Owner[0].Fraction).to.be.equal(1);
+      expect(token2Data.owner[0].owner).to.be.deep.equal(normalizeAccountId(Alice.address));
+      expect(token2Data.owner[0].fraction).to.be.equal(1);
 
-      expect(token3Data.Owner[0].Owner).to.be.deep.equal(normalizeAccountId(Alice.address));
-      expect(token3Data.Owner[0].Fraction).to.be.equal(1);
+      expect(token3Data.owner[0].owner).to.be.deep.equal(normalizeAccountId(Alice.address));
+      expect(token3Data.owner[0].fraction).to.be.equal(1);
 
-      expect(token1Data.ConstData.toString()).to.be.equal('0x31');
-      expect(token2Data.ConstData.toString()).to.be.equal('0x32');
-      expect(token3Data.ConstData.toString()).to.be.equal('0x33');
+      expect(token1Data.constData.toString()).to.be.equal('0x31');
+      expect(token2Data.constData.toString()).to.be.equal('0x32');
+      expect(token3Data.constData.toString()).to.be.equal('0x33');
 
-      expect(token1Data.VariableData.toString()).to.be.equal('0x31');
-      expect(token2Data.VariableData.toString()).to.be.equal('0x32');
-      expect(token3Data.VariableData.toString()).to.be.equal('0x33');
+      expect(token1Data.variableData.toString()).to.be.equal('0x31');
+      expect(token2Data.variableData.toString()).to.be.equal('0x32');
+      expect(token3Data.variableData.toString()).to.be.equal('0x33');
     });
   });
 
@@ -125,7 +125,7 @@
 
       const collectionId = await createCollectionExpectSuccess();
       await setCollectionLimitsExpectSuccess(alice, collectionId, {
-        TokenLimit: 2,
+        tokenLimit: 2,
       });
       const args = [
         { nft: ['A', 'A'] },
@@ -156,7 +156,7 @@
       const collectionId = await createCollectionExpectSuccess();
       const itemsListIndexBefore = await api.query.nft.itemListIndex(collectionId) as unknown as BN;
       expect(itemsListIndexBefore.toNumber()).to.be.equal(0);
-      await addCollectionAdminExpectSuccess(Alice, collectionId, Bob); 
+      await addCollectionAdminExpectSuccess(Alice, collectionId, Bob);
       const args = [{ nft: ['0x31', '0x31'] }, { nft: ['0x32', '0x32'] }, { nft: ['0x33', '0x33'] }];
       const createMultipleItemsTx = api.tx.nft
         .createMultipleItems(collectionId, normalizeAccountId(Bob.address), args);
@@ -167,17 +167,17 @@
       const token2Data = (await api.query.nft.nftItemList(collectionId, 2)).toJSON() as unknown as ITokenDataType;
       const token3Data = (await api.query.nft.nftItemList(collectionId, 3)).toJSON() as unknown as ITokenDataType;
 
-      expect(token1Data.Owner).to.be.deep.equal(normalizeAccountId(Bob.address));
-      expect(token2Data.Owner).to.be.deep.equal(normalizeAccountId(Bob.address));
-      expect(token3Data.Owner).to.be.deep.equal(normalizeAccountId(Bob.address));
+      expect(token1Data.owner).to.be.deep.equal(normalizeAccountId(Bob.address));
+      expect(token2Data.owner).to.be.deep.equal(normalizeAccountId(Bob.address));
+      expect(token3Data.owner).to.be.deep.equal(normalizeAccountId(Bob.address));
 
-      expect(token1Data.ConstData.toString()).to.be.equal('0x31');
-      expect(token2Data.ConstData.toString()).to.be.equal('0x32');
-      expect(token3Data.ConstData.toString()).to.be.equal('0x33');
+      expect(token1Data.constData.toString()).to.be.equal('0x31');
+      expect(token2Data.constData.toString()).to.be.equal('0x32');
+      expect(token3Data.constData.toString()).to.be.equal('0x33');
 
-      expect(token1Data.VariableData.toString()).to.be.equal('0x31');
-      expect(token2Data.VariableData.toString()).to.be.equal('0x32');
-      expect(token3Data.VariableData.toString()).to.be.equal('0x33');
+      expect(token1Data.variableData.toString()).to.be.equal('0x31');
+      expect(token2Data.variableData.toString()).to.be.equal('0x32');
+      expect(token3Data.variableData.toString()).to.be.equal('0x33');
     });
   });
 
@@ -186,7 +186,7 @@
       const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
       const itemsListIndexBefore = await api.query.nft.itemListIndex(collectionId) as unknown as BN;
       expect(itemsListIndexBefore.toNumber()).to.be.equal(0);
-      await addCollectionAdminExpectSuccess(Alice, collectionId, Bob); 
+      await addCollectionAdminExpectSuccess(Alice, collectionId, Bob);
       const args = [
         {fungible: { value: 1 }},
         {fungible: { value: 2 }},
@@ -197,7 +197,7 @@
       await submitTransactionAsync(Bob, createMultipleItemsTx);
       const token1Data = (await api.query.nft.fungibleItemList(collectionId, Bob.address) as any).toJSON() as unknown as IFungibleTokenDataType;
 
-      expect(token1Data.Value).to.be.equal(6); // 1 + 2 + 3
+      expect(token1Data.value).to.be.equal(6); // 1 + 2 + 3
     });
   });
 
@@ -206,7 +206,7 @@
       const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
       const itemsListIndexBefore = await api.query.nft.itemListIndex(collectionId) as unknown as BN;
       expect(itemsListIndexBefore.toNumber()).to.be.equal(0);
-      await addCollectionAdminExpectSuccess(Alice, collectionId, Bob); 
+      await addCollectionAdminExpectSuccess(Alice, collectionId, Bob);
       const args = [
         {refungible: {const_data: [0x31], variable_data: [0x31], pieces: 1}},
         {refungible: {const_data: [0x32], variable_data: [0x32], pieces: 1}},
@@ -221,22 +221,22 @@
       const token2Data = (await api.query.nft.reFungibleItemList(collectionId, 2) as any).toJSON() as unknown as IReFungibleTokenDataType;
       const token3Data = (await api.query.nft.reFungibleItemList(collectionId, 3) as any).toJSON() as unknown as IReFungibleTokenDataType;
 
-      expect(token1Data.Owner[0].Owner).to.be.deep.equal(normalizeAccountId(Bob.address));
-      expect(token1Data.Owner[0].Fraction).to.be.equal(1);
+      expect(token1Data.owner[0].owner).to.be.deep.equal(normalizeAccountId(Bob.address));
+      expect(token1Data.owner[0].fraction).to.be.equal(1);
 
-      expect(token2Data.Owner[0].Owner).to.be.deep.equal(normalizeAccountId(Bob.address));
-      expect(token2Data.Owner[0].Fraction).to.be.equal(1);
+      expect(token2Data.owner[0].owner).to.be.deep.equal(normalizeAccountId(Bob.address));
+      expect(token2Data.owner[0].fraction).to.be.equal(1);
 
-      expect(token3Data.Owner[0].Owner).to.be.deep.equal(normalizeAccountId(Bob.address));
-      expect(token3Data.Owner[0].Fraction).to.be.equal(1);
+      expect(token3Data.owner[0].owner).to.be.deep.equal(normalizeAccountId(Bob.address));
+      expect(token3Data.owner[0].fraction).to.be.equal(1);
 
-      expect(token1Data.ConstData.toString()).to.be.equal('0x31');
-      expect(token2Data.ConstData.toString()).to.be.equal('0x32');
-      expect(token3Data.ConstData.toString()).to.be.equal('0x33');
+      expect(token1Data.constData.toString()).to.be.equal('0x31');
+      expect(token2Data.constData.toString()).to.be.equal('0x32');
+      expect(token3Data.constData.toString()).to.be.equal('0x33');
 
-      expect(token1Data.VariableData.toString()).to.be.equal('0x31');
-      expect(token2Data.VariableData.toString()).to.be.equal('0x32');
-      expect(token3Data.VariableData.toString()).to.be.equal('0x33');
+      expect(token1Data.variableData.toString()).to.be.equal('0x31');
+      expect(token2Data.variableData.toString()).to.be.equal('0x32');
+      expect(token3Data.variableData.toString()).to.be.equal('0x33');
     });
   });
 });
@@ -379,7 +379,7 @@
 
       const collectionId = await createCollectionExpectSuccess();
       await setCollectionLimitsExpectSuccess(Alice, collectionId, {
-        TokenLimit: 1,
+        tokenLimit: 1,
       });
       const args = [
         { nft: ['A', 'A'] },

--- a/tests/src/destroyCollection.test.ts
+++ b/tests/src/destroyCollection.test.ts
@@ -8,9 +8,9 @@
 import chaiAsPromised from 'chai-as-promised';
 import privateKey from './substrate/privateKey';
 import { default as usingApi } from './substrate/substrate-api';
-import { createCollectionExpectSuccess, 
-  destroyCollectionExpectSuccess, 
-  destroyCollectionExpectFailure, 
+import { createCollectionExpectSuccess,
+  destroyCollectionExpectSuccess,
+  destroyCollectionExpectFailure,
   setCollectionLimitsExpectSuccess,
   addCollectionAdminExpectSuccess,
 } from './util/helpers';
@@ -67,7 +67,7 @@
   });
   it('fails when OwnerCanDestroy == false', async () => {
     const collectionId = await createCollectionExpectSuccess();
-    await setCollectionLimitsExpectSuccess(alice, collectionId, { OwnerCanDestroy: false });
+    await setCollectionLimitsExpectSuccess(alice, collectionId, { ownerCanDestroy: false });
 
     await destroyCollectionExpectFailure(collectionId, '//Alice');
   });

--- a/tests/src/limits.test.ts
+++ b/tests/src/limits.test.ts
@@ -17,7 +17,7 @@
   transferExpectSuccess,
   getFreeBalance,
   waitNewBlocks,
-} from './util/helpers'; 
+} from './util/helpers';
 import { expect } from 'chai';
 
 describe('Number of tokens per address (NFT)', () => {
@@ -30,9 +30,9 @@
   });
 
   it.skip('Collection limits allow greater number than chain limits, chain limits are enforced', async () => {
-      
+
     const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });
-    await setCollectionLimitsExpectSuccess(Alice, collectionId, { AccountTokenOwnershipLimit: 20 });
+    await setCollectionLimitsExpectSuccess(Alice, collectionId, { accountTokenOwnershipLimit: 20 });
     for(let i = 0; i < 10; i++){
       await createItemExpectSuccess(Alice, collectionId, 'NFT');
     }
@@ -43,7 +43,7 @@
   it('Collection limits allow lower number than chain limits, collection limits are enforced', async () => {
 
     const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });
-    await setCollectionLimitsExpectSuccess(Alice, collectionId, { AccountTokenOwnershipLimit: 1 });
+    await setCollectionLimitsExpectSuccess(Alice, collectionId, { accountTokenOwnershipLimit: 1 });
     await createItemExpectSuccess(Alice, collectionId, 'NFT');
     await createItemExpectFailure(Alice, collectionId, 'NFT');
     await destroyCollectionExpectSuccess(collectionId);
@@ -59,9 +59,9 @@
     });
   });
 
-  it.skip('Collection limits allow greater number than chain limits, chain limits are enforced', async () => {   
+  it.skip('Collection limits allow greater number than chain limits, chain limits are enforced', async () => {
     const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible' }});
-    await setCollectionLimitsExpectSuccess(Alice, collectionId, { AccountTokenOwnershipLimit: 20 });
+    await setCollectionLimitsExpectSuccess(Alice, collectionId, { accountTokenOwnershipLimit: 20 });
     for(let i = 0; i < 10; i++){
       await createItemExpectSuccess(Alice, collectionId, 'ReFungible');
     }
@@ -71,7 +71,7 @@
 
   it('Collection limits allow lower number than chain limits, collection limits are enforced', async () => {
     const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible' }});
-    await setCollectionLimitsExpectSuccess(Alice, collectionId, { AccountTokenOwnershipLimit: 1 });
+    await setCollectionLimitsExpectSuccess(Alice, collectionId, { accountTokenOwnershipLimit: 1 });
     await createItemExpectSuccess(Alice, collectionId, 'ReFungible');
     await createItemExpectFailure(Alice, collectionId, 'ReFungible');
     await destroyCollectionExpectSuccess(collectionId);
@@ -91,9 +91,9 @@
     });
   });
 
-  it('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {  
+  it('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {
     const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });
-    await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 7 });
+    await setCollectionLimitsExpectSuccess(Alice, collectionId, { sponsorTimeout: 7 });
     const tokenId = await createItemExpectSuccess(Alice, collectionId, 'NFT');
     await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
     await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
@@ -117,7 +117,7 @@
   it('Collection limits have lower timeout value than chain limits, chain limits are enforced', async () => {
 
     const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });
-    await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 1 });
+    await setCollectionLimitsExpectSuccess(Alice, collectionId, { sponsorTimeout: 1 });
     const tokenId = await createItemExpectSuccess(Alice, collectionId, 'NFT');
     await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
     await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
@@ -152,9 +152,9 @@
     });
   });
 
-  it('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {  
+  it('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {
     const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
-    await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 7 });
+    await setCollectionLimitsExpectSuccess(Alice, collectionId, { sponsorTimeout: 7 });
     const tokenId = await createItemExpectSuccess(Alice, collectionId, 'Fungible');
     await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
     await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
@@ -180,7 +180,7 @@
   it('Collection limits have lower timeout value than chain limits, chain limits are enforced', async () => {
 
     const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
-    await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 1 });
+    await setCollectionLimitsExpectSuccess(Alice, collectionId, { sponsorTimeout: 1 });
     const tokenId = await createItemExpectSuccess(Alice, collectionId, 'Fungible');
     await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
     await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
@@ -217,9 +217,9 @@
     });
   });
 
-  it('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {  
+  it('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {
     const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible' }});
-    await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 7 });
+    await setCollectionLimitsExpectSuccess(Alice, collectionId, { sponsorTimeout: 7 });
     const tokenId = await createItemExpectSuccess(Alice, collectionId, 'ReFungible');
     await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
     await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
@@ -243,7 +243,7 @@
   it('Collection limits have lower timeout value than chain limits, chain limits are enforced', async () => {
 
     const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });
-    await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 1 });
+    await setCollectionLimitsExpectSuccess(Alice, collectionId, { sponsorTimeout: 1 });
     const tokenId = await createItemExpectSuccess(Alice, collectionId, 'NFT');
     await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
     await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
@@ -278,9 +278,9 @@
     });
   });
 
-  it.skip('Limits have 0 in tokens per address field, the chain limits are applied', async () => {  
+  it.skip('Limits have 0 in tokens per address field, the chain limits are applied', async () => {
     const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });
-    await setCollectionLimitsExpectSuccess(Alice, collectionId, { AccountTokenOwnershipLimit: 0 });
+    await setCollectionLimitsExpectSuccess(Alice, collectionId, { accountTokenOwnershipLimit: 0 });
     for(let i = 0; i < 10; i++){
       await createItemExpectSuccess(Alice, collectionId, 'NFT');
     }
@@ -290,7 +290,7 @@
   it('Limits have 0 in sponsor timeout, no limits are applied', async () => {
 
     const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });
-    await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 0 });
+    await setCollectionLimitsExpectSuccess(Alice, collectionId, { sponsorTimeout: 0 });
     const tokenId = await createItemExpectSuccess(Alice, collectionId, 'NFT');
     await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
     await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
@@ -320,7 +320,7 @@
 
   it('Limits have 0 in sponsor timeout, no limits are applied', async () => {
     const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
-    await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 0 });
+    await setCollectionLimitsExpectSuccess(Alice, collectionId, { sponsorTimeout: 0 });
     const tokenId = await createItemExpectSuccess(Alice, collectionId, 'Fungible');
     await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
     await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
@@ -349,9 +349,9 @@
     });
   });
 
-  it.skip('Limits have 0 in tokens per address field, the chain limits are applied', async () => {  
+  it.skip('Limits have 0 in tokens per address field, the chain limits are applied', async () => {
     const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible' }});
-    await setCollectionLimitsExpectSuccess(Alice, collectionId, { AccountTokenOwnershipLimit: 0 });
+    await setCollectionLimitsExpectSuccess(Alice, collectionId, { accountTokenOwnershipLimit: 0 });
     for(let i = 0; i < 10; i++){
       await createItemExpectSuccess(Alice, collectionId, 'ReFungible');
     }
@@ -361,7 +361,7 @@
   it('Limits have 0 in sponsor timeout, no limits are applied', async () => {
 
     const collectionId = await createCollectionExpectSuccess({ mode: { type: 'ReFungible' } });
-    await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 0 });
+    await setCollectionLimitsExpectSuccess(Alice, collectionId, { sponsorTimeout: 0 });
     const tokenId = await createItemExpectSuccess(Alice, collectionId, 'ReFungible');
     await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
     await confirmSponsorshipExpectSuccess(collectionId, '//Alice');

--- a/tests/src/pallet-presence.test.ts
+++ b/tests/src/pallet-presence.test.ts
@@ -8,7 +8,7 @@
 import usingApi from './substrate/substrate-api';
 
 function getModuleNames(api: ApiPromise): string[] {
-  return api.runtimeMetadata.asLatest.modules.map(m => m.name.toString().toLowerCase());
+  return api.runtimeMetadata.asLatest.pallets.map(m => m.name.toString().toLowerCase());
 }
 
 // Pallets that must always be present

--- a/tests/src/removeCollectionAdmin.test.ts
+++ b/tests/src/removeCollectionAdmin.test.ts
@@ -20,7 +20,7 @@
       const Alice = privateKey('//Alice');
       const Bob = privateKey('//Bob');
       const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();
-      expect(collection.Owner).to.be.deep.eq(Alice.address);
+      expect(collection.owner).to.be.deep.eq(Alice.address);
       // first - add collection admin Bob
       const addAdminTx = api.tx.nft.addCollectionAdmin(collectionId, normalizeAccountId(Bob.address));
       await submitTransactionAsync(Alice, addAdminTx);
@@ -44,7 +44,7 @@
       const Bob = privateKey('//Bob');
       const Charlie = privateKey('//Charlie');
       const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();
-      expect(collection.Owner).to.be.deep.eq(Alice.address);
+      expect(collection.owner).to.be.deep.eq(Alice.address);
       // first - add collection admin Bob
       const addAdminTx = api.tx.nft.addCollectionAdmin(collectionId, normalizeAccountId(Bob.address));
       await submitTransactionAsync(Alice, addAdminTx);

--- a/tests/src/setChainLimits.test.ts
+++ b/tests/src/setChainLimits.test.ts
@@ -25,16 +25,16 @@
       bob = privateKey('//Bob');
       dave = privateKey('//Dave');
       limits = {
-        CollectionNumbersLimit : 1,
-        AccountTokenOwnershipLimit: 1,
-        CollectionsAdminsLimit: 1,
-        CustomDataLimit: 1,
-        NftSponsorTransferTimeout: 1,
-        FungibleSponsorTransferTimeout: 1,
-        RefungibleSponsorTransferTimeout: 1,
-        OffchainSchemaLimit: 1,
-        VariableOnChainSchemaLimit: 1,
-        ConstOnChainSchemaLimit: 1,
+        collectionNumbersLimit : 1,
+        accountTokenOwnershipLimit: 1,
+        collectionsAdminsLimit: 1,
+        customDataLimit: 1,
+        nftSponsorTransferTimeout: 1,
+        fungibleSponsorTransferTimeout: 1,
+        refungibleSponsorTransferTimeout: 1,
+        offchainSchemaLimit: 1,
+        variableOnChainSchemaLimit: 1,
+        constOnChainSchemaLimit: 1,
       };
     });
   });

--- a/tests/src/setCollectionLimits.test.ts
+++ b/tests/src/setCollectionLimits.test.ts
@@ -46,12 +46,12 @@
       tx = api.tx.nft.setCollectionLimits(
         collectionIdForTesting,
         {
-          AccountTokenOwnershipLimit: accountTokenOwnershipLimit,
-          SponsoredMintSize: sponsoredDataSize,
-          TokenLimit: tokenLimit,
-          SponsorTimeout: sponsorTimeout,
-          OwnerCanTransfer: true,
-          OwnerCanDestroy: true,
+          accountTokenOwnershipLimit: accountTokenOwnershipLimit,
+          sponsoredMintSize: sponsoredDataSize,
+          tokenLimit: tokenLimit,
+          sponsorTimeout: sponsorTimeout,
+          ownerCanTransfer: true,
+          ownerCanDestroy: true,
         },
       );
       const events = await submitTransactionAsync(alice, tx);
@@ -62,12 +62,12 @@
 
       // tslint:disable-next-line:no-unused-expression
       expect(result.success).to.be.true;
-      expect(collectionInfo.Limits.AccountTokenOwnershipLimit).to.be.equal(accountTokenOwnershipLimit);
-      expect(collectionInfo.Limits.SponsoredDataSize).to.be.equal(sponsoredDataSize);
-      expect(collectionInfo.Limits.TokenLimit).to.be.equal(tokenLimit);
-      expect(collectionInfo.Limits.SponsorTimeout).to.be.equal(sponsorTimeout);
-      expect(collectionInfo.Limits.OwnerCanTransfer).to.be.true;
-      expect(collectionInfo.Limits.OwnerCanDestroy).to.be.true;
+      expect(collectionInfo.limits.accountTokenOwnershipLimit).to.be.equal(accountTokenOwnershipLimit);
+      expect(collectionInfo.limits.sponsoredDataSize).to.be.equal(sponsoredDataSize);
+      expect(collectionInfo.limits.tokenLimit).to.be.equal(tokenLimit);
+      expect(collectionInfo.limits.sponsorTimeout).to.be.equal(sponsorTimeout);
+      expect(collectionInfo.limits.ownerCanTransfer).to.be.true;
+      expect(collectionInfo.limits.ownerCanDestroy).to.be.true;
     });
   });
 
@@ -75,12 +75,12 @@
     await usingApi(async (api: ApiPromise) => {
 
       const collectionLimits = {
-        AccountTokenOwnershipLimit: accountTokenOwnershipLimit,
-        SponsoredMintSize: sponsoredDataSize,
-        TokenLimit: tokenLimit,
-        SponsorTimeout: sponsorTimeout,
-        OwnerCanTransfer: true,
-        OwnerCanDestroy: true,
+        accountTokenOwnershipLimit: accountTokenOwnershipLimit,
+        sponsoredMintSize: sponsoredDataSize,
+        tokenLimit: tokenLimit,
+        sponsorTimeout: sponsorTimeout,
+        ownerCanTransfer: true,
+        ownerCanDestroy: true,
       };
 
       // The first time
@@ -103,9 +103,9 @@
 
       // tslint:disable-next-line:no-unused-expression
       expect(result1.success).to.be.true;
-      expect(collectionInfo1.Limits.TokenLimit).to.be.equal(tokenLimit);
+      expect(collectionInfo1.limits.tokenLimit).to.be.equal(tokenLimit);
       expect(result2.success).to.be.true;
-      expect(collectionInfo2.Limits.TokenLimit).to.be.equal(tokenLimit);
+      expect(collectionInfo2.limits.tokenLimit).to.be.equal(tokenLimit);
     });
   });
 
@@ -183,41 +183,41 @@
 
   it('fails when trying to enable OwnerCanTransfer after it was disabled', async () => {
     const collectionId = await createCollectionExpectSuccess();
-    await setCollectionLimitsExpectSuccess(alice, collectionId, { 
-      AccountTokenOwnershipLimit: accountTokenOwnershipLimit,
-      SponsoredMintSize: sponsoredDataSize,
-      TokenLimit: tokenLimit,
-      SponsorTimeout: sponsorTimeout,
-      OwnerCanTransfer: false,
-      OwnerCanDestroy: true,
+    await setCollectionLimitsExpectSuccess(alice, collectionId, {
+      accountTokenOwnershipLimit: accountTokenOwnershipLimit,
+      sponsoredMintSize: sponsoredDataSize,
+      tokenLimit: tokenLimit,
+      sponsorTimeout: sponsorTimeout,
+      ownerCanTransfer: false,
+      ownerCanDestroy: true,
     });
-    await setCollectionLimitsExpectFailure(alice, collectionId, { 
-      AccountTokenOwnershipLimit: accountTokenOwnershipLimit,
-      SponsoredMintSize: sponsoredDataSize,
-      TokenLimit: tokenLimit,
-      SponsorTimeout: sponsorTimeout,
-      OwnerCanTransfer: true,
-      OwnerCanDestroy: true,
+    await setCollectionLimitsExpectFailure(alice, collectionId, {
+      accountTokenOwnershipLimit: accountTokenOwnershipLimit,
+      sponsoredMintSize: sponsoredDataSize,
+      tokenLimit: tokenLimit,
+      sponsorTimeout: sponsorTimeout,
+      ownerCanTransfer: true,
+      ownerCanDestroy: true,
     });
   });
 
   it('fails when trying to enable OwnerCanDestroy after it was disabled', async () => {
     const collectionId = await createCollectionExpectSuccess();
     await setCollectionLimitsExpectSuccess(alice, collectionId, {
-      AccountTokenOwnershipLimit: accountTokenOwnershipLimit,
-      SponsoredMintSize: sponsoredDataSize,
-      TokenLimit: tokenLimit,
-      SponsorTimeout: sponsorTimeout,
-      OwnerCanTransfer: true,
-      OwnerCanDestroy: false,
+      accountTokenOwnershipLimit: accountTokenOwnershipLimit,
+      sponsoredMintSize: sponsoredDataSize,
+      tokenLimit: tokenLimit,
+      sponsorTimeout: sponsorTimeout,
+      ownerCanTransfer: true,
+      ownerCanDestroy: false,
     });
-    await setCollectionLimitsExpectFailure(alice, collectionId, { 
-      AccountTokenOwnershipLimit: accountTokenOwnershipLimit,
-      SponsoredMintSize: sponsoredDataSize,
-      TokenLimit: tokenLimit,
-      SponsorTimeout: sponsorTimeout,
-      OwnerCanTransfer: true,
-      OwnerCanDestroy: true,
+    await setCollectionLimitsExpectFailure(alice, collectionId, {
+      accountTokenOwnershipLimit: accountTokenOwnershipLimit,
+      sponsoredMintSize: sponsoredDataSize,
+      tokenLimit: tokenLimit,
+      sponsorTimeout: sponsorTimeout,
+      ownerCanTransfer: true,
+      ownerCanDestroy: true,
     });
   });
 
@@ -226,19 +226,19 @@
 
       const collectionId = await createCollectionExpectSuccess();
       const collectionLimits = {
-        AccountTokenOwnershipLimit: accountTokenOwnershipLimit,
-        SponsoredMintSize: sponsoredDataSize,
-        TokenLimit: tokenLimit,
-        SponsorTimeout: sponsorTimeout,
-        OwnerCanTransfer: true,
-        OwnerCanDestroy: true,
+        accountTokenOwnershipLimit: accountTokenOwnershipLimit,
+        sponsoredMintSize: sponsoredDataSize,
+        tokenLimit: tokenLimit,
+        sponsorTimeout: sponsorTimeout,
+        ownerCanTransfer: true,
+        ownerCanDestroy: true,
       };
 
       // The first time
       await setCollectionLimitsExpectSuccess(alice, collectionId, collectionLimits);
 
       // The second time - higher token limit
-      collectionLimits.TokenLimit += 1;
+      collectionLimits.tokenLimit += 1;
       await setCollectionLimitsExpectFailure(alice, collectionId, collectionLimits);
     });
   });

--- a/tests/src/setConstOnChainSchema.test.ts
+++ b/tests/src/setConstOnChainSchema.test.ts
@@ -38,7 +38,7 @@
     await usingApi(async (api) => {
       const collectionId = await createCollectionExpectSuccess();
       const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();
-      expect(collection.Owner).to.be.eq(Alice.address);
+      expect(collection.owner).to.be.eq(Alice.address);
       const setShema = api.tx.nft.setConstOnChainSchema(collectionId, Shema);
       await submitTransactionAsync(Alice, setShema);
     });
@@ -48,7 +48,7 @@
     await usingApi(async (api) => {
       const collectionId = await createCollectionExpectSuccess();
       const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();
-      expect(collection.Owner).to.be.eq(Alice.address);
+      expect(collection.owner).to.be.eq(Alice.address);
       await addCollectionAdminExpectSuccess(Alice, collectionId, Bob);
       const setShema = api.tx.nft.setConstOnChainSchema(collectionId, Shema);
       await submitTransactionAsync(Bob, setShema);
@@ -61,7 +61,7 @@
       const setShema = api.tx.nft.setConstOnChainSchema(collectionId, Shema);
       await submitTransactionAsync(Alice, setShema);
       const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();
-      expect(collection.ConstOnChainSchema.toString()).to.be.eq(Shema);
+      expect(collection.constOnChainSchema.toString()).to.be.eq(Shema);
 
     });
   });
@@ -99,7 +99,7 @@
     await usingApi(async (api) => {
       const collectionId = await createCollectionExpectSuccess();
       const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();
-      expect(collection.Owner).to.be.eq(Alice.address);
+      expect(collection.owner).to.be.eq(Alice.address);
       const setShema = api.tx.nft.setConstOnChainSchema(collectionId, Shema);
       await expect(submitTransactionExpectFailAsync(Bob, setShema)).to.be.rejected;
     });

--- a/tests/src/setOffchainSchema.test.ts
+++ b/tests/src/setOffchainSchema.test.ts
@@ -39,7 +39,7 @@
     await setOffchainSchemaExpectSuccess(alice, collectionId, DATA);
     const collection = await queryCollectionExpectSuccess(collectionId);
 
-    expect(collection.OffchainSchema).to.be.equal('0x' + Buffer.from(DATA).toString('hex'));
+    expect(collection.offchainSchema).to.be.equal('0x' + Buffer.from(DATA).toString('hex'));
   });
 
   it('execute setOffchainSchema (collection admin), verify data was set', async () => {
@@ -48,7 +48,7 @@
     await setOffchainSchemaExpectSuccess(bob, collectionId, DATA);
     const collection = await queryCollectionExpectSuccess(collectionId);
 
-    expect(collection.OffchainSchema).to.be.equal('0x' + Buffer.from(DATA).toString('hex'));
+    expect(collection.offchainSchema).to.be.equal('0x' + Buffer.from(DATA).toString('hex'));
   });
 });
 

--- a/tests/src/setSchemaVersion.test.ts
+++ b/tests/src/setSchemaVersion.test.ts
@@ -66,7 +66,7 @@
       // tslint:disable-next-line:no-unused-expression
       expect(collectionInfo).to.be.exist;
       // tslint:disable-next-line:no-unused-expression
-      expect(collectionInfo ? collectionInfo.SchemaVersion.toString() : '').to.be.equal('Unique');
+      expect(collectionInfo ? collectionInfo.schemaVersion.toString() : '').to.be.equal('Unique');
     });
   });
 });
@@ -92,7 +92,7 @@
       // tslint:disable-next-line:no-unused-expression
       expect(collectionInfo).to.be.exist;
       // tslint:disable-next-line:no-unused-expression
-      expect(collectionInfo ? collectionInfo.SchemaVersion.toString() : '').to.be.equal('Unique');
+      expect(collectionInfo ? collectionInfo.schemaVersion.toString() : '').to.be.equal('Unique');
     });
   });
 
@@ -107,7 +107,7 @@
       // tslint:disable-next-line:no-unused-expression
       expect(collectionInfo).to.be.exist;
       // tslint:disable-next-line:no-unused-expression
-      expect(collectionInfo ? collectionInfo.SchemaVersion.toString() : '').to.be.equal('ImageURL');
+      expect(collectionInfo ? collectionInfo.schemaVersion.toString() : '').to.be.equal('ImageURL');
     });
   });
 });

--- a/tests/src/setVariableMetaData.test.ts
+++ b/tests/src/setVariableMetaData.test.ts
@@ -45,7 +45,7 @@
     await usingApi(async api => {
       const item: any = (await api.query.nft.nftItemList(collectionId, tokenId) as any).unwrap();
 
-      expect(Array.from(item.VariableData)).to.deep.equal(Array.from(data));
+      expect(Array.from(item.variableData)).to.deep.equal(Array.from(data));
     });
   });
 });
@@ -76,7 +76,7 @@
     await usingApi(async api => {
       const item: any = (await api.query.nft.nftItemList(collectionId, tokenId) as any).unwrap();
 
-      expect(Array.from(item.VariableData)).to.deep.equal(Array.from(data));
+      expect(Array.from(item.variableData)).to.deep.equal(Array.from(data));
     });
   });
 });

--- a/tests/src/setVariableMetadataSponsoringRateLimit.test.ts
+++ b/tests/src/setVariableMetadataSponsoringRateLimit.test.ts
@@ -33,7 +33,7 @@
     await setCollectionSponsorExpectSuccess(collectionId, alice.address);
     await confirmSponsorshipExpectSuccess(collectionId);
     await setCollectionLimitsExpectSuccess(alice, collectionId, {
-      SponsoredDataRateLimit: 0,
+      sponsoredDataRateLimit: 0,
     });
 
     const itemId = await createItemExpectSuccess(alice, collectionId, 'NFT', userWithNoBalance.address);
@@ -46,7 +46,7 @@
     await setCollectionSponsorExpectSuccess(collectionId, alice.address);
     await confirmSponsorshipExpectSuccess(collectionId);
     await setCollectionLimitsExpectSuccess(alice, collectionId, {
-      SponsoredDataRateLimit: 10,
+      sponsoredDataRateLimit: 10,
     });
 
     const itemId = await createItemExpectSuccess(alice, collectionId, 'NFT', userWithNoBalance.address);
@@ -59,8 +59,8 @@
     await setCollectionSponsorExpectSuccess(collectionId, alice.address);
     await confirmSponsorshipExpectSuccess(collectionId);
     await setCollectionLimitsExpectSuccess(alice, collectionId, {
-      SponsoredDataRateLimit: 0,
-      SponsoredDataSize: 1,
+      sponsoredDataRateLimit: 0,
+      sponsoredDataSize: 1,
     });
     const itemId = await createItemExpectSuccess(alice, collectionId, 'NFT', userWithNoBalance.address);
 

--- a/tests/src/setVariableOnChainSchema.test.ts
+++ b/tests/src/setVariableOnChainSchema.test.ts
@@ -38,7 +38,7 @@
     await usingApi(async (api) => {
       const collectionId = await createCollectionExpectSuccess();
       const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();
-      expect(collection.Owner).to.be.eq(Alice.address);
+      expect(collection.owner).to.be.eq(Alice.address);
       const setSchema = api.tx.nft.setVariableOnChainSchema(collectionId, Schema);
       await submitTransactionAsync(Alice, setSchema);
     });
@@ -50,7 +50,7 @@
       const setSchema = api.tx.nft.setVariableOnChainSchema(collectionId, Schema);
       await submitTransactionAsync(Alice, setSchema);
       const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();
-      expect(collection.VariableOnChainSchema.toString()).to.be.eq(Schema);
+      expect(collection.variableOnChainSchema.toString()).to.be.eq(Schema);
 
     });
   });
@@ -62,7 +62,7 @@
     await usingApi(async (api) => {
       const collectionId = await createCollectionExpectSuccess();
       const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();
-      expect(collection.Owner).to.be.eq(Alice.address);
+      expect(collection.owner).to.be.eq(Alice.address);
       await addCollectionAdminExpectSuccess(Alice, collectionId, Bob);
       const setSchema = api.tx.nft.setVariableOnChainSchema(collectionId, Schema);
       await submitTransactionAsync(Bob, setSchema);
@@ -76,7 +76,7 @@
       const setSchema = api.tx.nft.setVariableOnChainSchema(collectionId, Schema);
       await submitTransactionAsync(Bob, setSchema);
       const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();
-      expect(collection.VariableOnChainSchema.toString()).to.be.eq(Schema);
+      expect(collection.variableOnChainSchema.toString()).to.be.eq(Schema);
 
     });
   });
@@ -114,7 +114,7 @@
     await usingApi(async (api) => {
       const collectionId = await createCollectionExpectSuccess();
       const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();
-      expect(collection.Owner).to.be.eq(Alice.address);
+      expect(collection.owner).to.be.eq(Alice.address);
       const setSchema = api.tx.nft.setVariableOnChainSchema(collectionId, Schema);
       await expect(submitTransactionExpectFailAsync(Bob, setSchema)).to.be.rejected;
     });

--- a/tests/src/substrate/substrate-api.ts
+++ b/tests/src/substrate/substrate-api.ts
@@ -11,12 +11,11 @@
 import config from '../config';
 import promisifySubstrate from './promisify-substrate';
 import { ApiOptions, SubmittableExtrinsic, ApiTypes } from '@polkadot/api/types';
-import rtt from '../../../runtime_types.json';
 
 function defaultApiOptions(): ApiOptions {
   const wsProvider = new WsProvider(config.substrateUrl);
   return {
-    provider: wsProvider, types: rtt, signedExtensions: {
+    provider: wsProvider, signedExtensions: {
       ContractHelpers: {
         extrinsic: {},
         payload: {},
@@ -30,7 +29,7 @@
   const api: ApiPromise = new ApiPromise(settings);
   let result: T = null as unknown as T;
 
-  // TODO: Remove, this is temporary: Filter unneeded API output 
+  // TODO: Remove, this is temporary: Filter unneeded API output
   // (Jaco promised it will be removed in the next version)
   const consoleErr = console.error;
   const consoleLog = console.log;
@@ -41,7 +40,7 @@
       consoleErr(message);
       return;
     }
-    if (!message.includes('StorageChangeSet:: WebSocket is not connected') && 
+    if (!message.includes('StorageChangeSet:: WebSocket is not connected') &&
         !message.includes('2021-') &&
         !message.includes('StorageChangeSet:: Normal connection closure'))
       consoleErr(message);
@@ -79,7 +78,7 @@
   }
   if (status.isBroadcast) {
     return TransactionStatus.NotReady;
-  } 
+  }
   if (status.isInBlock || status.isFinalized) {
     if(events.filter(e => e.event.data.method === 'ExtrinsicFailed').length > 0) {
       return TransactionStatus.Fail;

--- a/tests/src/transferFrom.test.ts
+++ b/tests/src/transferFrom.test.ts
@@ -248,7 +248,7 @@
       const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
       await burnItemExpectSuccess(Alice, nftCollectionId, newNftTokenId, 1);
       await approveExpectFail(nftCollectionId, newNftTokenId, Alice, Bob);
-      await transferFromExpectFail(nftCollectionId, newNftTokenId, Bob, Alice, Charlie, 1);      
+      await transferFromExpectFail(nftCollectionId, newNftTokenId, Bob, Alice, Charlie, 1);
     });
   });
   it( 'transferFrom burnt token before approve Fungible', async () => {
@@ -258,9 +258,9 @@
       await burnItemExpectSuccess(Alice, fungibleCollectionId, 1, 10);
       await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob);
       await transferFromExpectFail(fungibleCollectionId, newFungibleTokenId, Bob, Alice, Charlie, 1);
-          
+
     });
-  }); 
+  });
   it( 'transferFrom burnt token before approve ReFungible', async () => {
     await usingApi(async () => {
       const reFungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
@@ -268,10 +268,10 @@
       await burnItemExpectSuccess(Alice, reFungibleCollectionId, newReFungibleTokenId, 1);
       await approveExpectFail(reFungibleCollectionId, newReFungibleTokenId, Alice, Bob);
       await transferFromExpectFail(reFungibleCollectionId, newReFungibleTokenId, Bob, Alice, Charlie, 1);
-          
+
     });
   });
-  
+
   it( 'transferFrom burnt token after approve NFT', async () => {
     await usingApi(async () => {
       // nft
@@ -279,7 +279,7 @@
       const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
       await approveExpectSuccess(nftCollectionId, newNftTokenId, Alice, Bob);
       await burnItemExpectSuccess(Alice, nftCollectionId, newNftTokenId, 1);
-      await transferFromExpectFail(nftCollectionId, newNftTokenId, Bob, Alice, Charlie, 1);      
+      await transferFromExpectFail(nftCollectionId, newNftTokenId, Bob, Alice, Charlie, 1);
     });
   });
   it( 'transferFrom burnt token after approve Fungible', async () => {
@@ -289,9 +289,9 @@
       await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob);
       await burnItemExpectSuccess(Alice, fungibleCollectionId, 1, 10);
       await transferFromExpectFail(fungibleCollectionId, newFungibleTokenId, Bob, Alice, Charlie, 1);
-          
+
     });
-  }); 
+  });
   it( 'transferFrom burnt token after approve ReFungible', async () => {
     await usingApi(async () => {
       const reFungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
@@ -299,14 +299,14 @@
       await approveExpectSuccess(reFungibleCollectionId, newReFungibleTokenId, Alice, Bob);
       await burnItemExpectSuccess(Alice, reFungibleCollectionId, newReFungibleTokenId, 1);
       await transferFromExpectFail(reFungibleCollectionId, newReFungibleTokenId, Bob, Alice, Charlie, 1);
-          
+
     });
   });
 
   it('fails when called by collection owner on non-owned item when OwnerCanTransfer == false', async () => {
     const collectionId = await createCollectionExpectSuccess();
     const itemId = await createItemExpectSuccess(Alice, collectionId, 'NFT', Bob.address);
-    await setCollectionLimitsExpectSuccess(Alice, collectionId, { OwnerCanTransfer: false });
+    await setCollectionLimitsExpectSuccess(Alice, collectionId, { ownerCanTransfer: false });
 
     await transferFromExpectFail(collectionId, itemId, Alice, Bob, Charlie);
   });

--- a/tests/src/types.ts
+++ b/tests/src/types.ts
@@ -6,29 +6,29 @@
 import BN from 'bn.js';
 
 export interface ICollectionInterface {
-  Access: string;
+  access: string;
   id: number;
-  DecimalPoints: BN;
+  decimalPoints: BN;
   // constOnChainSchema
-  Description: [BN, BN]; // utf16
+  description: [BN, BN]; // utf16
   isReFungible: boolean;
-  Limits: {
-    AccountTokenOwnershipLimit: number;
-    SponsoredDataSize: number;
-    SponsoredDataRateLimit?: number,
-    TokenLimit: number;
-    SponsorTimeout: number;
-    OwnerCanTransfer: boolean;
-    OwnerCanDestroy: boolean;
+  limits: {
+    accountTokenOwnershipLimit: number;
+    sponsoredDataSize: number;
+    sponsoredDataRateLimit?: number,
+    tokenLimit: number;
+    sponsorTimeout: number;
+    ownerCanTransfer: boolean;
+    ownerCanDestroy: boolean;
   };
-  MintMode: boolean;
-  Mode: {
-    Nft: null;
+  mintMode: boolean;
+  mode: {
+    nft: null;
   };
-  Name: [BN, BN]; // utf16
-  OffchainSchema: [Uint8Array];
-  Owner: [Uint8Array];
-  SchemaVersion: string;
+  name: [BN, BN]; // utf16
+  offchainSchema: [Uint8Array];
+  owner: [Uint8Array];
+  schemaVersion: string;
   // prefix
   // sponsor
   // tokenPrefix