suidouble 0.0.51 → 1.0.4-2

package/test/different_types_args.test.js

@@ -0,0 +1,108 @@
+'use strict'
+
+const t = require('tap');
+const { test } = t;
+const path = require('path');
+
+const { SuiMaster, SuiLocalTestValidator } = require('..');
+
+let suiLocalTestValidator = null;
+let suiMaster = null;
+let contract = null;
+
+let store = null;
+
+test('spawn local test node', async t => {
+    suiLocalTestValidator = await SuiLocalTestValidator.launch({ testFallbackEnabled: true });
+    t.ok(suiLocalTestValidator.active);
+
+    // SuiLocalTestValidator runs as signle instance. So you can't start it twice with static method
+    const suiLocalTestValidatorCopy = await SuiLocalTestValidator.launch();
+    t.equal(suiLocalTestValidator, suiLocalTestValidatorCopy);
+});
+
+test('init suiMaster and connect it to local test validator', async t => {
+    suiMaster = new SuiMaster({client: suiLocalTestValidator, as: 'somebody', debug: true});
+    await suiMaster.initialize();
+
+    t.ok(suiMaster.address); // there should be some address
+    t.ok(`${suiMaster.address}`.indexOf('0x') === 0); // adress is string starting with '0x'
+});
+test('request sui from faucet', async t => {
+    const balanceBefore = await suiMaster.getBalance();
+    await suiMaster.requestSuiFromFaucet();
+
+    const balanceAfter = await suiMaster.getBalance();
+
+    t.ok(balanceAfter > balanceBefore);
+});
+
+test('attach a local package', async t => {
+    contract = suiMaster.addPackage({
+        path: path.join(__dirname, './test_move_contracts/different_types/'),
+    });
+    await contract.build();
+    await contract.publish();
+
+    store = suiMaster.objectStorage.findMostRecentByTypeName('Store'); // should be in local objectStorage after publish
+    await store.fetchFields();
+    t.ok(store.fields.numbers == 0); // values on init
+});
+
+test('try to update store with different types', async t => {
+    await contract.moveCall('different_types', 'put_u8', [ store.id, contract.arg('u8', 77) ]);
+    await contract.moveCall('different_types', 'put_u16', [ store.id, contract.arg('u16', 77) ]);
+    await contract.moveCall('different_types', 'put_u32', [ store.id, contract.arg('u32', 77) ]);
+    await contract.moveCall('different_types', 'put_u64', [ store.id, contract.arg('u64', 77) ]);
+    await contract.moveCall('different_types', 'put_u128', [ store.id, contract.arg('u128', 77) ]);
+    await contract.moveCall('different_types', 'put_u256', [ store.id, contract.arg('u256', 77) ]);
+
+    await store.fetchFields();
+    t.ok(store.fields.numbers == 6 * 77); // incremented 6 times by 77
+
+    await contract.moveCall('different_types', 'put_vector_u16', [ store.id, contract.arg('vector<u16>', [77,77,77,77]) ]);
+
+    await store.fetchFields();
+    t.ok(store.fields.numbers == 10 * 77); // plus 4 more times by 77
+
+    await contract.moveCall('different_types', 'put_bool', [ store.id, contract.arg('bool', true) ]);
+    await contract.moveCall('different_types', 'put_address', [ store.id, contract.arg('address', store.id) ]);
+
+    await store.fetchFields();
+    t.ok(store.fields.v_bool == true); 
+    t.ok(store.fields.v_address == store.id); 
+
+    await contract.moveCall('different_types', 'put_string', [ store.id, contract.arg('string', 'test') ]);
+
+    await store.fetchFields();
+    t.ok(store.fields.v_string == 'test'); 
+});
+
+test('module has same methods for args', async t => {
+    const mod = contract.modules.different_types;
+    await mod.moveCall('put_string', [ store.id, mod.arg('string', 'another test') ]);
+
+    await store.fetchFields();
+    t.ok(store.fields.v_string == 'another test'); 
+});
+
+test('passing typeArguments parameters', async t => {
+    const mod = contract.modules.different_types;
+
+    await mod.moveCall('put_type', [ store.id ], [ 'bool' ]);
+
+    await store.fetchFields();
+    t.ok(store.fields.v_string == 'bool'); 
+
+
+    await mod.moveCall('put_type', [ store.id ], [ store.type ]);
+    await store.fetchFields();
+
+    // it's '_____packageid____::different_types::Store'
+    t.ok(store.fields.v_string.indexOf('::different_types::Store') > 0); 
+});
+
+
+test('stops local test node', async t => {
+    await SuiLocalTestValidator.stop();
+});

package/test/sui_master_basic.test.js

@@ -13,7 +13,7 @@ test('initialization', async t => {
 });
 
 test('pseudo-random keypairs generation works ok', async t => {
-    const suiMaster = new SuiMaster({provider: 'test', as: 'somebody'});
+    const suiMaster = new SuiMaster({client: 'test', as: 'somebody'});
     await suiMaster.initialize();
 
     // pseudo-random generation of 'somebody' is a keypair for a wallet '0x15b9493fb639a3118fed766ca80c1da62fa20493c293f319cc7d136506d2db69'
@@ -24,7 +24,7 @@ test('pseudo-random keypairs generation works ok', async t => {
     t.ok(suiMaster.address); // there should be some address
     t.ok(`${suiMaster.address}`.indexOf('0x') === 0); // adress is string starting with '0x'
 
-    const suiMasterAsAdmin = new SuiMaster({provider: 'test', as: 'admin'});
+    const suiMasterAsAdmin = new SuiMaster({client: 'test', as: 'admin'});
     await suiMasterAsAdmin.initialize();
 
     t.ok(suiMasterAsAdmin.address); // there should be some address
@@ -33,7 +33,7 @@ test('pseudo-random keypairs generation works ok', async t => {
     t.not(`${suiMaster.address}`, `${suiMasterAsAdmin.address}`, 'different pseudo randoms should be different');
 
     /// but if you pass the same string as 'as' - it will generate the same keypair:
-    const suiMasterAsAdminAnother =  new SuiMaster({provider: 'test', as: 'admin'});
+    const suiMasterAsAdminAnother =  new SuiMaster({client: 'test', as: 'admin'});
     await suiMasterAsAdminAnother.initialize();
 
     t.equal(`${suiMasterAsAdminAnother.address}`, `${suiMasterAsAdmin.address}`, 'same string should generate same pseudo-random');
@@ -42,15 +42,15 @@ test('pseudo-random keypairs generation works ok', async t => {
 test('keypair generation with seed phrase works ok', async t => {
     // Ed25519
     const phrase = 'seek weekend run rival noodle dog alone mosquito decide hover aerobic fiction'; // 0x2bfe9c35ca9400c42e24e4b424cbd2dfb51bcb7c2487e1b4694ff53d8ca00262
-    const suiMaster = new SuiMaster({provider: 'test', phrase: phrase});
+    const suiMaster = new SuiMaster({client: 'test', phrase: phrase});
     await suiMaster.initialize();
 
     t.equal(`${suiMaster.address}`, `0x2bfe9c35ca9400c42e24e4b424cbd2dfb51bcb7c2487e1b4694ff53d8ca00262`, 'Ed25519 generated ok');
 
-    const suiMasterNextAccount = new SuiMaster({provider: 'test', phrase: phrase, accountIndex: 1}); // default = 0
+    const suiMasterNextAccount = new SuiMaster({client: 'test', phrase: phrase, accountIndex: 1}); // default = 0
     await suiMasterNextAccount.initialize();
 
-    t.notEqual(`${suiMaster.address}`, `${suiMasterNextAccount.address}`);
+    t.not(`${suiMaster.address}`, `${suiMasterNextAccount.address}`);
 
     t.equal(`${suiMasterNextAccount.address}`, `0xa6fb5c51b751e07a3e3b3af1f40f3115004702aad5a96263ff0be9078195f43b`, 'Ed25519 next account generated ok');
 });
@@ -58,15 +58,15 @@ test('keypair generation with seed phrase works ok', async t => {
 test('keypair generation with seed phrase works ok with secp256r1', async t => {
     // Ed25519
     const phrase = 'seek weekend run rival noodle dog alone mosquito decide hover aerobic fiction'; // 
-    const suiMaster = new SuiMaster({provider: 'test', phrase: phrase, keypairAlgo: 'secp256r1'});
+    const suiMaster = new SuiMaster({client: 'test', phrase: phrase, keypairAlgo: 'secp256r1'});
     await suiMaster.initialize();
 
     t.equal(`${suiMaster.address}`, `0x444f18d480b4d776d7679fae88ebb4f274941a81c3d98db430f7bd13f82e287d`, 'secp256r1 generated ok');
 
-    const suiMasterNextAccount = new SuiMaster({provider: 'test', phrase: phrase, accountIndex: 1, keypairAlgo: 'secp256r1'}); // default = 0
+    const suiMasterNextAccount = new SuiMaster({client: 'test', phrase: phrase, accountIndex: 1, keypairAlgo: 'secp256r1'}); // default = 0
     await suiMasterNextAccount.initialize();
 
-    t.notEqual(`${suiMaster.address}`, `${suiMasterNextAccount.address}`);
+    t.not(`${suiMaster.address}`, `${suiMasterNextAccount.address}`);
 
     t.equal(`${suiMasterNextAccount.address}`, `0xae496597c64aa6b1aaa03792c0ba0a725b1212adcb0df85d22c447cd57c21c95`, 'secp256r1 next account generated ok');
 });
@@ -75,21 +75,21 @@ test('keypair generation with seed phrase works ok with secp256r1', async t => {
 test('keypair generation with seed phrase works ok with secp256k1', async t => {
     // Ed25519
     const phrase = 'seek weekend run rival noodle dog alone mosquito decide hover aerobic fiction'; // 
-    const suiMaster = new SuiMaster({provider: 'test', phrase: phrase, keypairAlgo: 'secp256k1'});
+    const suiMaster = new SuiMaster({client: 'test', phrase: phrase, keypairAlgo: 'secp256k1'});
     await suiMaster.initialize();
 
     t.equal(`${suiMaster.address}`, `0x86a5dd3def25cab060af90f438842524894c7901839a954b2e9547ecc0f35ef8`, 'secp256k1 generated ok');
 
-    const suiMasterNextAccount = new SuiMaster({provider: 'test', phrase: phrase, accountIndex: 1, keypairAlgo: 'secp256k1'}); // default = 0
+    const suiMasterNextAccount = new SuiMaster({client: 'test', phrase: phrase, accountIndex: 1, keypairAlgo: 'secp256k1'}); // default = 0
     await suiMasterNextAccount.initialize();
 
-    t.notEqual(`${suiMaster.address}`, `${suiMasterNextAccount.address}`);
+    t.not(`${suiMaster.address}`, `${suiMasterNextAccount.address}`);
 
     t.equal(`${suiMasterNextAccount.address}`, `0xc5390344b0344a3e657176eaf72ca00ecf3ed4ec791640b6fc65a11cb680c53f`, 'secp256k1 next account generated ok');
 });
 
 test('SuiMaster has MIST_PER_SUI property available as BigInt', async t => {
-    const suiMaster = new SuiMaster({provider: 'test', as: 'somebody'});
+    const suiMaster = new SuiMaster({client: 'test', as: 'somebody'});
 
     t.ok(suiMaster.MIST_PER_SUI);
 
@@ -102,22 +102,22 @@ test('SuiMaster has MIST_PER_SUI property available as BigInt', async t => {
 });
 
 test('connecting to different chains', async t => {
-    const suiMaster = new SuiMaster({provider: 'test', as: 'somebody'});
+    const suiMaster = new SuiMaster({client: 'test', as: 'somebody'});
     await suiMaster.initialize();
 
     t.equal(suiMaster.connectedChain, 'sui:testnet');
 
-    const suiMaster2 = new SuiMaster({provider: 'dev', as: 'somebody'});
+    const suiMaster2 = new SuiMaster({client: 'dev', as: 'somebody'});
     await suiMaster2.initialize();
 
     t.equal(suiMaster2.connectedChain, 'sui:devnet');
 
-    const suiMaster3 = new SuiMaster({provider: 'main', as: 'somebody'});
+    const suiMaster3 = new SuiMaster({client: 'main', as: 'somebody'});
     await suiMaster3.initialize();
 
     t.equal(suiMaster3.connectedChain, 'sui:mainnet');
 
-    const suiMaster4 = new SuiMaster({provider: 'local', as: 'somebody'});
+    const suiMaster4 = new SuiMaster({client: 'local', as: 'somebody'});
     await suiMaster4.initialize();
 
     t.equal(suiMaster4.connectedChain, 'sui:localnet');

package/test/sui_master_onlocal.test.js

@@ -27,7 +27,7 @@ test('spawn local test node', async t => {
 });
 
 test('init suiMaster and connect it to local test validator', async t => {
-    suiMaster = new SuiMaster({provider: suiLocalTestValidator, as: 'somebody', debug: true});
+    suiMaster = new SuiMaster({client: suiLocalTestValidator, as: 'somebody', debug: true});
     await suiMaster.initialize();
 
     t.ok(suiMaster.address); // there should be some address
@@ -97,7 +97,7 @@ test('attach a local package', async t => {
 });
 
 test('attach a package by address on the blockchain', async t => {
-    suiMaster = new SuiMaster({provider: suiLocalTestValidator, as: 'somebody'});
+    suiMaster = new SuiMaster({client: suiLocalTestValidator, as: 'somebody'});
     await suiMaster.initialize();
 
     contract = await suiMaster.addPackage({
@@ -124,7 +124,7 @@ test('attach a package by address on the blockchain', async t => {
 });
 
 test('can find a package on the blockchain by expected module name (in owned)', async t => {
-    suiMaster = new SuiMaster({provider: suiLocalTestValidator, as: 'somebody'});
+    suiMaster = new SuiMaster({client: suiLocalTestValidator, as: 'somebody'});
     await suiMaster.initialize();
 
     contract = await suiMaster.addPackage({
@@ -166,7 +166,7 @@ test('subscribe to module events', async t => {
         gotEventChatResponseCreated = event.detail; // .detail is reference to event itself. To support CustomEvent pattern
     });
 
-    await contract.moveCall('suidouble_chat', 'post', [chatShopObjectId, 'the message', 'metadata']);
+    await contract.moveCall('suidouble_chat', 'post', [chatShopObjectId, contract.arg('string', 'the message'), contract.arg('string', 'metadata')]);
     await new Promise((res)=>setTimeout(res, 300)); // got events without timeout, but just to be sure.
 
     t.ok(gotEventChatTopMessageCreated);
@@ -181,7 +181,7 @@ test('subscribe to module events', async t => {
 });
 
 test('execute contract methods', async t => {
-    const moveCallResult = await contract.moveCall('suidouble_chat', 'post', [chatShopObjectId, 'the message', 'metadata']);
+    const moveCallResult = await contract.moveCall('suidouble_chat', 'post', [chatShopObjectId, contract.arg('string', 'the message'), contract.arg('string', 'metadata')]);
 
     // there're at least some object created
     t.ok(moveCallResult.created.length > 0);
@@ -223,7 +223,7 @@ test('execute contract methods', async t => {
     t.ok(dynamicFields.data.length === 1);
 
     const responseTextAsBytes = [].slice.call(new TextEncoder().encode('ขอบคุณครับ, 🇺🇦')); // regular array with utf data
-    const moveCallResult2 = await contract.moveCall('suidouble_chat', 'reply', [chatTopMessage.id, responseTextAsBytes, 'metadata']);
+    const moveCallResult2 = await contract.moveCall('suidouble_chat', 'reply', [chatTopMessage.id, contract.arg('string', 'ขอบคุณครับ, 🇺🇦'), contract.arg('string', 'metadata')]);
 
     // there're at least some object created
     t.ok(moveCallResult2.created.length > 0);
@@ -248,7 +248,7 @@ test('testing paginatedResponse', async t => {
     t.ok(chatTopMessage);
 
     // fill method create a lot of responses ( check out contract's code )
-    const moveCallResult = await contract.moveCall('suidouble_chat', 'fill', [chatTopMessage.id, 'the message response', 'metadata']);
+    const moveCallResult = await contract.moveCall('suidouble_chat', 'fill', [chatTopMessage.id, contract.arg('string', 'the message response'), contract.arg('string', 'metadata')]);
     t.ok(moveCallResult.created.length >= 60); // it's 60 in move code, but let's keep chat flexible
 
     const eventsResponse = await contract.fetchEvents('suidouble_chat');
@@ -282,6 +282,8 @@ test('testing paginatedResponse', async t => {
 
 test('find owned module objects with query', async t => {
     const module = await contract.getModule('suidouble_chat');
+    await module.getNormalizedMoveFunction('fill');
+
     const paginatedResponse = await module.getOwnedObjects();
 
     let foundCount = 0;
@@ -319,10 +321,10 @@ test('testing move call with coins', async t => {
 
     const longMessageYouCanNotPostForFree = ('message ').padEnd(500, 'test');
     // can't post it for free (as per contract design)
-    t.rejects(contract.moveCall('suidouble_chat', 'post', [chatShopObjectId, longMessageYouCanNotPostForFree, 'metadata']));
+    t.rejects(contract.moveCall('suidouble_chat', 'post', [chatShopObjectId, contract.arg('string', longMessageYouCanNotPostForFree), contract.arg('string', 'metadata')]));
 
     // but can post with with post_pay function sending some sui to it
-    const moveCallResult = await contract.moveCall('suidouble_chat', 'post_pay', [chatShopObjectId, {type: 'SUI', amount: 400000000000n}, longMessageYouCanNotPostForFree, 'metadata']);
+    const moveCallResult = await contract.moveCall('suidouble_chat', 'post_pay', [chatShopObjectId, {type: 'SUI', amount: 400000000000n}, contract.arg('string', longMessageYouCanNotPostForFree), contract.arg('string', 'metadata')]);
 
     // there're at least some object created
     t.ok(moveCallResult.created.length > 0);

package/test/sui_test_scenario.test.js

@@ -29,7 +29,7 @@ test('checking takeShared', async t => {
         t.ok(chatShop.address); // there should be some address
         t.ok(`${chatShop.address}`.indexOf('0x') === 0); // adress is string starting with '0x'
 
-        await testScenario.moveCall('suidouble_chat', 'post', [chatShop.address, 'posting a message', 'metadata']);
+        await testScenario.moveCall('suidouble_chat', 'post', [chatShop.address, testScenario.arg('string', 'posting a message'),  testScenario.arg('string', 'metadata')]);
         const chatTopMessage = testScenario.takeShared('ChatTopMessage');
 
         t.ok(chatTopMessage.address); // there should be some address
@@ -44,7 +44,7 @@ test('checking takeOwned', async t => {
         const chatTopMessage = testScenario.takeShared('ChatTopMessage');
         t.ok(chatTopMessage.address); // there should be some address
 
-        await testScenario.moveCall('suidouble_chat', 'reply', [chatTopMessage.address, 'posting a response', 'metadata']);
+        await testScenario.moveCall('suidouble_chat', 'reply', [chatTopMessage.address, testScenario.arg('string', 'posting a response'), testScenario.arg('string', 'metadata')]);
         const chatResponse = testScenario.takeFromSender('ChatResponse');
 
         t.ok(chatResponse.address); // there should be some address

package/test/test_move_contracts/{suidouble_color → different_types}/Move.lock

@@ -1,8 +1,9 @@
 # @generated by Move, please check-in and do not edit manually.
 
 [move]
-version = 0
-
+version = 2
+manifest_digest = "782E5DC5571D50504E8D0062C1C45607FF5A73378BE161077BCEF58ADEC1A3F5"
+deps_digest = "F8BBB0CCB2491CA29A3DF03D6F92277A4F3574266507ACD77214D37ECA3F3082"
 dependencies = [
   { name = "Sui" },
 ]
@@ -18,3 +19,8 @@ source = { git = "https://github.com/MystenLabs/sui.git", rev = "testnet", subdi
 dependencies = [
   { name = "MoveStdlib" },
 ]
+
+[move.toolchain-version]
+compiler-version = "1.25.1"
+edition = "2024.beta"
+flavor = "sui"

package/test/test_move_contracts/{suidouble_color → different_types}/Move.toml

@@ -1,10 +1,11 @@
 [package]
-name = "suidouble_color"
+name = "different_types"
 version = "0.0.1"
+edition = "2024.beta"
 
 [dependencies]
 Sui = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/sui-framework", rev = "testnet" }
 
 [addresses]
-suidouble_color =  "0x0"
+different_types =  "0x0"
 sui =  "0000000000000000000000000000000000000000000000000000000000000002"

package/test/test_move_contracts/different_types/sources/different_types.move

@@ -0,0 +1,73 @@
+module different_types::different_types {
+    use std::string::{Self, utf8, String};
+    use std::type_name;
+
+    /// A shared object. `key` ability is required.
+    public struct Store has key {
+        id: UID,
+        numbers: u256,
+        v_bool: bool,
+        v_address: address,
+        v_string: String,
+    }
+
+
+    /// Init function is often ideal place for initializing
+    /// a shared object as it is called only once.
+    /// To share an object `transfer::share_object` is used.
+    fun init(ctx: &mut TxContext) {
+        let id = object::new(ctx);
+        // Share the object to make it accessible to everyone!
+        transfer::share_object(Store {
+            id: id,
+            numbers: 0,
+            v_bool: false,
+            v_address: @0xABBA,
+            v_string: utf8(b""),
+        })
+    }
+
+    public entry fun put_u8(store: &mut Store, value: u8, _ctx: &mut TxContext) {
+        store.numbers = store.numbers + (value as u256);
+    }
+    public entry fun put_u16(store: &mut Store, value: u16, _ctx: &mut TxContext) {
+        store.numbers = store.numbers + (value as u256);
+    }
+    public entry fun put_u32(store: &mut Store, value: u32, _ctx: &mut TxContext) {
+        store.numbers = store.numbers + (value as u256);
+    }
+    public entry fun put_u64(store: &mut Store, value: u64, _ctx: &mut TxContext) {
+        store.numbers = store.numbers + (value as u256);
+    }
+    public entry fun put_u128(store: &mut Store, value: u128, _ctx: &mut TxContext) {
+        store.numbers = store.numbers + (value as u256);
+    }
+    public entry fun put_u256(store: &mut Store, value: u256, _ctx: &mut TxContext) {
+        store.numbers = store.numbers + (value as u256);
+    }
+    public entry fun put_vector_u16(store: &mut Store, value: vector<u16>, _ctx: &mut TxContext) {
+        let vec_length = vector::length(&value);
+        let mut i = 0;
+        while (i < vec_length) {
+            store.numbers = store.numbers + (*vector::borrow(&value, i) as u256);
+
+            i = i + 1;
+        };
+    }
+    public entry fun put_address(store: &mut Store, value: address, _ctx: &mut TxContext) {
+        store.v_address = value;
+    }
+    public entry fun put_bool(store: &mut Store, value: bool, _ctx: &mut TxContext) {
+        store.v_bool = value;
+    }
+    public entry fun put_string(store: &mut Store, value: String, _ctx: &mut TxContext) {
+        store.v_string = value;
+    }
+
+    public entry fun put_type<T>(store: &mut Store, _ctx: &mut TxContext) {
+        let typen = type_name::get<T>();
+        let type_as_string = typen.into_string(); // returns ascii string
+
+        store.v_string = string::from_ascii(type_as_string);
+    }
+}

package/test/test_move_contracts/suidouble_chat/Move.lock

@@ -22,6 +22,6 @@ dependencies = [
 ]
 
 [move.toolchain-version]
-compiler-version = "1.22.0"
+compiler-version = "1.25.1"
 edition = "legacy"
 flavor = "sui"

package/test/test_move_contracts/suidouble_color/sources/suidouble_color.move

@@ -1,150 +0,0 @@
-
-module suidouble_color::suidouble_color {
-    use sui::tx_context::{Self, sender, TxContext};
-    use std::string::{Self, utf8, String};
-    use sui::transfer;
-    use sui::object::{Self, UID, ID};
-    use std::vector::{Self, append, insert};
-
-    use sui::event::emit;
-    
-    // The creator bundle: these two packages often go together.
-    use sui::package;
-    use sui::display;
-
-    /// Text size overflow.
-    const EInvalidColor: u64 = 0;
-
-    // ======== Events =========
-
-    /// Event. When a new color minted
-    struct ColorCreated has copy, drop { id: ID, r: u8, g: u8, b: u8 }
-
-    /// The Hero - an outstanding collection of digital art.
-    struct Color has key, store {
-        id: UID,
-        name: String,
-        r: u8,
-        g: u8,
-        b: u8,
-        img_url: String,
-    }
-
-    /// One-Time-Witness for the module.
-    struct SUIDOUBLE_COLOR has drop {}
-
-    /// In the module initializer we claim the `Publisher` object
-    /// to then create a `Display`. The `Display` is initialized with
-    /// a set of fields (but can be modified later) and published via
-    /// the `update_version` call.
-    ///
-    /// Keys and values are set in the initializer but could also be
-    /// set after publishing if a `Publisher` object was created.
-    fun init(otw: SUIDOUBLE_COLOR, ctx: &mut TxContext) {
-        let keys = vector[
-            utf8(b"name"),
-            utf8(b"link"),
-            utf8(b"image_url"),
-            utf8(b"description"),
-            utf8(b"project_url"),
-            utf8(b"creator"),
-        ];
-
-        let values = vector[
-            utf8(b"{name}"),
-            // For `link` we can build a URL using an `id` property
-            utf8(b"https://suidouble-color.herokuapp.com/color/{id}"),
-            utf8(b"{img_url}"),
-            // Description is static for all `Color` objects.
-            utf8(b"What a nice color. Isn't it?"),
-            // Project URL is usually static
-            utf8(b"https://suidouble-color.herokuapp.com/"),
-            // Creator field can be any
-            utf8(b"Jeka")
-        ];
-
-        // Claim the `Publisher` for the package!
-        let publisher = package::claim(otw, ctx);
-
-        // Get a new `Display` object for the `Color` type.
-        let display = display::new_with_fields<Color>(
-            &publisher, keys, values, ctx
-        );
-
-        // Commit first version of `Display` to apply changes.
-        display::update_version(&mut display);
-
-        transfer::public_transfer(publisher, sender(ctx));
-        transfer::public_transfer(display, sender(ctx));
-    }
-
-    /// Anyone can mint their `Color`!
-    public entry fun mint(name: String, r: u8, g: u8, b: u8, ctx: &mut TxContext) {
-        assert!(r >= 0 && r <= 255, EInvalidColor);
-        assert!(g >= 0 && g <= 255, EInvalidColor);
-        assert!(b >= 0 && b <= 255, EInvalidColor);
-
-        let id = object::new(ctx);
-
-        emit(ColorCreated { id: object::uid_to_inner(&id), r, g, b,  });
-
-        // constructing the smallest (1x1) GIF with the color of RGB
-        let gif_start = vector<u8>[71, 73, 70, 56, 57, 97, 1, 0, 1, 0, 128, 1, 0];
-        let gif_end = vector<u8>[0, 0, 0, 33, 249, 4, 1, 10, 0, 1, 0, 44, 0, 0, 0, 0, 1, 0, 1, 0, 0, 2, 2, 68, 1, 0, 59];
-            
-        insert(&mut gif_start, r, 13);  // appending R
-        insert(&mut gif_start, g, 14);   // appending G
-        insert(&mut gif_start, b, 15); // appending B
-        append(&mut gif_start, gif_end);
-
-        let img_url = encode(&gif_start);
-
-        let base_prefix = b"data:image/gif;base64,";
-        let as_string = utf8(base_prefix);
-        string::append(&mut as_string, utf8(img_url));
-
-        // 
-        let color = Color { id, name, img_url: as_string, r: r, g: g, b: b };
-
-        transfer::transfer(color, tx_context::sender(ctx));
-    }
-
-    // thanks to: https://github.com/movefuns/movefuns/blob/dd1f4443c6bf0bc761b27e28fb6ba00f10636840/stdlib/sources/base64.move#L2
-    const TABLE: vector<u8> = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-
-    public fun encode(str: &vector<u8>): vector<u8> {
-        if (vector::is_empty(str)) {
-            return vector::empty<u8>()
-        };
-        let size = vector::length(str);
-        let eq: u8 = 61;
-        let res = vector::empty<u8>();
-
-        let m = 0 ;
-        while (m < size ) {
-            vector::push_back(&mut res, *vector::borrow(&TABLE, (((*vector::borrow(str, m) & 0xfc) >> 2) as u64)));
-            if ( m + 3 >= size) {
-                if ( size % 3 == 1) {
-                    vector::push_back(&mut res, *vector::borrow(&TABLE, (((*vector::borrow(str, m) & 0x03) << 4) as u64)));
-                    vector::push_back(&mut res, eq);
-                    vector::push_back(&mut res, eq);
-                }else if (size % 3 == 2) {
-                    vector::push_back(&mut res, *vector::borrow(&TABLE, ((((*vector::borrow(str, m) & 0x03) << 4) + ((*vector::borrow(str, m + 1) & 0xf0) >> 4)) as u64)));
-                    vector::push_back(&mut res, *vector::borrow(&TABLE, (((*vector::borrow(str, m + 1) & 0x0f) << 2) as u64)));
-                    vector::push_back(&mut res, eq);
-                }else {
-                    vector::push_back(&mut res, *vector::borrow(&TABLE, ((((*vector::borrow(str, m) & 0x03) << 4) + ((*vector::borrow(str, m + 1) & 0xf0) >> 4)) as u64)));
-                    vector::push_back(&mut res, *vector::borrow(&TABLE, ((((*vector::borrow(str, m + 1) & 0x0f) << 2) + ((*vector::borrow(str, m + 2) & 0xc0) >> 6)) as u64)));
-                    vector::push_back(&mut res, *vector::borrow(&TABLE, ((*vector::borrow(str, m + 2) & 0x3f) as u64)));
-                };
-            }else {
-                vector::push_back(&mut res, *vector::borrow(&TABLE, ((((*vector::borrow(str, m) & 0x03) << 4) + ((*vector::borrow(str, m + 1) & 0xf0) >> 4)) as u64)));
-                vector::push_back(&mut res, *vector::borrow(&TABLE, ((((*vector::borrow(str, m + 1) & 0x0f) << 2) + ((*vector::borrow(str, m + 2) & 0xc0) >> 6)) as u64)));
-                vector::push_back(&mut res, *vector::borrow(&TABLE, ((*vector::borrow(str, m + 2) & 0x3f) as u64)));
-            };
-            m = m + 3;
-        };
-
-        return res
-    }
-}