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');
   });

32  it.skip('Collection limits allow greater number than chain limits, chain limits are enforced', async () => {32  it.skip('Collection limits allow greater number than chain limits, chain limits are enforced', async () => {
33      33
34    const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });34    const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });
35    await setCollectionLimitsExpectSuccess(Alice, collectionId, { AccountTokenOwnershipLimit: 20 });35    await setCollectionLimitsExpectSuccess(Alice, collectionId, { accountTokenOwnershipLimit: 20 });
36    for(let i = 0; i < 10; i++){36    for(let i = 0; i < 10; i++){
37      await createItemExpectSuccess(Alice, collectionId, 'NFT');37      await createItemExpectSuccess(Alice, collectionId, 'NFT');
38    }38    }
43  it('Collection limits allow lower number than chain limits, collection limits are enforced', async () => {43  it('Collection limits allow lower number than chain limits, collection limits are enforced', async () => {
4444
45    const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });45    const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });
46    await setCollectionLimitsExpectSuccess(Alice, collectionId, { AccountTokenOwnershipLimit: 1 });46    await setCollectionLimitsExpectSuccess(Alice, collectionId, { accountTokenOwnershipLimit: 1 });
47    await createItemExpectSuccess(Alice, collectionId, 'NFT');47    await createItemExpectSuccess(Alice, collectionId, 'NFT');
48    await createItemExpectFailure(Alice, collectionId, 'NFT');48    await createItemExpectFailure(Alice, collectionId, 'NFT');
49    await destroyCollectionExpectSuccess(collectionId);49    await destroyCollectionExpectSuccess(collectionId);
6161
62  it.skip('Collection limits allow greater number than chain limits, chain limits are enforced', async () => {   62  it.skip('Collection limits allow greater number than chain limits, chain limits are enforced', async () => {
63    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible' }});63    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible' }});
64    await setCollectionLimitsExpectSuccess(Alice, collectionId, { AccountTokenOwnershipLimit: 20 });64    await setCollectionLimitsExpectSuccess(Alice, collectionId, { accountTokenOwnershipLimit: 20 });
65    for(let i = 0; i < 10; i++){65    for(let i = 0; i < 10; i++){
66      await createItemExpectSuccess(Alice, collectionId, 'ReFungible');66      await createItemExpectSuccess(Alice, collectionId, 'ReFungible');
67    }67    }
7171
72  it('Collection limits allow lower number than chain limits, collection limits are enforced', async () => {72  it('Collection limits allow lower number than chain limits, collection limits are enforced', async () => {
73    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible' }});73    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible' }});
74    await setCollectionLimitsExpectSuccess(Alice, collectionId, { AccountTokenOwnershipLimit: 1 });74    await setCollectionLimitsExpectSuccess(Alice, collectionId, { accountTokenOwnershipLimit: 1 });
75    await createItemExpectSuccess(Alice, collectionId, 'ReFungible');75    await createItemExpectSuccess(Alice, collectionId, 'ReFungible');
76    await createItemExpectFailure(Alice, collectionId, 'ReFungible');76    await createItemExpectFailure(Alice, collectionId, 'ReFungible');
77    await destroyCollectionExpectSuccess(collectionId);77    await destroyCollectionExpectSuccess(collectionId);
9393
94  it('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {  94  it('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {
95    const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });95    const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });
96    await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 7 });96    await setCollectionLimitsExpectSuccess(Alice, collectionId, { sponsorTimeout: 7 });
97    const tokenId = await createItemExpectSuccess(Alice, collectionId, 'NFT');97    const tokenId = await createItemExpectSuccess(Alice, collectionId, 'NFT');
98    await setCollectionSponsorExpectSuccess(collectionId, Alice.address);98    await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
99    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');99    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
117  it('Collection limits have lower timeout value than chain limits, chain limits are enforced', async () => {117  it('Collection limits have lower timeout value than chain limits, chain limits are enforced', async () => {
118118
119    const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });119    const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });
120    await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 1 });120    await setCollectionLimitsExpectSuccess(Alice, collectionId, { sponsorTimeout: 1 });
121    const tokenId = await createItemExpectSuccess(Alice, collectionId, 'NFT');121    const tokenId = await createItemExpectSuccess(Alice, collectionId, 'NFT');
122    await setCollectionSponsorExpectSuccess(collectionId, Alice.address);122    await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
123    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');123    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
154154
155  it('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {  155  it('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {
156    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});156    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
157    await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 7 });157    await setCollectionLimitsExpectSuccess(Alice, collectionId, { sponsorTimeout: 7 });
158    const tokenId = await createItemExpectSuccess(Alice, collectionId, 'Fungible');158    const tokenId = await createItemExpectSuccess(Alice, collectionId, 'Fungible');
159    await setCollectionSponsorExpectSuccess(collectionId, Alice.address);159    await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
160    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');160    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
180  it('Collection limits have lower timeout value than chain limits, chain limits are enforced', async () => {180  it('Collection limits have lower timeout value than chain limits, chain limits are enforced', async () => {
181181
182    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});182    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
183    await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 1 });183    await setCollectionLimitsExpectSuccess(Alice, collectionId, { sponsorTimeout: 1 });
184    const tokenId = await createItemExpectSuccess(Alice, collectionId, 'Fungible');184    const tokenId = await createItemExpectSuccess(Alice, collectionId, 'Fungible');
185    await setCollectionSponsorExpectSuccess(collectionId, Alice.address);185    await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
186    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');186    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
219219
220  it('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {  220  it('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {
221    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible' }});221    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible' }});
222    await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 7 });222    await setCollectionLimitsExpectSuccess(Alice, collectionId, { sponsorTimeout: 7 });
223    const tokenId = await createItemExpectSuccess(Alice, collectionId, 'ReFungible');223    const tokenId = await createItemExpectSuccess(Alice, collectionId, 'ReFungible');
224    await setCollectionSponsorExpectSuccess(collectionId, Alice.address);224    await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
225    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');225    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
243  it('Collection limits have lower timeout value than chain limits, chain limits are enforced', async () => {243  it('Collection limits have lower timeout value than chain limits, chain limits are enforced', async () => {
244244
245    const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });245    const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });
246    await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 1 });246    await setCollectionLimitsExpectSuccess(Alice, collectionId, { sponsorTimeout: 1 });
247    const tokenId = await createItemExpectSuccess(Alice, collectionId, 'NFT');247    const tokenId = await createItemExpectSuccess(Alice, collectionId, 'NFT');
248    await setCollectionSponsorExpectSuccess(collectionId, Alice.address);248    await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
249    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');249    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
280280
281  it.skip('Limits have 0 in tokens per address field, the chain limits are applied', async () => {  281  it.skip('Limits have 0 in tokens per address field, the chain limits are applied', async () => {
282    const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });282    const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });
283    await setCollectionLimitsExpectSuccess(Alice, collectionId, { AccountTokenOwnershipLimit: 0 });283    await setCollectionLimitsExpectSuccess(Alice, collectionId, { accountTokenOwnershipLimit: 0 });
284    for(let i = 0; i < 10; i++){284    for(let i = 0; i < 10; i++){
285      await createItemExpectSuccess(Alice, collectionId, 'NFT');285      await createItemExpectSuccess(Alice, collectionId, 'NFT');
286    }286    }
290  it('Limits have 0 in sponsor timeout, no limits are applied', async () => {290  it('Limits have 0 in sponsor timeout, no limits are applied', async () => {
291291
292    const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });292    const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });
293    await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 0 });293    await setCollectionLimitsExpectSuccess(Alice, collectionId, { sponsorTimeout: 0 });
294    const tokenId = await createItemExpectSuccess(Alice, collectionId, 'NFT');294    const tokenId = await createItemExpectSuccess(Alice, collectionId, 'NFT');
295    await setCollectionSponsorExpectSuccess(collectionId, Alice.address);295    await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
296    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');296    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
320320
321  it('Limits have 0 in sponsor timeout, no limits are applied', async () => {321  it('Limits have 0 in sponsor timeout, no limits are applied', async () => {
322    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});322    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
323    await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 0 });323    await setCollectionLimitsExpectSuccess(Alice, collectionId, { sponsorTimeout: 0 });
324    const tokenId = await createItemExpectSuccess(Alice, collectionId, 'Fungible');324    const tokenId = await createItemExpectSuccess(Alice, collectionId, 'Fungible');
325    await setCollectionSponsorExpectSuccess(collectionId, Alice.address);325    await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
326    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');326    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
351351
352  it.skip('Limits have 0 in tokens per address field, the chain limits are applied', async () => {  352  it.skip('Limits have 0 in tokens per address field, the chain limits are applied', async () => {
353    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible' }});353    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible' }});
354    await setCollectionLimitsExpectSuccess(Alice, collectionId, { AccountTokenOwnershipLimit: 0 });354    await setCollectionLimitsExpectSuccess(Alice, collectionId, { accountTokenOwnershipLimit: 0 });
355    for(let i = 0; i < 10; i++){355    for(let i = 0; i < 10; i++){
356      await createItemExpectSuccess(Alice, collectionId, 'ReFungible');356      await createItemExpectSuccess(Alice, collectionId, 'ReFungible');
357    }357    }
361  it('Limits have 0 in sponsor timeout, no limits are applied', async () => {361  it('Limits have 0 in sponsor timeout, no limits are applied', async () => {
362362
363    const collectionId = await createCollectionExpectSuccess({ mode: { type: 'ReFungible' } });363    const collectionId = await createCollectionExpectSuccess({ mode: { type: 'ReFungible' } });
364    await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 0 });364    await setCollectionLimitsExpectSuccess(Alice, collectionId, { sponsorTimeout: 0 });
365    const tokenId = await createItemExpectSuccess(Alice, collectionId, 'ReFungible');365    const tokenId = await createItemExpectSuccess(Alice, collectionId, 'ReFungible');
366    await setCollectionSponsorExpectSuccess(collectionId, Alice.address);366    await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
367    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');367    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

--- a/tests/src/util/helpers.ts
+++ b/tests/src/util/helpers.ts
@@ -84,14 +84,14 @@
 }
 
 interface IReFungibleOwner {
-  Fraction: BN;
-  Owner: number[];
+  fraction: BN;
+  owner: number[];
 }
 
 interface ITokenDataType {
-  Owner: IKeyringPair;
-  ConstData: number[];
-  VariableData: number[];
+  owner: IKeyringPair;
+  constData: number[];
+  variableData: number[];
 }
 
 interface IGetMessage {
@@ -101,26 +101,26 @@
 }
 
 export interface IFungibleTokenDataType {
-  Value: number;
+  value: number;
 }
 
 export interface IChainLimits {
-  CollectionNumbersLimit: number;
-	AccountTokenOwnershipLimit: number;
-	CollectionsAdminsLimit: number;
-	CustomDataLimit: number;
-	NftSponsorTransferTimeout: number;
-	FungibleSponsorTransferTimeout: number;
-	RefungibleSponsorTransferTimeout: number;
-	OffchainSchemaLimit: number;
-	VariableOnChainSchemaLimit: number;
-	ConstOnChainSchemaLimit: number;
+  collectionNumbersLimit: number;
+	accountTokenOwnershipLimit: number;
+	collectionsAdminsLimit: number;
+	customDataLimit: number;
+	nftSponsorTransferTimeout: number;
+	fungibleSponsorTransferTimeout: number;
+	refungibleSponsorTransferTimeout: number;
+	offchainSchemaLimit: number;
+	variableOnChainSchemaLimit: number;
+	constOnChainSchemaLimit: number;
 }
 
 export interface IReFungibleTokenDataType {
-  Owner: IReFungibleOwner[];
-  ConstData: number[];
-  VariableData: number[];
+  owner: IReFungibleOwner[];
+  constData: number[];
+  variableData: number[];
 }
 
 export function nftEventMessage(events: EventRecord[]): IGetMessage {
@@ -290,10 +290,10 @@
     // tslint:disable-next-line:no-unused-expression
     expect(collection).to.be.not.null;
     expect(BcollectionCount).to.be.equal(AcollectionCount + 1, 'Error: NFT collection NOT created.');
-    expect(collection.Owner).to.be.equal(toSubstrateAddress(alicesPublicKey));
-    expect(utf16ToStr(collection.Name)).to.be.equal(name);
-    expect(utf16ToStr(collection.Description)).to.be.equal(description);
-    expect(hexToStr(collection.TokenPrefix)).to.be.equal(tokenPrefix);
+    expect(collection.owner).to.be.equal(toSubstrateAddress(alicesPublicKey));
+    expect(utf16ToStr(collection.name)).to.be.equal(name);
+    expect(utf16ToStr(collection.description)).to.be.equal(description);
+    expect(hexToStr(collection.tokenPrefix)).to.be.equal(tokenPrefix);
 
     collectionId = result.collectionId;
   });
@@ -400,7 +400,7 @@
 
 export async function queryCollectionLimits(collectionId: number) {
   return await usingApi(async (api) => {
-    return ((await api.query.nft.collectionById(collectionId)).toJSON() as any).Limits;
+    return ((await api.query.nft.collectionById(collectionId)).toJSON() as any).limits;
   });
 }
 
@@ -442,7 +442,7 @@
 
     // What to expect
     expect(result.success).to.be.true;
-    expect(collection.Sponsorship).to.deep.equal({
+    expect(collection.sponsorship).to.deep.equal({
       unconfirmed: sponsor,
     });
   });
@@ -462,7 +462,7 @@
 
     // What to expect
     expect(result.success).to.be.true;
-    expect(collection.Sponsorship).to.be.deep.equal({ disabled: null });
+    expect(collection.sponsorship).to.be.deep.equal({ disabled: null });
   });
 }
 
@@ -500,7 +500,7 @@
 
     // What to expect
     expect(result.success).to.be.true;
-    expect(collection.Sponsorship).to.be.deep.equal({
+    expect(collection.sponsorship).to.be.deep.equal({
       confirmed: sender.address,
     });
   });
@@ -758,17 +758,17 @@
     expect(result.success).to.be.true;
     if (type === 'NFT') {
       const nftItemData = (await api.query.nft.nftItemList(collectionId, tokenId) as any).toJSON() as ITokenDataType;
-      expect(nftItemData.Owner).to.be.deep.equal(to);
+      expect(nftItemData.owner).to.be.deep.equal(to);
     }
     if (type === 'Fungible') {
-      const balanceAfter = (await api.query.nft.fungibleItemList(collectionId, toSubstrateAddress(to)) as any).Value as unknown as BN;
+      const balanceAfter = (await api.query.nft.fungibleItemList(collectionId, toSubstrateAddress(to)) as any).value as unknown as BN;
       expect(balanceAfter.sub(balanceBefore).toString()).to.be.equal(value.toString());
     }
     if (type === 'ReFungible') {
       const nftItemData =
         (await api.query.nft.reFungibleItemList(collectionId, tokenId) as any).toJSON() as IReFungibleTokenDataType;
-      expect(nftItemData.Owner[0].Owner).to.be.deep.equal(normalizeAccountId(to));
-      expect(nftItemData.Owner[0].Fraction).to.be.equal(value);
+      expect(nftItemData.owner[0].owner).to.be.deep.equal(normalizeAccountId(to));
+      expect(nftItemData.owner[0].fraction).to.be.equal(value);
     }
   });
 }
@@ -814,8 +814,8 @@
 getFreeBalance(account: IKeyringPair) : Promise<BigNumber>
 {
   let balance = new BigNumber(0) ;
-  await usingApi(async (api) => { 
-    balance = new BigNumber((await api.query.system.account(account.address)).data.free.toString());  
+  await usingApi(async (api) => {
+    balance = new BigNumber((await api.query.system.account(account.address)).data.free.toString());
   });
 
   return balance;
@@ -844,7 +844,7 @@
     const recipientBalanceBefore = new BigNumber((await api.query.system.account(recipient.address)).data.free.toString());
 
     const nftItemDataBefore = (await api.query.nft.nftItemList(collectionId, tokenId)).toJSON() as any as ITokenDataType;
-    expect(toSubstrateAddress(nftItemDataBefore.Owner)).to.be.equal(sender.address);
+    expect(toSubstrateAddress(nftItemDataBefore.owner)).to.be.equal(sender.address);
 
     // sleep for 4 blocks
     await new Promise(resolve => setTimeout(resolve, blockTimeMs * (blockSchedule + 1)));
@@ -852,7 +852,7 @@
     const recipientBalanceAfter = new BigNumber((await api.query.system.account(recipient.address)).data.free.toString());
 
     const nftItemData = (await api.query.nft.nftItemList(collectionId, tokenId)).toJSON() as unknown as ITokenDataType;
-    expect(toSubstrateAddress(nftItemData.Owner)).to.be.equal(recipient.address);
+    expect(toSubstrateAddress(nftItemData.owner)).to.be.equal(recipient.address);
     expect(recipientBalanceAfter.toNumber()).to.be.equal(recipientBalanceBefore.toNumber());
   });
 }
@@ -886,20 +886,20 @@
     expect(result.value.toString()).to.be.equal(value.toString());
     if (type === 'NFT') {
       const nftItemData = (await api.query.nft.nftItemList(collectionId, tokenId)).toJSON() as unknown as ITokenDataType;
-      expect(nftItemData.Owner).to.be.deep.equal(to);
+      expect(nftItemData.owner).to.be.deep.equal(to);
     }
     if (type === 'Fungible') {
-      const balanceAfter = (await api.query.nft.fungibleItemList(collectionId, toSubstrateAddress(to)) as any).Value as unknown as BN;
+      const balanceAfter = (await api.query.nft.fungibleItemList(collectionId, toSubstrateAddress(to)) as any).value as unknown as BN;
       expect(balanceAfter.sub(balanceBefore).toString()).to.be.equal(value.toString());
     }
     if (type === 'ReFungible') {
       const nftItemData =
         (await api.query.nft.reFungibleItemList(collectionId, tokenId)).toJSON() as unknown as IReFungibleTokenDataType;
       const expectedOwner = toSubstrateAddress(to);
-      const ownerIndex = nftItemData.Owner.findIndex(v => toSubstrateAddress(v.Owner as any as string) == expectedOwner);
+      const ownerIndex = nftItemData.owner.findIndex(v => toSubstrateAddress(v.owner as any as string) == expectedOwner);
       expect(ownerIndex).to.not.equal(-1);
-      expect(nftItemData.Owner[ownerIndex].Owner).to.be.deep.equal(normalizeAccountId(to));
-      expect(nftItemData.Owner[ownerIndex].Fraction).to.be.greaterThanOrEqual(value as number);
+      expect(nftItemData.owner[ownerIndex].owner).to.be.deep.equal(normalizeAccountId(to));
+      expect(nftItemData.owner[ownerIndex].fraction).to.be.greaterThanOrEqual(value as number);
     }
   });
 }
@@ -942,8 +942,8 @@
   owner: string,
 ) {
   return await usingApi(async (api) => {
-    const response = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON() as unknown as { Value: string };
-    return BigInt(response.Value);
+    const response = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON() as unknown as { value: string };
+    return BigInt(response.value);
   });
 }
 
@@ -970,7 +970,7 @@
     const to = normalizeAccountId(owner);
     const AItemCount = parseInt((await api.query.nft.itemListIndex(collectionId)).toString(), 10);
     const Aitem: any = (await api.query.nft.fungibleItemList(collectionId, toSubstrateAddress(to))).toJSON();
-    const AItemBalance = new BigNumber(Aitem.Value);
+    const AItemBalance = new BigNumber(Aitem.value);
 
     let tx;
     if (createMode === 'Fungible') {
@@ -989,7 +989,7 @@
 
     const BItemCount = parseInt((await api.query.nft.itemListIndex(collectionId)).toString(), 10);
     const Bitem: any = (await api.query.nft.fungibleItemList(collectionId, toSubstrateAddress(to))).toJSON();
-    const BItemBalance = new BigNumber(Bitem.Value);
+    const BItemBalance = new BigNumber(Bitem.value);
 
     // What to expect
     // tslint:disable-next-line:no-unused-expression
@@ -1035,7 +1035,7 @@
     // What to expect
     // tslint:disable-next-line:no-unused-expression
     expect(result.success).to.be.true;
-    expect(collection.Access).to.be.equal(accessMode);
+    expect(collection.access).to.be.equal(accessMode);
   });
 }
 
@@ -1082,7 +1082,7 @@
     // What to expect
     // tslint:disable-next-line:no-unused-expression
     expect(result.success).to.be.true;
-    expect(collection.MintMode).to.be.equal(enabled);
+    expect(collection.mintMode).to.be.equal(enabled);
   });
 }
 
@@ -1166,7 +1166,7 @@
 
 export async function addToWhiteListExpectFail(sender: IKeyringPair, collectionId: number, address: string | AccountId) {
   await usingApi(async (api) => {
-    
+
     // Run the transaction
     const tx = api.tx.nft.addToWhiteList(collectionId, normalizeAccountId(address));
     const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;
@@ -1221,7 +1221,7 @@
 }
 
 export async function queryNftOwner(api: ApiPromise, collectionId: number, tokenId: number): Promise<CrossAccountId> {
-  return normalizeAccountId((await api.query.nft.nftItemList(collectionId, tokenId) as any).toJSON().Owner);
+  return normalizeAccountId((await api.query.nft.nftItemList(collectionId, tokenId) as any).toJSON().owner);
 }
 
 export async function waitNewBlocks(blocksCount = 1): Promise<void> {