dequanto 0.0.1 → 0.0.7

package/dist/src/solidity/SlotsStorage.js

@@ -0,0 +1,158 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlotsStorage = void 0;
+const alot_1 = __importDefault(require("alot"));
+const _require_1 = require("@dequanto/utils/$require");
+const SlotValueHandler_1 = require("./storage/handlers/SlotValueHandler");
+const SlotFixedArrayHandler_1 = require("./storage/handlers/SlotFixedArrayHandler");
+const SlotDynamicArrayHandler_1 = require("./storage/handlers/SlotDynamicArrayHandler");
+const SlotsStorageTransport_1 = require("./storage/SlotsStorageTransport");
+const atma_utils_1 = require("atma-utils");
+const SlotMappingHandler_1 = require("./storage/handlers/SlotMappingHandler");
+const SlotStringHandler_1 = require("./storage/handlers/SlotStringHandler");
+const Accessor_1 = require("./storage/Accessor");
+const SlotStructHandler_1 = require("./storage/handlers/SlotStructHandler");
+class SlotsStorage {
+    constructor(transport, slots) {
+        this.transport = transport;
+        this.slots = slots;
+    }
+    static createWithClient(client, address, slots, params) {
+        let reader = new SlotsStorageTransport_1.SlotsStorageTransport(client, address, params);
+        return new SlotsStorage(reader, slots);
+    }
+    async get(path) {
+        let keys = this.getKeys(path);
+        if (keys.length === 0 && this.slots.length > 0) {
+            return this.fetchAll();
+        }
+        let { handler } = await this.getStorageFor(keys);
+        return handler.get(keys);
+    }
+    async set(path, value) {
+        let keys = this.getKeys(path);
+        if (keys.length === 0 && this.slots.length > 0) {
+            await this.saveAll(value);
+            return;
+        }
+        let { handler } = await this.getStorageFor(keys);
+        await handler.set(keys, value);
+    }
+    // for(property: string) {
+    //     let slot = this.slots.find(x => x.name === property);
+    //     $require.notNull(slot, `StateVariable ${property} not found. Available: ${this.slots.map(x => x.name).join(', ')}`);
+    //     const Ctor = this.getSlotStorage(slot);
+    //     return new Ctor(this.transport, slot);
+    // }
+    async fetchAll() {
+        let arr = await (0, alot_1.default)(this.slots)
+            .mapAsync(async (slot, i) => {
+            const Ctor = this.getSlotStorage(slot);
+            const slotReader = new Ctor(this.transport, slot);
+            const value = await slotReader.fetchAll();
+            return {
+                key: slot.name || null,
+                value
+            };
+        })
+            .toArrayAsync();
+        if (arr.length === 0) {
+            return null;
+        }
+        if (arr.length === 1 && arr[0].key == null) {
+            return arr[0].value;
+        }
+        if (arr[0].key == null) {
+            return arr.map(x => x.value);
+        }
+        let dict = (0, alot_1.default)(arr).toDictionary(x => x.key, x => x.value);
+        return dict;
+    }
+    async saveAll(value) {
+        if (value == null) {
+            throw new Error(`Can't save the undefined value`);
+        }
+        if (this.slots.length === 0) {
+            throw new Error(`Slots are empty to save ${value}`);
+        }
+        if ((0, atma_utils_1.is_Object)(value)) {
+            // object
+            await alot_1.default
+                .fromObject(value)
+                .mapAsync(async (entry) => {
+                await this.set([{ key: entry.key, type: 'key' }], entry.value);
+            })
+                .toArrayAsync();
+            return;
+        }
+        if (this.slots.length > 1) {
+            throw new Error(`Value type (${value}) not possible to save to multiple slots: ${this.slots.map(x => x.name)}`);
+        }
+        const slot = this.slots[0];
+        const Ctor = this.getSlotStorage(slot);
+        const handler = new Ctor(this.transport, slot);
+        await handler.set([], value);
+    }
+    getStorageFor(path) {
+        let keys = this.getKeys(path);
+        let slot;
+        if (keys.length > 0) {
+            let key = keys.shift();
+            slot = this.slots.find(x => x.name === key.key);
+            _require_1.$require.notNull(slot, `StateVariable ${key.key} not found. Available: ${this.slots.map(x => x.name).join(', ')}`);
+        }
+        else {
+            if (this.slots.length !== 1) {
+                throw new Error(`Key ${JSON.stringify(keys)} not specified for multiple slots: ${this.slots.map(x => x.name)}`);
+            }
+            slot = this.slots[0];
+        }
+        const Ctor = this.getSlotStorage(slot);
+        const handler = new Ctor(this.transport, slot);
+        return { keys, handler };
+    }
+    getSlotStorage(slot) {
+        if (SlotFixedArrayHandler_1.SlotFixedArrayHandler.supports(slot)) {
+            return SlotFixedArrayHandler_1.SlotFixedArrayHandler;
+        }
+        if (SlotStructHandler_1.SlotStructHandler.supports(slot)) {
+            return SlotStructHandler_1.SlotStructHandler;
+        }
+        if (SlotDynamicArrayHandler_1.SlotDynamicArrayHandler.supports(slot)) {
+            return SlotDynamicArrayHandler_1.SlotDynamicArrayHandler;
+        }
+        if (SlotMappingHandler_1.SlotMappingHandler.supports(slot)) {
+            return SlotMappingHandler_1.SlotMappingHandler;
+        }
+        if (SlotStringHandler_1.SlotStringHandler.supports(slot)) {
+            return SlotStringHandler_1.SlotStringHandler;
+        }
+        return SlotValueHandler_1.SlotValueHandler;
+    }
+    getKeys(path) {
+        if (path == null) {
+            return [];
+        }
+        if (typeof path === 'string') {
+            return Accessor_1.Accessor.parse(path).keys;
+        }
+        function isValue(x) {
+            switch (typeof x) {
+                case 'number':
+                case 'bigint':
+                case 'string':
+                    return true;
+            }
+            return false;
+        }
+        let isBreadcrumbs = path.every(isValue);
+        if (isBreadcrumbs) {
+            return path.map(key => ({ key, type: 'key' }));
+        }
+        return path;
+    }
+}
+exports.SlotsStorage = SlotsStorage;

package/dist/src/solidity/storage/Accessor.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Accessor = void 0;
+class Accessor {
+    constructor(keys) {
+        this.keys = keys;
+    }
+    /**
+     * "foo.bar"
+     * "foos[0].bar"
+     * "foo['key'].bar"
+     * "[0].qux"
+     * @param path
+     */
+    static parse(path) {
+        path = path.trim();
+        let arr = [];
+        for (let i = 0; i < path.length; i++) {
+            i = Parse.skipWhitespace(path, i);
+            let c = path[i];
+            if (c === '.') {
+                continue;
+            }
+            if (c === "[") {
+                let end = Parse.goToClosing(path, i + 1, '[', ']');
+                let keyStr = path.substring(i + 1, end);
+                let { value, type } = Parse.parseKey(keyStr);
+                i = end;
+                arr.push({
+                    key: value,
+                    type
+                });
+                continue;
+            }
+            let end = Parse.goToFieldEnd(path, i);
+            arr.push({
+                key: path.substring(i, end),
+                type: 'key',
+            });
+            i = end - 1;
+            continue;
+        }
+        return new Accessor(arr);
+    }
+}
+exports.Accessor = Accessor;
+var Parse;
+(function (Parse) {
+    function goToFieldEnd(str, i) {
+        for (; i < str.length; i++) {
+            let c = str[i];
+            if (c === ' ' || c === '.' || c === '[') {
+                return i;
+            }
+        }
+        return i;
+    }
+    Parse.goToFieldEnd = goToFieldEnd;
+    function parseKey(str) {
+        let start = skipWhitespace(str, 0);
+        let c = str[start];
+        let quotes = c === '"' || c === "'";
+        if (quotes) {
+            start = start + 1;
+        }
+        let end = quotes ? goToQuoteEnd(str, start + 1, c) : str.length;
+        let key = str.substring(start, end);
+        let value = key.trim();
+        if (quotes === false && /^\d+$/.test(value)) {
+            return {
+                value: Number(value),
+                type: 'index'
+            };
+        }
+        return {
+            value,
+            type: 'key'
+        };
+    }
+    Parse.parseKey = parseKey;
+    function skipWhitespace(str, _i) {
+        let i = _i;
+        for (; i < str.length; i++) {
+            if (str.charCodeAt(i) > 32) {
+                return i;
+            }
+        }
+        return i;
+    }
+    Parse.skipWhitespace = skipWhitespace;
+    function goToClosing(str, startI, openChar, closeChar) {
+        closeChar = closeChar ?? CLOSE_CHARS[openChar];
+        let count = 1;
+        for (let i = startI; i < str.length; i++) {
+            if (str[i] === openChar) {
+                count++;
+            }
+            if (str[i] === closeChar) {
+                count--;
+            }
+            if (count === 0) {
+                return i;
+            }
+        }
+        throw new Error(`Unmatched closing chars ${openChar} ${closeChar} in ${str}`);
+    }
+    Parse.goToClosing = goToClosing;
+    function goToQuoteEnd(str, startI, quote) {
+        for (let i = startI; i < str.length; i++) {
+            let c = str[i];
+            if (c === '\\') {
+                i++;
+                continue;
+            }
+            if (str[i] === quote) {
+                return i;
+            }
+        }
+        throw new Error(`Not found closing quote ${quote} in ${str}`);
+    }
+    Parse.goToQuoteEnd = goToQuoteEnd;
+    const CLOSE_CHARS = {
+        '[': ']',
+        '(': ')'
+    };
+})(Parse || (Parse = {}));

package/dist/src/solidity/storage/SlotDynamicArray.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ASlotDynamicArray = void 0;
+const _types_1 = require("../utils/$types");
+const SlotsStorageHandler_1 = require("./SlotsStorageHandler");
+class ASlotDynamicArray extends SlotsStorageHandler_1.ASlotsStorageHandler {
+    static supports(slot) {
+        return _types_1.$types.isDynamicArray(slot.type);
+    }
+    async length() {
+        let { slot } = this;
+        let arrLengthHex = await this.transport.getStorageAt(slot.slot, 0, 256);
+        let arrLength = Number(arrLengthHex);
+        return arrLength;
+    }
+}
+exports.ASlotDynamicArray = ASlotDynamicArray;

package/dist/src/solidity/storage/SlotFixedArray.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ASlotFixedArray = void 0;
+const _abiType_1 = require("@dequanto/utils/$abiType");
+const _require_1 = require("@dequanto/utils/$require");
+const _types_1 = require("../utils/$types");
+const SlotsStorageHandler_1 = require("./SlotsStorageHandler");
+class ASlotFixedArray extends SlotsStorageHandler_1.ASlotsStorageHandler {
+    static supports(slot) {
+        return _types_1.$types.isFixedArray(slot.type);
+    }
+    /** @TODO doesnt support complex arrays  */
+    async getCursorFor(idx) {
+        let { slot } = this;
+        let arrLength = _abiType_1.$abiType.array.getLength(slot.type);
+        _require_1.$require.True(idx < arrLength, `${idx} is out of bounds for the array[${arrLength}]`);
+        let itemSize = slot.size / arrLength;
+        let offset = slot.position + itemSize * idx;
+        let offsetSlots = Math.floor(offset / 256);
+        let cursor = {
+            slot: BigInt(slot.slot) + BigInt(offsetSlots),
+            position: offset % 256,
+            size: itemSize,
+        };
+        return cursor;
+    }
+}
+exports.ASlotFixedArray = ASlotFixedArray;

package/dist/src/solidity/storage/SlotsStorageHandler.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ASlotsStorageHandler = void 0;
+class ASlotsStorageHandler {
+    constructor(transport, slot) {
+        this.transport = transport;
+        this.slot = slot;
+    }
+}
+exports.ASlotsStorageHandler = ASlotsStorageHandler;

package/dist/src/solidity/storage/SlotsStorageTransport.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlotsStorageTransportForMapping = exports.SlotsStorageTransportForArray = exports.SlotsStorageTransport = exports.SlotsCursorTransport = void 0;
+const _str_1 = require("@dequanto/solidity/utils/$str");
+const _abiUtils_1 = require("@dequanto/utils/$abiUtils");
+const _bigint_1 = require("@dequanto/utils/$bigint");
+const _contract_1 = require("@dequanto/utils/$contract");
+const _hex_1 = require("@dequanto/utils/$hex");
+const _require_1 = require("@dequanto/utils/$require");
+class SlotsCursorTransport {
+    constructor(cursor, transport) {
+        this.cursor = cursor;
+        this.transport = transport;
+    }
+    getStorageAt(slot, position, size) {
+        let offsetSlot = BigInt(this.cursor.slot);
+        let offsetPosition = position + (this.cursor.position ?? 0);
+        size ?? (size = this.cursor.size);
+        return this.transport.getStorageAt(BigInt(slot) + offsetSlot, offsetPosition, size);
+    }
+    setStorageAt(slot, position, size, buffer) {
+        let offsetSlot = BigInt(this.cursor.slot);
+        let offsetPosition = position + (this.cursor.position ?? 0);
+        return this.transport.setStorageAt(BigInt(slot) + offsetSlot, offsetPosition, size, buffer);
+    }
+}
+exports.SlotsCursorTransport = SlotsCursorTransport;
+class SlotsStorageTransport {
+    constructor(client, address, params) {
+        this.client = client;
+        this.address = address;
+        this.params = params;
+    }
+    async getStorageAt(slot, position, size) {
+        slot = _hex_1.$hex.toHex(slot);
+        let mem = await this.client.getStorageAt(this.address, slot, this.params?.blockNumber);
+        if (size != null && size < 256) {
+            mem = '0x' + _str_1.$str.sliceFromEnd(mem, position, size);
+        }
+        return mem;
+    }
+    async setStorageAt(slot, position, size, buffer) {
+        _require_1.$require.notNull(slot, `Slot position is undefined`);
+        _require_1.$require.notNull(buffer, `Slot value is undefined`);
+        slot = _hex_1.$hex.toHex(slot);
+        buffer = _hex_1.$hex.toHexBuffer(buffer);
+        let SLOT_SIZE = 256;
+        if (size != null && size < SLOT_SIZE) {
+            let current = await this.client.getStorageAt(this.address, slot);
+            let bytesLen = size / 8;
+            buffer = _hex_1.$hex.padBytes(buffer, bytesLen);
+            buffer = _str_1.$str.writeFromEnd(current, buffer, position, size);
+            buffer = _hex_1.$hex.ensure(buffer);
+        }
+        buffer = _hex_1.$hex.padBytes(buffer, 32);
+        await this.client.debug.setStorageAt(this.address, slot, buffer);
+    }
+}
+exports.SlotsStorageTransport = SlotsStorageTransport;
+class SlotsStorageTransportForArray {
+    constructor(storage, slotNr, elementI = 0, slotsPerElement = 1) {
+        this.storage = storage;
+        this.slotNr = slotNr;
+        this.elementI = elementI;
+        this.slotsPerElement = slotsPerElement;
+    }
+    async getStorageAt(slot, position = 0, size = 256) {
+        if (typeof slot !== 'number') {
+            throw new Error(`Array Slot reader supports only numbers for position`);
+        }
+        let location = this.mapToGlobalSlot(slot);
+        let memory = await this.storage.getStorageAt(location, position, size);
+        return memory;
+    }
+    async setStorageAt(slot, position, size, buffer) {
+        let location = this.mapToGlobalSlot(Number(slot));
+        let memory = await this.storage.setStorageAt(location, position, size, buffer);
+        return memory;
+    }
+    mapToGlobalSlot(slot) {
+        let slotPositionNr = this.elementI * this.slotsPerElement + slot;
+        let x = BigInt(_contract_1.$contract.keccak256(_abiUtils_1.$abiUtils.encodePacked({ value: _hex_1.$hex.toHex(this.slotNr), type: 'uint256' })));
+        let uint = x + BigInt(slotPositionNr);
+        return _bigint_1.$bigint.toHex(uint);
+    }
+}
+exports.SlotsStorageTransportForArray = SlotsStorageTransportForArray;
+class SlotsStorageTransportForMapping {
+    constructor(storage, slotNr, key, slotsPerElement = 1) {
+        this.storage = storage;
+        this.slotNr = slotNr;
+        this.key = key;
+        this.slotsPerElement = slotsPerElement;
+    }
+    async getStorageAt(slot) {
+        if (typeof slot !== 'number') {
+            throw new Error(`Mapping Slot reader supports only numbers for position`);
+        }
+        let location = this.mapToGlobalSlot(BigInt(slot));
+        let memory = await this.storage.getStorageAt(location, 0, 256);
+        return memory;
+    }
+    async setStorageAt(slot, position, size, buffer) {
+        let location = this.mapToGlobalSlot(BigInt(slot));
+        let memory = await this.storage.setStorageAt(location, position, size, buffer);
+        return memory;
+    }
+    mapToGlobalSlot(slotPositionNr = 0n) {
+        let key = this.key;
+        let slotMappingNr = this.slotNr;
+        if (typeof key === 'string' && /^\d+$/.test(key)) {
+            key = Number(key);
+        }
+        let packed = _abiUtils_1.$abiUtils.encodePacked({
+            value: _hex_1.$hex.padBytes(_hex_1.$hex.toHexBuffer(key), 32),
+            type: 'bytes32'
+        }, {
+            value: slotMappingNr,
+            type: 'uint256'
+        });
+        let x = BigInt(_contract_1.$contract.keccak256(packed));
+        let uint = x + BigInt(slotPositionNr);
+        return _bigint_1.$bigint.toHex(uint);
+    }
+}
+exports.SlotsStorageTransportForMapping = SlotsStorageTransportForMapping;

package/dist/src/solidity/storage/handlers/SlotDynamicArrayHandler.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlotDynamicArrayHandler = void 0;
+const alot_1 = __importDefault(require("alot"));
+const SlotsParser_1 = require("@dequanto/solidity/SlotsParser");
+const _abiType_1 = require("@dequanto/utils/$abiType");
+const SlotsStorage_1 = require("../../SlotsStorage");
+const SlotsStorageTransport_1 = require("../SlotsStorageTransport");
+const SlotDynamicArray_1 = require("../SlotDynamicArray");
+class SlotDynamicArrayHandler extends SlotDynamicArray_1.ASlotDynamicArray {
+    async get(keys) {
+        if (keys == null || keys.length === 0) {
+            return this.fetchAll();
+        }
+        let key = keys.shift();
+        let reader = await this.getStorageInner(key);
+        return reader.get(keys);
+    }
+    async set(keys, value) {
+        if (keys == null || keys.length === 0) {
+            throw new Error(`saveAll not implemented`);
+        }
+        let key = keys.shift();
+        let reader = await this.getStorageInner(key);
+        reader.set(keys, value);
+    }
+    async fetchAll() {
+        let arrLength = await this.length();
+        return await alot_1.default.fromRange(0, arrLength).mapAsync(async (i) => {
+            return this.get([{ key: i, type: 'index' }]);
+        }).toArrayAsync();
+    }
+    async getStorageInner(key) {
+        if (key.type !== 'index') {
+            throw new Error(`Expected to get the Array index as a Key got ${key.key} as ${key.type}`);
+        }
+        let baseType = _abiType_1.$abiType.array.getBaseType(this.slot.type);
+        let baseSlots = await SlotsParser_1.SlotsParser.slotsFromAbi(baseType);
+        let transport = new SlotsStorageTransport_1.SlotsStorageTransportForArray(this.transport, this.slot.slot, key.key, baseSlots.length);
+        let storage = new SlotsStorage_1.SlotsStorage(transport, baseSlots);
+        return storage;
+    }
+}
+exports.SlotDynamicArrayHandler = SlotDynamicArrayHandler;

package/dist/src/solidity/storage/handlers/SlotFixedArrayHandler.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlotFixedArrayHandler = void 0;
+const alot_1 = __importDefault(require("alot"));
+const _abiType_1 = require("@dequanto/utils/$abiType");
+const SlotFixedArray_1 = require("../SlotFixedArray");
+const SlotsStorage_1 = require("@dequanto/solidity/SlotsStorage");
+const SlotsParser_1 = require("@dequanto/solidity/SlotsParser");
+const SlotsStorageTransport_1 = require("../SlotsStorageTransport");
+class SlotFixedArrayHandler extends SlotFixedArray_1.ASlotFixedArray {
+    async get(keys) {
+        if (keys == null || keys.length === 0) {
+            return this.fetchAll();
+        }
+        let storage = await this.getStorageInner(keys);
+        return storage.get(keys);
+    }
+    async set(keys, value) {
+        if (keys == null || keys.length === 0) {
+            throw new Error(`saveAll not implemented`);
+        }
+        let storage = await this.getStorageInner(keys);
+        return storage.set(keys, value);
+    }
+    async fetchAll() {
+        let slot = this.slot;
+        let arrLength = _abiType_1.$abiType.array.getLength(slot.type);
+        return await alot_1.default.fromRange(0, arrLength).mapAsync(async (i) => {
+            return this.get([
+                { key: i, type: 'index' }
+            ]);
+        }).toArrayAsync();
+    }
+    async getStorageInner(keys) {
+        let key = keys.shift();
+        if (key.type !== 'index') {
+            throw new Error(`Expected to get the Array index as a Key got ${key.key} as ${key.type}`);
+        }
+        let cursor = await this.getCursorFor(key.key);
+        let baseType = _abiType_1.$abiType.array.getBaseType(this.slot.type);
+        let baseSlots = await SlotsParser_1.SlotsParser.slotsFromAbi(baseType);
+        let transport = new SlotsStorageTransport_1.SlotsCursorTransport(cursor, this.transport);
+        let storage = new SlotsStorage_1.SlotsStorage(transport, baseSlots);
+        return storage;
+    }
+}
+exports.SlotFixedArrayHandler = SlotFixedArrayHandler;

package/dist/src/solidity/storage/handlers/SlotMappingHandler.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlotMappingHandler = void 0;
+const _abiType_1 = require("@dequanto/utils/$abiType");
+const SlotsParser_1 = require("../../SlotsParser");
+const SlotsStorage_1 = require("../../SlotsStorage");
+const _types_1 = require("../../utils/$types");
+const SlotsStorageTransport_1 = require("../SlotsStorageTransport");
+const SlotsStorageHandler_1 = require("../SlotsStorageHandler");
+class SlotMappingHandler extends SlotsStorageHandler_1.ASlotsStorageHandler {
+    static supports(slot) {
+        return _types_1.$types.isMapping(slot.type);
+    }
+    async get(keys) {
+        if (keys == null || keys.length === 0) {
+            return this.fetchAll();
+        }
+        let key = keys.shift();
+        let reader = await this.getStorageInner(key);
+        return reader.get(keys);
+    }
+    async set(keys, value) {
+        if (keys == null || keys.length === 0) {
+            throw new Error(`saveAll not implemented`);
+        }
+        let key = keys.shift();
+        let storage = await this.getStorageInner(key);
+        storage.set(keys, value);
+    }
+    async fetchAll() {
+        throw new Error(`SlotMappingReader doesn't support fetchAll method, as size could be infinite`);
+    }
+    async getStorageInner(key) {
+        let { slot } = this;
+        let mapValueType = _abiType_1.$abiType.mapping.getValueType(slot.type);
+        let mapValueSlots = await SlotsParser_1.SlotsParser.slotsFromAbi(mapValueType);
+        let transport = new SlotsStorageTransport_1.SlotsStorageTransportForMapping(this.transport, this.slot.slot, key.key, mapValueSlots.length);
+        let storage = new SlotsStorage_1.SlotsStorage(transport, mapValueSlots);
+        return storage;
+    }
+}
+exports.SlotMappingHandler = SlotMappingHandler;