diff --git a/cypress/e2e/home_page.cy.js b/cypress/e2e/home_page.cy.js
index d6e200ff..401ae0e6 100644
--- a/cypress/e2e/home_page.cy.js
+++ b/cypress/e2e/home_page.cy.js
@@ -70,8 +70,10 @@ describe('The Home Page', () => {
         cy.url().should('include', '/#asset-register')
     });
     it('Navigates to ipfs', () => {
-        cy.get(`.path-ipfs`).click();
-        cy.url().should('include', '/#ipfs')
+        cy.get(`#token-name-Sepolia-test`).click();
+        cy.wait(1000)
+        cy.get(`.path-ipfs-login`).click();
+        cy.url().should('include', '/#ipfs-login')
     });
     it('Navigates to setup', () => {
         cy.get(`.path-setup`).click();
diff --git a/cypress/e2e/members.cy.js b/cypress/e2e/members.cy.js
index c487ff61..2583070e 100644
--- a/cypress/e2e/members.cy.js
+++ b/cypress/e2e/members.cy.js
@@ -30,6 +30,7 @@ describe('Members page', () => {
     it('Should check update tier buttons does not exits if no role', () => {
         cy.get(`.path-list`).click();
         cy.get(`#token-name-New-Project`).click();
+        cy.wait(1000)
         cy.get(`.path-members`).click();
         cy.get(`.update-tier-erc20`).should('not.exist')
         cy.get(`.update-tier-erc1155`).should('not.exist')
diff --git a/public/pkg/.gitignore b/public/pkg/.gitignore
new file mode 100644
index 00000000..e69de29b
diff --git a/public/pkg/encoding_addresses.d.ts b/public/pkg/encoding_addresses.d.ts
new file mode 100644
index 00000000..eeaef0cb
--- /dev/null
+++ b/public/pkg/encoding_addresses.d.ts
@@ -0,0 +1,55 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+* @param {Array<any>} addresses
+* @returns {Uint8Array}
+*/
+export function concat_hex_addresses(addresses: Array<any>): Uint8Array;
+/**
+* @param {string} hex_val
+* @returns {Uint8Array | undefined}
+*/
+export function hex_to_bytes(hex_val: string): Uint8Array | undefined;
+/**
+* @param {Uint8Array} address
+* @returns {Promise<any>}
+*/
+export function cbor_encode_addresses(address: Uint8Array): Promise<any>;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+  readonly memory: WebAssembly.Memory;
+  readonly concat_hex_addresses: (a: number, b: number) => void;
+  readonly hex_to_bytes: (a: number, b: number, c: number) => void;
+  readonly cbor_encode_addresses: (a: number, b: number) => number;
+  readonly __wbindgen_malloc: (a: number, b: number) => number;
+  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+  readonly __wbindgen_export_2: WebAssembly.Table;
+  readonly _dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hcde5a7880f359960: (a: number, b: number, c: number) => void;
+  readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+  readonly __wbindgen_exn_store: (a: number) => void;
+  readonly wasm_bindgen__convert__closures__invoke2_mut__h0ee3583ded983582: (a: number, b: number, c: number, d: number) => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+/**
+* Instantiates the given `module`, which can either be bytes or
+* a precompiled `WebAssembly.Module`.
+*
+* @param {SyncInitInput} module
+*
+* @returns {InitOutput}
+*/
+export function initSync(module: SyncInitInput): InitOutput;
+
+/**
+* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+* for everything else, calls `WebAssembly.instantiate` directly.
+*
+* @param {InitInput | Promise<InitInput>} module_or_path
+*
+* @returns {Promise<InitOutput>}
+*/
+export default function __wbg_init (module_or_path?: InitInput | Promise<InitInput>): Promise<InitOutput>;
diff --git a/public/pkg/encoding_addresses.js b/public/pkg/encoding_addresses.js
new file mode 100644
index 00000000..172b82b6
--- /dev/null
+++ b/public/pkg/encoding_addresses.js
@@ -0,0 +1,437 @@
+let wasm;
+
+const heap = new Array(128).fill(undefined);
+
+heap.push(undefined, null, true, false);
+
+function getObject(idx) { return heap[idx]; }
+
+let heap_next = heap.length;
+
+function dropObject(idx) {
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let cachedUint8Memory0 = null;
+
+function getUint8Memory0() {
+    if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
+        cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8Memory0;
+}
+
+const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
+
+const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
+    ? function (arg, view) {
+    return cachedTextEncoder.encodeInto(arg, view);
+}
+    : function (arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+        read: arg.length,
+        written: buf.length
+    };
+});
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8Memory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+let cachedInt32Memory0 = null;
+
+function getInt32Memory0() {
+    if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
+        cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
+    }
+    return cachedInt32Memory0;
+}
+
+const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
+
+if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+}
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(state => {
+    wasm.__wbindgen_export_2.get(state.dtor)(state.a, state.b)
+});
+
+function makeMutClosure(arg0, arg1, dtor, f) {
+    const state = { a: arg0, b: arg1, cnt: 1, dtor };
+    const real = (...args) => {
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        const a = state.a;
+        state.a = 0;
+        try {
+            return f(a, state.b, ...args);
+        } finally {
+            if (--state.cnt === 0) {
+                wasm.__wbindgen_export_2.get(state.dtor)(a, state.b);
+                CLOSURE_DTORS.unregister(state);
+            } else {
+                state.a = a;
+            }
+        }
+    };
+    real.original = state;
+    CLOSURE_DTORS.register(real, state, state);
+    return real;
+}
+function __wbg_adapter_20(arg0, arg1, arg2) {
+    wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hcde5a7880f359960(arg0, arg1, addHeapObject(arg2));
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
+}
+/**
+* @param {Array<any>} addresses
+* @returns {Uint8Array}
+*/
+export function concat_hex_addresses(addresses) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.concat_hex_addresses(retptr, addHeapObject(addresses));
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        var v1 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_free(r0, r1 * 1, 1);
+        return v1;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+* @param {string} hex_val
+* @returns {Uint8Array | undefined}
+*/
+export function hex_to_bytes(hex_val) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(hex_val, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.hex_to_bytes(retptr, ptr0, len0);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        let v2;
+        if (r0 !== 0) {
+            v2 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_free(r0, r1 * 1, 1);
+        }
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8Memory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+/**
+* @param {Uint8Array} address
+* @returns {Promise<any>}
+*/
+export function cbor_encode_addresses(address) {
+    const ptr0 = passArray8ToWasm0(address, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.cbor_encode_addresses(ptr0, len0);
+    return takeObject(ret);
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        wasm.__wbindgen_exn_store(addHeapObject(e));
+    }
+}
+function __wbg_adapter_42(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures__invoke2_mut__h0ee3583ded983582(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+
+            } catch (e) {
+                if (module.headers.get('Content-Type') != 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else {
+                    throw e;
+                }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+
+        } else {
+            return instance;
+        }
+    }
+}
+
+function __wbg_get_imports() {
+    const imports = {};
+    imports.wbg = {};
+    imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
+        takeObject(arg0);
+    };
+    imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
+        const obj = getObject(arg1);
+        const ret = typeof(obj) === 'string' ? obj : undefined;
+        var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len1;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr1;
+    };
+    imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
+        const ret = getStringFromWasm0(arg0, arg1);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_number_new = function(arg0) {
+        const ret = arg0;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
+        const ret = getObject(arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_cb_drop = function(arg0) {
+        const obj = takeObject(arg0).original;
+        if (obj.cnt-- == 1) {
+            obj.a = 0;
+            return true;
+        }
+        const ret = false;
+        return ret;
+    };
+    imports.wbg.__wbg_queueMicrotask_481971b0d87f3dd4 = function(arg0) {
+        queueMicrotask(getObject(arg0));
+    };
+    imports.wbg.__wbg_queueMicrotask_3cbae2ec6b6cd3d6 = function(arg0) {
+        const ret = getObject(arg0).queueMicrotask;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_is_function = function(arg0) {
+        const ret = typeof(getObject(arg0)) === 'function';
+        return ret;
+    };
+    imports.wbg.__wbg_get_bd8e338fbd5f5cc8 = function(arg0, arg1) {
+        const ret = getObject(arg0)[arg1 >>> 0];
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_length_cd7af8117672b8b8 = function(arg0) {
+        const ret = getObject(arg0).length;
+        return ret;
+    };
+    imports.wbg.__wbg_new_16b304a2cfa7ff4a = function() {
+        const ret = new Array();
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_newnoargs_e258087cd0daa0ea = function(arg0, arg1) {
+        const ret = new Function(getStringFromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_call_27c0f87801dedf93 = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).call(getObject(arg1));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_self_ce0dbfc45cf2f5be = function() { return handleError(function () {
+        const ret = self.self;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_window_c6fb939a7f436783 = function() { return handleError(function () {
+        const ret = window.window;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_globalThis_d1e6af4856ba331b = function() { return handleError(function () {
+        const ret = globalThis.globalThis;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_global_207b558942527489 = function() { return handleError(function () {
+        const ret = global.global;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbindgen_is_undefined = function(arg0) {
+        const ret = getObject(arg0) === undefined;
+        return ret;
+    };
+    imports.wbg.__wbg_set_d4638f722068f043 = function(arg0, arg1, arg2) {
+        getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
+    };
+    imports.wbg.__wbg_call_b3ca7c6051f9bec1 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_new_81740750da40724f = function(arg0, arg1) {
+        try {
+            var state0 = {a: arg0, b: arg1};
+            var cb0 = (arg0, arg1) => {
+                const a = state0.a;
+                state0.a = 0;
+                try {
+                    return __wbg_adapter_42(a, state0.b, arg0, arg1);
+                } finally {
+                    state0.a = a;
+                }
+            };
+            const ret = new Promise(cb0);
+            return addHeapObject(ret);
+        } finally {
+            state0.a = state0.b = 0;
+        }
+    };
+    imports.wbg.__wbg_resolve_b0083a7967828ec8 = function(arg0) {
+        const ret = Promise.resolve(getObject(arg0));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_then_0c86a60e8fcfe9f6 = function(arg0, arg1) {
+        const ret = getObject(arg0).then(getObject(arg1));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_throw = function(arg0, arg1) {
+        throw new Error(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbindgen_closure_wrapper146 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 77, __wbg_adapter_20);
+        return addHeapObject(ret);
+    };
+
+    return imports;
+}
+
+function __wbg_init_memory(imports, maybe_memory) {
+
+}
+
+function __wbg_finalize_init(instance, module) {
+    wasm = instance.exports;
+    __wbg_init.__wbindgen_wasm_module = module;
+    cachedInt32Memory0 = null;
+    cachedUint8Memory0 = null;
+
+
+    return wasm;
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+    const imports = __wbg_get_imports();
+
+    __wbg_init_memory(imports);
+
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+
+    const instance = new WebAssembly.Instance(module, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(input) {
+    if (wasm !== undefined) return wasm;
+
+    if (typeof input === 'undefined') {
+        input = new URL('encoding_addresses_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) {
+        input = fetch(input);
+    }
+
+    __wbg_init_memory(imports);
+
+    const { instance, module } = await __wbg_load(await input, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync }
+export default __wbg_init;
diff --git a/public/pkg/encoding_addresses_bg.wasm b/public/pkg/encoding_addresses_bg.wasm
new file mode 100644
index 00000000..0af62908
Binary files /dev/null and b/public/pkg/encoding_addresses_bg.wasm differ
diff --git a/public/pkg/encoding_addresses_bg.wasm.d.ts b/public/pkg/encoding_addresses_bg.wasm.d.ts
new file mode 100644
index 00000000..eea2801d
--- /dev/null
+++ b/public/pkg/encoding_addresses_bg.wasm.d.ts
@@ -0,0 +1,14 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export function concat_hex_addresses(a: number, b: number): void;
+export function hex_to_bytes(a: number, b: number, c: number): void;
+export function cbor_encode_addresses(a: number, b: number): number;
+export function __wbindgen_malloc(a: number, b: number): number;
+export function __wbindgen_realloc(a: number, b: number, c: number, d: number): number;
+export const __wbindgen_export_2: WebAssembly.Table;
+export function _dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hcde5a7880f359960(a: number, b: number, c: number): void;
+export function __wbindgen_add_to_stack_pointer(a: number): number;
+export function __wbindgen_free(a: number, b: number, c: number): void;
+export function __wbindgen_exn_store(a: number): void;
+export function wasm_bindgen__convert__closures__invoke2_mut__h0ee3583ded983582(a: number, b: number, c: number, d: number): void;
diff --git a/public/pkg/package.json b/public/pkg/package.json
new file mode 100644
index 00000000..48c143ee
--- /dev/null
+++ b/public/pkg/package.json
@@ -0,0 +1,14 @@
+{
+  "name": "encoding-addresses",
+  "version": "0.1.0",
+  "files": [
+    "encoding_addresses_bg.wasm",
+    "encoding_addresses.js",
+    "encoding_addresses.d.ts"
+  ],
+  "module": "encoding_addresses.js",
+  "types": "encoding_addresses.d.ts",
+  "sideEffects": [
+    "./snippets/*"
+  ]
+}
\ No newline at end of file
diff --git a/src/assets/icons/bin.svg b/src/assets/icons/bin.svg
new file mode 100644
index 00000000..a41c2d7b
--- /dev/null
+++ b/src/assets/icons/bin.svg
@@ -0,0 +1,5 @@
+<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M19 6H5" stroke="#DD1212" stroke-linecap="round"/>
+<path d="M14 5H10" stroke="#DD1212" stroke-linecap="round"/>
+<path d="M6 10V21H18C18 20 18 10 18 10" stroke="#DD1212" stroke-linecap="round"/>
+</svg>
diff --git a/src/assets/icons/copy_brown.svg b/src/assets/icons/copy_brown.svg
new file mode 100644
index 00000000..ff1414b8
--- /dev/null
+++ b/src/assets/icons/copy_brown.svg
@@ -0,0 +1,4 @@
+<svg width="17" height="17" viewBox="0 0 17 17" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M11.3337 9.1388V12.1138C11.3337 14.593 10.342 15.5846 7.86283 15.5846H4.88783C2.40866 15.5846 1.41699 14.593 1.41699 12.1138V9.1388C1.41699 6.65964 2.40866 5.66797 4.88783 5.66797H7.86283C10.342 5.66797 11.3337 6.65964 11.3337 9.1388Z" stroke="#9D7334" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M15.5837 4.8888V7.8638C15.5837 10.343 14.592 11.3346 12.1128 11.3346H11.3337V9.1388C11.3337 6.65963 10.342 5.66797 7.86283 5.66797H5.66699V4.8888C5.66699 2.40964 6.65866 1.41797 9.13783 1.41797H12.1128C14.592 1.41797 15.5837 2.40964 15.5837 4.8888Z" stroke="#9D7334" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>
diff --git a/src/components/Navigation.svelte b/src/components/Navigation.svelte
index 500292eb..f065651f 100644
--- a/src/components/Navigation.svelte
+++ b/src/components/Navigation.svelte
@@ -1,5 +1,5 @@
 <script>
-    import {sftInfo, tokenName, vault} from "../scripts/store.js";
+    import {sftInfo, tokenName, vault, account} from "../scripts/store.js";
     import NavigationButton from './NavigationButton.svelte';
     import TokenOverviewTable from './TokenOverviewTable.svelte';
     import {navigate} from '../scripts/helpers.js';
@@ -91,7 +91,8 @@
          class="flex jusitfy-start items-center space-x-6 w-full  focus:outline-none  focus:text-indigo-400 rounded py-2 text-nav font-semibold pl-5">
         <span class="leading-5 menu-header">Web 3</span>
       </a>
-      <NavigationButton targetPath="#ipfs" {path} on:navClick={handleClick}>
+
+      <NavigationButton label="IPFS" {path}>
         <div slot="icon">
           <svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
             <path
@@ -102,6 +103,8 @@
           </svg>
         </div>
       </NavigationButton>
+      <NavigationButton targetPath="#ipfs-login" {path} on:navClick={handleClick} child={true}/>
+      <NavigationButton targetPath="#track-addresses" {path} on:navClick={handleClick} child={true}/>
       <NavigationButton targetPath="#setup" {path} on:navClick={handleClick}>
         <div slot="icon">
           <svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
diff --git a/src/contract/rainMetadata/rainMetadataAbi.json b/src/contract/rainMetadata/rainMetadataAbi.json
new file mode 100644
index 00000000..8182dd81
--- /dev/null
+++ b/src/contract/rainMetadata/rainMetadataAbi.json
@@ -0,0 +1,75 @@
+[
+  {
+    "type": "function",
+    "name": "emitMeta",
+    "inputs": [
+      {
+        "name": "subject",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "meta",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "hash",
+    "inputs": [
+      {
+        "name": "data",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "event",
+    "name": "MetaV1_2",
+    "inputs": [
+      {
+        "name": "sender",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "subject",
+        "type": "bytes32",
+        "indexed": false,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "meta",
+        "type": "bytes",
+        "indexed": false,
+        "internalType": "bytes"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "error",
+    "name": "NotRainMetaV1",
+    "inputs": [
+      {
+        "name": "unmeta",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ]
+  }
+]
\ No newline at end of file
diff --git a/src/lib/Default.svelte b/src/lib/Default.svelte
index 655b7cd6..ab0e2457 100644
--- a/src/lib/Default.svelte
+++ b/src/lib/Default.svelte
@@ -78,6 +78,7 @@
     import Issuers from '../routes/Issuers.svelte';
     import Curators from '../routes/Curators.svelte';
     import Auditors from '../routes/Auditors.svelte';
+    import TrackAddresses from '../routes/TrackAddresses.svelte';
 
     let connectedAccount;
     export let url = "";
@@ -126,6 +127,8 @@
                     navigateTo("#list", {replace: false})
                 } else if (location === "#setup") {
                     navigateTo("#setup", {replace: false})
+                } else if (location === "#track-addresses") {
+                    navigateTo("#track-addresses", {replace: false})
                 } else if (location === "#ipfs") {
                     navigateTo("#ipfs", {replace: false})
                 } else if (location === "#manual") {
@@ -163,19 +166,7 @@
         await getEthersData();
         if ($isCypress) {
             account.set('0xc0d477556c25c9d67e1f57245c7453da776b51cf')
-            activeNetwork.set({
-                "id": 80001,
-                "chainId": 80001,
-                "name": "mumbai",
-                "displayName": "Mumbai testnet",
-                "currencySymbol": "MATIC",
-                "blockExplorer": "https://mumbai.polygonscan.com",
-                "blockExplorerIcon": "polygonscan",
-                "rpcUrl": "https://rpc-mumbai.maticvigil.com/",
-                "icon": "polygon",
-                "factory_address": "0x94927792b88D518f9a429572dD3D40400b8BE906",
-                "subgraph_url": "https://api.thegraph.com/subgraphs/name/gildlab/offchainassetvault-mumbai"
-            })
+            activeNetwork.set(networks.find(n => n.id === 11155111))
         }
         if ($isMetamaskInstalled) {
             if ((location === "/" || location === "") && !$landing) {
@@ -245,7 +236,6 @@
         vault.set({});
         await setNetwork();
         await getTokens();
-        navigateTo("#list");
     }
 
     async function getEthersData() {
@@ -473,6 +463,7 @@
             <Route path="#token-overview/:address" component={TokenOverview}/>
             <Route path="#change-comparison" component={ChangeComparison}/>
             <Route path="#address-overview/:address" component={AddressOverview}/>
+            <Route path="#track-addresses" component={TrackAddresses}/>
           </div>
         </div>
         <div class={$sftInfo ? "main-card sft-info-opened" : "main-card" }>
@@ -487,7 +478,7 @@
             <Route path="#new-asset-class" component={NewSchema}/>
             <Route path="#asset-information/:id/:id" component={AssetInformation}/>
             <Route path="#sft-create-success" component={SftCreateSuccess}/>
-            <Route path="#ipfs" component={Ipfs}/>
+            <Route path="#ipfs-login" component={Ipfs}/>
             <Route path="#manual" component={Manual}/>
             <Route path="#new-revision/:id" component={NewRevision}/>
             <div class={location === '#mint' || location === "#redeem" ? 'tabs show' : 'tabs hide'}>
diff --git a/src/routes/Home.svelte b/src/routes/Home.svelte
index 7f227de6..bb60d242 100644
--- a/src/routes/Home.svelte
+++ b/src/routes/Home.svelte
@@ -4,8 +4,8 @@
     import {
         account,
         accountRoles,
-        activeNetwork, auditHistory, deposits,
-        ethersData, isCypress, roles, schemas,
+        activeNetwork, auditHistory,
+        ethersData, roles, schemas,
         sftInfo,
         tokens, tokensLoading, transactionError, transactionInProgress, transactionInProgressShow, transactionSuccess,
         vault
diff --git a/src/routes/Mint.svelte b/src/routes/Mint.svelte
index 6abe85e6..0173943c 100644
--- a/src/routes/Mint.svelte
+++ b/src/routes/Mint.svelte
@@ -11,13 +11,11 @@
         transactionSuccess,
         transactionInProgress,
         auditHistory,
-        accountRoles,
         tokenName,
         pageTitle,
         isCypress
     } from "../scripts/store.js";
     import {account} from "../scripts/store.js";
-    import {navigateTo} from "yrv";
     import axios from "axios";
     import Select from "../components/Select.svelte";
     import {icons} from "../scripts/assets.js";
diff --git a/src/routes/Roles.svelte b/src/routes/Roles.svelte
index 0562272b..09b67b9e 100644
--- a/src/routes/Roles.svelte
+++ b/src/routes/Roles.svelte
@@ -95,7 +95,6 @@
 
         pageTitle.set("SFT roles")
         titleIcon.set(`${icons.roles_icon}`)
-
     })
 
 </script>
diff --git a/src/routes/TokenOverview.svelte b/src/routes/TokenOverview.svelte
index 07defc73..337796fc 100644
--- a/src/routes/TokenOverview.svelte
+++ b/src/routes/TokenOverview.svelte
@@ -242,7 +242,7 @@
 
 </script>
 {#if !isEditorOpen}
-  <div class="{$sftInfo ? '' : 'left-margin'} w-full token-overview-container">
+  <div class="{$sftInfo ? '' : 'left-margin'} token-overview-container">
     <div class="flex justify-between mb-2">
       <div class="links">
         <SftCredentialLinks sft={token} on:editClick={handleEditClick}></SftCredentialLinks>
diff --git a/src/routes/TrackAddresses.svelte b/src/routes/TrackAddresses.svelte
new file mode 100644
index 00000000..1e28503e
--- /dev/null
+++ b/src/routes/TrackAddresses.svelte
@@ -0,0 +1,311 @@
+<script>
+    import {
+        account,
+        ethersData,
+        sftInfo, transactionError,
+        transactionInProgress,
+        transactionSuccess,
+        activeNetwork
+    } from "../scripts/store";
+    import {
+        cborDecode,
+        getContract, showPrompt,
+    } from "../scripts/helpers.js";
+    import SftLoader from '../components/SftLoader.svelte';
+    import {icons} from '../scripts/assets.js';
+    import {encodeAddresses, hexToBytes, initWasm} from "../wasm_utils.js";
+    import {
+        MAGIC_NUMBERS, RAIN_METADATA_CONTRACT_ADDRESS_ARBITRUM_ONE
+    } from '../scripts/consts.js';
+    import {arrayify} from 'ethers/lib/utils.js';
+    import metadataContractAbi from "../contract/rainMetadata/rainMetadataAbi.json"
+    import {onMount} from 'svelte';
+    import networks from '../scripts/networksConfig.js';
+    import {ethers} from 'ethers';
+
+    let {signer} = $ethersData;
+    let arbitrumNet = networks.find(n => n.id === 42161)
+
+    let metadataContract = "";
+    let addresses = [];
+
+    onMount(async () => {
+        metadataContract = await getContract(arbitrumNet, RAIN_METADATA_CONTRACT_ADDRESS_ARBITRUM_ONE.trim(), metadataContractAbi, $ethersData.signerOrProvider)
+        await getAddresses();
+    })
+
+    function processAddresses(metaData) {
+        const addressActions = {};
+        // Traverse the meta data to process each add/remove action
+        metaData.forEach(item => {
+            const decoded = cborDecode(item.meta.slice(18)); // Decode the meta data
+            const myArray = decoded[0].get(0);
+            const magicNumber = decoded[0].get(1);
+            if (magicNumber && magicNumber === MAGIC_NUMBERS.AUTHORS_LIST) {
+                const actionPrefix = myArray[0];
+                if (myArray instanceof Uint8Array) {
+                    const addressHex = arrayToHex(myArray.subarray(1)); // Extract the address
+
+                    // Track the last action for each address (1 for add, 0 for remove) along with the sender
+                    addressActions[addressHex] = {action: actionPrefix, sender: item.sender};
+                }
+            }
+        });
+
+        // Collect addresses that were added (1) and not subsequently removed (0)
+        return Object.keys(addressActions)
+            .filter(address => addressActions[address].action === 1)
+            .map(address => ({
+                address: address,
+                sender: addressActions[address].sender
+            }));
+    }
+
+
+    // Helper function to convert Uint8Array to a hex string
+    function arrayToHex(uint8Array) {
+        return '0x' + Array.from(uint8Array)
+            .map(byte => byte.toString(16).padStart(2, '0'))
+            .join('');
+    }
+
+    async function cborEncodeAddress(addresses) {
+        await initWasm();
+        return await encodeAddresses(addresses);
+    }
+
+    async function getAddresses() {
+        const managerAddress = import.meta.env.VITE_MANAGER_ADDRESS;
+        const addresses_subgraph_url = import.meta.env.VITE_ADDRESSES_SUBGRAPH_URL;
+
+        let query = `
+          query($sender: String!) {
+            metaV1S(where: { sender: $sender }) {
+              meta
+              sender
+            }
+          }
+         `;
+
+        let data = {};
+        let variables = {sender: managerAddress.toLowerCase()}
+        try {
+            let req = await fetch(addresses_subgraph_url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    query,
+                    variables
+                })
+            })
+
+            data = await req.json()
+
+            if (data) {
+                let tempData = data.data;
+
+                if (tempData.metaV1S?.length > 0) {
+                    addresses = processAddresses(tempData.metaV1S);
+                }
+            }
+        } catch (e) {
+            console.log(e.message)
+        }
+    }
+
+    let error = ''
+    let addressFound = false;
+    let loading = false;
+    let address = '';
+    $: address && checkAddress();
+
+    function checkAddress() {
+        if (address) {
+            addressFound = !!addresses.find(a => a.address === address)
+        }
+    }
+
+    async function switchToArbitrum() {
+        let arbNetChainId = ethers.utils.hexValue(arbitrumNet.chainId)
+
+        try {
+            await window.ethereum.request({
+                method: "wallet_switchEthereumChain",
+                params: [{chainId: arbNetChainId}]
+            });
+        } catch (switchError) {
+            // This error code indicates that the chain has not been added to MetaMask.
+            if (switchError.code === 4902) {
+                try {
+                    await window.ethereum.request({
+                        method: "wallet_addEthereumChain",
+                        params: [
+                            {
+                                chainId: arbNetChainId,
+                                chainName: arbitrumNet.displayName,
+                                rpcUrls: [arbitrumNet.rpcUrl],
+                                blockExplorerUrls: [arbitrumNet.blockExplorer],
+                                nativeCurrency: {
+                                    name: arbitrumNet.currencySymbol,
+                                    symbol: arbitrumNet.currencySymbol,
+                                    decimals: 18
+                                }
+                            }
+                        ]
+                    });
+                } catch (addError) {
+                    console.log(addError)
+                }
+            }
+        }
+    }
+
+    async function addAddress() {
+
+        if (addressFound) {
+            return;
+        }
+        let byteAddress = await hexToBytes(address)
+
+        // Create a new Uint8Array with a length of 21 bytes
+        let newArray = new Uint8Array(21);
+
+        // Set the first byte of the new array to 1
+        newArray[0] = 1;
+
+        // Copy the contents of the original array to the new array starting from index 1
+        newArray.set(byteAddress, 1);
+
+        //Cbor Encode the address
+        let cborEncoded = await cborEncodeAddress(newArray)
+
+        let rainMagic = arrayify(MAGIC_NUMBERS.RAIN_META_DOCUMENT_HEX_STRING)
+
+        let constructedMeta = new Uint8Array(rainMagic.length + cborEncoded.length);
+
+        constructedMeta.set(rainMagic, 0);
+        constructedMeta.set(cborEncoded, rainMagic.length);
+        let subject = "0x0000000000000000000000000000000000000000000000000000000000000001"
+        let tx = await metadataContract.connect(signer)["emitMeta(bytes32,bytes)"](subject, constructedMeta);
+        await showPrompt(tx)
+
+        let wait = await tx.wait()
+        if (wait.status === 1) {
+            addresses = [...addresses, {address: address, sender: $account}];
+            transactionSuccess.set(true)
+            transactionInProgress.set(false)
+        } else {
+            transactionError.set(true)
+        }
+
+    }
+
+    function copyAddress(address) {
+        if (navigator && navigator.clipboard && navigator.clipboard.writeText) {
+            return navigator.clipboard.writeText(address.toLowerCase());
+        }
+        return Promise.reject("The Clipboard API is not available.");
+    }
+
+    async function removeAddress(address) {
+        let byteAddress = await hexToBytes(address)
+        // Create a new Uint8Array with a length of 21 bytes
+        let newArray = new Uint8Array(21);
+
+        // Set the first byte of the new array to 0
+        newArray[0] = 0;
+
+        // Copy the contents of the original array to the new array starting from index 1
+        newArray.set(byteAddress, 1);
+
+        //Cbor Encode the address
+        let cborEncoded = await cborEncodeAddress(newArray)
+
+        let rainMagic = arrayify(MAGIC_NUMBERS.RAIN_META_DOCUMENT_HEX_STRING)
+
+        let constructedMeta = new Uint8Array(rainMagic.length + cborEncoded.length);
+
+        constructedMeta.set(rainMagic, 0);
+        constructedMeta.set(cborEncoded, rainMagic.length);
+
+        let subject = "0x0000000000000000000000000000000000000000000000000000000000000001"
+        let tx = await metadataContract.connect(signer)["emitMeta(bytes32,bytes)"](subject, constructedMeta);
+        await showPrompt(tx)
+
+        let wait = await tx.wait()
+        if (wait.status === 1) {
+            addresses = addresses.filter(a => a.address !== address);
+            transactionSuccess.set(true)
+            transactionInProgress.set(false)
+        } else {
+            transactionError.set(true)
+        }
+    }
+</script>
+
+<div class="{$sftInfo ? 'w-full' : 'left-margin'} mr-5">
+  {#if loading}
+    <SftLoader/>
+  {/if}
+  {#if !loading }
+    <div class="bg-white rounded-xl gap-4 flex flex-col p-8">
+      <div class="flex flex-col items-start gap-2 w-full font-normal">
+        <span>Add an address to track IPFS pins from</span>
+        <div class="flex gap-5 w-full">
+          <input class="default-input w-1/2" bind:value={address}/>
+          {#if $activeNetwork.chainId === arbitrumNet.chainId}
+            <button class="default-btn" on:click={()=>{addAddress()}} disabled={addressFound}> Add address</button>
+          {/if}
+          {#if $activeNetwork.chainId !== arbitrumNet.chainId}
+            <button class="default-btn" on:click={()=>{switchToArbitrum()}}> Change network</button>
+          {/if}
+          {#if addressFound}
+            <div class="error">Address already added</div>
+          {/if}
+        </div>
+      </div>
+      <span class="self-start">Current Addresses to track IPFS pins from</span>
+      <table class="sft-table shadow-none">
+        <thead>
+        <tr>
+          <th></th>
+          <th>Current addresses</th>
+          <th class="rounded-tr-[10px]">Sender</th>
+          <th class="!bg-white"></th>
+        </tr>
+        </thead>
+        <tbody>
+        {#if addresses.length}
+
+          {#each addresses as ad}
+            <tr class="tb-row">
+              <td class="cursor-pointer hover:opacity-50" on:click={()=>{copyAddress(ad.address)}}>
+                <img class="ml-5" src="{icons.copy_brown}" alt="copy">
+              </td>
+              <td class="address flex">{ad?.address?.toLowerCase()}</td>
+              <td>{ad?.sender?.toLowerCase()}</td>
+              <td class="bg-white border-0" on:click={()=>{removeAddress(ad.address)}}>
+                <img class="ml-2 cursor-pointer hover:opacity-50" src="{icons.bin}" alt="copy">
+              </td>
+            </tr>
+          {/each}
+        {/if}
+        </tbody>
+      </table>
+    </div>
+  {/if}
+</div>
+
+<style>
+    .left-margin {
+        margin-left: 223px;
+    }
+
+    .address {
+        color: #9D7334;
+    }
+
+
+</style>
\ No newline at end of file
diff --git a/src/scripts/assets.js b/src/scripts/assets.js
index e2c03ed9..695f6906 100644
--- a/src/scripts/assets.js
+++ b/src/scripts/assets.js
@@ -15,6 +15,7 @@ import gild_lab from '../assets/icons/gild_lab.svg'
 import rain from '../assets/icons/rain.svg'
 import camera from '../assets/icons/camera.svg'
 import copy from '../assets/icons/copy.svg'
+import copy_brown from '../assets/icons/copy_brown.svg'
 import discord from '../assets/icons/discord.svg'
 import etherscan from '../assets/icons/etherscan.svg'
 import polygonscan from '../assets/icons/polygonscan.svg'
@@ -50,6 +51,7 @@ import auditors_hero from '../assets/icons/auditors_hero.webp';
 import wave_resp from '../assets/icons/wave_resp.svg';
 import investor_hero_tile from '../assets/icons/investor_hero_tile.webp';
 import arbitrum from '../assets/icons/arbitrum.svg';
+import bin from '../assets/icons/bin.svg';
 
 export const icons = {
     ethereum,
@@ -103,5 +105,7 @@ export const icons = {
     auditors_hero,
     wave_resp,
     investor_hero_tile,
-    arbitrum
+    arbitrum,
+    copy_brown,
+    bin
 }
diff --git a/src/scripts/consts.js b/src/scripts/consts.js
index 3d67a70e..4e3b8d7b 100644
--- a/src/scripts/consts.js
+++ b/src/scripts/consts.js
@@ -33,6 +33,8 @@ export const MAGIC_NUMBERS = {
      * Prefixes every rain meta document
      */
     RAIN_META_DOCUMENT: BigInt(0xff0a89c674ee7874n),
+
+    RAIN_META_DOCUMENT_HEX_STRING: "0xff0a89c674ee7874",
     /**S
      * OA Schema
      */
@@ -56,7 +58,7 @@ export const MAGIC_NUMBERS = {
     /**
      * OA Token authors
      */
-    AUTHORS_LIST: BigInt(0xffb2637608c09e38)
+    AUTHORS_LIST: BigInt(0xffb2637608c09e38n)
 };
 
 export const TRANSACTION_IN_PROGRESS_TEXT = "Transaction taking place, please wait."
@@ -82,7 +84,13 @@ export const ROUTE_LABEL_MAP = new Map([
     ["#asset-history", "Asset history"],
     ["#change-comparison", "Change comparison"],
     ["#address-overview", "Address overview"],
-    ["#knowledgebase", "Knowledgebase"]
+    ["#knowledgebase", "Knowledgebase"],
+    ["#ipfs-login", "IPFS login"],
+    ["#track-addresses", "Track addresses"]
 ]);
 
-export const landingPages = ['', '/', '#', '#transparency', '#investors', '#issuers', '#curators','#auditors']
\ No newline at end of file
+export const landingPages = ['', '/', '#', '#transparency', '#investors', '#issuers', '#curators', '#auditors']
+
+export const RAIN_METADATA_CONTRACT_ADDRESS = "0x441f7AF49387295638Eec40577dB67dc5776c683"
+export const RAIN_METADATA_CONTRACT_ADDRESS_SEPOLIA = "0xb1d6D10561D4e1792A7c6B336b0529e4bFb5Ea8F"
+export const RAIN_METADATA_CONTRACT_ADDRESS_ARBITRUM_ONE = "0x017F5651eB8fa4048BBc17433149c6c035d391A6"
\ No newline at end of file
diff --git a/src/scripts/networksConfig.js b/src/scripts/networksConfig.js
index 6112c032..2abd2745 100644
--- a/src/scripts/networksConfig.js
+++ b/src/scripts/networksConfig.js
@@ -62,7 +62,7 @@ const networks = [
         rpcUrl: "https://sepolia-rollup.arbitrum.io/rpc",
         icon: 'arbitrum',
         factory_address: '0xf1A14e96977E8dE295Ba9612691D127B157d1371',
-        subgraph_url: "https://api.goldsky.com/api/public/project_clv14x04y9kzi01saerx7bxpg/subgraphs/sft-offchainassetvault-arbitrum-sepolia/1.0.0/gn"
+        subgraph_url: "https://api.goldsky.com/api/public/project_clv14x04y9kzi01saerx7bxpg/subgraphs/sft-offchainassetvault-arbitrum-sepolia/1.0.0/gn",
     }
 ];
 
diff --git a/src/wasm_utils.js b/src/wasm_utils.js
new file mode 100644
index 00000000..80a0e121
--- /dev/null
+++ b/src/wasm_utils.js
@@ -0,0 +1,25 @@
+// src/wasmModule.js
+
+import init, { concat_hex_addresses, cbor_encode_addresses, hex_to_bytes} from "../public/pkg/encoding_addresses.js";
+
+let wasm;
+
+async function initWasm() {
+    wasm = await init();
+}
+
+export async function convertAddress(hexAddress) {
+    if (!wasm) await initWasm();
+    return concat_hex_addresses(hexAddress);
+}
+export async function encodeAddresses(hexAddress) {
+    if (!wasm) await initWasm();
+    return cbor_encode_addresses(hexAddress);
+}
+
+export async function hexToBytes(hexStr) {
+    if (!wasm) await initWasm();
+    return hex_to_bytes(hexStr);
+}
+
+export { initWasm };