dequanto 0.0.1 → 0.0.7

package/src/solidity/SlotsStorage.ts

@@ -0,0 +1,177 @@
+import alot from 'alot';
+import { Web3Client } from '@dequanto/clients/Web3Client';
+import { $require } from '@dequanto/utils/$require';
+import { ISlotVarDefinition } from './SlotsParser';
+import { SlotValueHandler } from './storage/handlers/SlotValueHandler';
+import { SlotFixedArrayHandler } from './storage/handlers/SlotFixedArrayHandler';
+import { SlotDynamicArrayHandler } from './storage/handlers/SlotDynamicArrayHandler';
+import { SlotsStorageTransport, ISlotsStorageTransport } from './storage/SlotsStorageTransport';
+import { TAddress } from '@dequanto/models/TAddress';
+import { ASlotsStorageHandler } from './storage/SlotsStorageHandler';
+import { Constructor, is_Object } from 'atma-utils';
+import { SlotMappingHandler } from './storage/handlers/SlotMappingHandler';
+import { SlotStringHandler } from './storage/handlers/SlotStringHandler';
+import { Accessor, IAccessorItem } from './storage/Accessor';
+import { SlotStructHandler } from './storage/handlers/SlotStructHandler';
+
+export class SlotsStorage {
+
+    static createWithClient(client: Web3Client, address: TAddress, slots: ISlotVarDefinition[], params?: { blockNumber: number }) {
+        let reader = new SlotsStorageTransport(client, address, params);
+        return new SlotsStorage(reader, slots)
+    }
+
+    constructor(public transport: ISlotsStorageTransport, public slots: ISlotVarDefinition[]) {
+
+    }
+
+    async get<T = any>(path?: string | (string | number | bigint)[] |IAccessorItem[]): Promise<T> {
+        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: string | IAccessorItem[], value: any): Promise<void> {
+        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 alot(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 = alot(arr).toDictionary(x => x.key, x => x.value);
+        return dict;
+    }
+
+    async saveAll(value: any) {
+        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 (is_Object(value)) {
+            // object
+            await alot
+                .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);
+    }
+
+    private getStorageFor(path: string | IAccessorItem[]) {
+        let keys = this.getKeys(path);
+        let slot: ISlotVarDefinition;
+        if (keys.length > 0) {
+            let key = keys.shift();
+            slot = this.slots.find(x => x.name === key.key);
+            $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 };
+    }
+    private getSlotStorage(slot: ISlotVarDefinition): Constructor<ASlotsStorageHandler> {
+        if (SlotFixedArrayHandler.supports(slot)) {
+            return SlotFixedArrayHandler;
+        }
+        if (SlotStructHandler.supports(slot)) {
+            return SlotStructHandler;
+        }
+        if (SlotDynamicArrayHandler.supports(slot)) {
+            return SlotDynamicArrayHandler;
+        }
+        if (SlotMappingHandler.supports(slot)) {
+            return SlotMappingHandler;
+        }
+        if (SlotStringHandler.supports(slot)) {
+            return SlotStringHandler;
+        }
+        return SlotValueHandler;
+    }
+    private getKeys(path?: string | (string | number | bigint)[] | IAccessorItem[]) {
+        if (path == null) {
+            return [];
+        }
+        if (typeof path === 'string') {
+            return Accessor.parse(path).keys;
+        }
+        function isValue (x) {
+            switch (typeof x) {
+                case 'number':
+                case 'bigint':
+                case 'string':
+                    return true;
+            }
+            return false;
+        }
+
+        let isBreadcrumbs = (path as any[]).every(isValue);
+        if (isBreadcrumbs) {
+            return path.map(key => (<IAccessorItem> { key, type: 'key' }))
+        }
+        return path as IAccessorItem[];
+    }
+}
+
+
+

package/src/solidity/storage/Accessor.spec.ts

@@ -0,0 +1,45 @@
+import { Accessor } from './Accessor'
+
+UTest({
+    'should parse accessors' () {
+        ([
+            [
+                ['foo', ' foo '],
+                [ { key: 'foo', type: 'key' } ]
+            ],
+            [
+                ['foo.bar', 'foo . bar', `['foo']["bar"]`],
+                [ { key: 'foo', type: 'key'}, { key: 'bar', type: 'key' } ]
+            ],
+            [
+                ['foo[1].bar', 'foo [1].bar', 'foo [ 1 ].bar'],
+                [
+                    { key: 'foo', type: 'key'},
+                    { key: 1, type: 'index'},
+                    { key: 'bar', type: 'key' },
+                ]
+            ],
+            [
+                ['foo["some"].bar', 'foo [   "some"  ] .bar', ],
+                [
+                    { key: 'foo', type: 'key'},
+                    { key: 'some', type: 'key'},
+                    { key: 'bar', type: 'key' },
+                ]
+            ],
+            [
+                ['[2].bar', '[2 ] ["bar"]'],
+                [
+                    { key: 2, type: 'index'},
+                    { key: 'bar', type: 'key' },
+                ]
+            ],
+        ] as const).forEach(([paths, expect]) => {
+
+            paths.forEach(path => {
+                let keys = Accessor.parse(path).keys;
+                deepEq_(keys, expect, `${path} doesnt match ${ JSON.stringify(expect, null, 2) }`);
+            })
+        })
+    }
+})

package/src/solidity/storage/Accessor.ts

@@ -0,0 +1,136 @@
+export type IAccessorItem = { key: string, type: 'key' } | { key: number, type: 'index' }
+
+
+
+export class Accessor {
+
+    constructor (public keys: IAccessorItem[]) {
+
+    }
+
+    /**
+     * "foo.bar"
+     * "foos[0].bar"
+     * "foo['key'].bar"
+     * "[0].qux"
+     * @param path
+     */
+    static parse (path: string): Accessor {
+        path = path.trim();
+        let arr = [] as IAccessorItem[];
+        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 as any,
+                    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);
+    }
+}
+
+
+
+namespace Parse {
+
+    export function goToFieldEnd (str: string, i: number) {
+        for (; i < str.length; i++) {
+            let c = str[i];
+            if (c === ' ' || c === '.' || c === '[') {
+                return i;
+            }
+        }
+        return i;
+    }
+
+    export function parseKey(str: string): { value: number | string, type: 'index' | 'key' } {
+        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'
+        };
+    }
+
+    export function skipWhitespace (str: string, _i: number) {
+        let i = _i;
+        for (; i < str.length; i++) {
+            if (str.charCodeAt(i) > 32) {
+                return i;
+            }
+        }
+        return i;
+    }
+
+
+    export function goToClosing (str: string, startI: number, openChar: string, closeChar?: string) {
+        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}`);
+    }
+    export function goToQuoteEnd (str: string, startI: number, quote: string) {
+        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}`);
+    }
+
+
+    const CLOSE_CHARS = {
+        '[': ']',
+        '(': ')'
+    };
+
+}

package/src/solidity/storage/SlotDynamicArray.ts

@@ -0,0 +1,46 @@
+import { $abiType } from '@dequanto/utils/$abiType';
+import { $require } from '@dequanto/utils/$require';
+import { ISlotVarDefinition, SlotsParser } from '../SlotsParser';
+import { $types } from '../utils/$types';
+import { ASlotsStorageHandler } from './SlotsStorageHandler';
+
+export abstract class ASlotDynamicArray extends ASlotsStorageHandler {
+
+    static supports (slot: ISlotVarDefinition): boolean {
+        return $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;
+    }
+
+
+    // /** @TODO doesnt support complex arrays  */
+    // protected async getCursorFor (idx: number): Promise<{
+    //     slot: number | bigint,
+    //     position: number,
+    //     size: number,
+    //     slots: ISlotVarDefinition[]
+    // }> {
+    //     let { slot } = this;
+    //     let arrLength = $abiType.array.getLength(slot.type);
+    //     $require.True(idx < arrLength, `${idx} is out of bounds for the array[${arrLength}]`);
+
+    //     let arrBaseType = $abiType.array.getBaseType(slot.type);
+    //     let arrBaseTypeSlots = await SlotsParser.slotsFromAbi(arrBaseType);
+    //     let arrSlotCountPerItem = 1 + arrBaseTypeSlots[arrBaseTypeSlots.length - 1].slot;
+
+
+    //     let cursor = {
+    //         slot: BigInt(slot.slot) + BigInt(arrSlotCountPerItem) * BigInt(idx),
+    //         position: 0,
+    //         size: arrSlotCountPerItem * 256,
+    //         slots: arrBaseTypeSlots,
+    //     };
+    //     return cursor;
+    // }
+}

package/src/solidity/storage/SlotFixedArray.ts

@@ -0,0 +1,31 @@
+import { $abiType } from '@dequanto/utils/$abiType';
+import { $require } from '@dequanto/utils/$require';
+import { ISlotVarDefinition } from '../SlotsParser';
+import { $types } from '../utils/$types';
+import { ASlotsStorageHandler } from './SlotsStorageHandler';
+
+export abstract class ASlotFixedArray extends ASlotsStorageHandler {
+
+    static supports (slot: ISlotVarDefinition): boolean {
+        return $types.isFixedArray(slot.type);
+    }
+
+    /** @TODO doesnt support complex arrays  */
+    protected async getCursorFor (idx: number): Promise<{ slot: number | bigint, position: number, size: number }> {
+        let { slot } = this;
+        let arrLength = $abiType.array.getLength(slot.type);
+        $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;
+    }
+}

package/src/solidity/storage/SlotsStorageHandler.ts

@@ -0,0 +1,17 @@
+import { TAddress } from '@dequanto/models/TAddress';
+import { ISlotVarDefinition } from '../SlotsParser';
+import { IAccessorItem } from './Accessor';
+import { ISlotsStorageTransport } from './SlotsStorageTransport';
+
+export abstract class ASlotsStorageHandler {
+    constructor(public transport: ISlotsStorageTransport, public slot: ISlotVarDefinition) {
+
+    }
+
+    abstract get (keys: IAccessorItem[]): Promise<any>
+    abstract set (keys: IAccessorItem[], value): Promise<any>
+
+    //abstract read(...args): Promise<any>
+
+    abstract fetchAll(): Promise<any>
+}

package/src/solidity/storage/SlotsStorageTransport.ts

@@ -0,0 +1,152 @@
+import { Web3Client } from '@dequanto/clients/Web3Client';
+import { TAddress } from '@dequanto/models/TAddress';
+import { $str } from '@dequanto/solidity/utils/$str';
+import { $abiUtils } from '@dequanto/utils/$abiUtils';
+import { $bigint } from '@dequanto/utils/$bigint';
+import { $contract } from '@dequanto/utils/$contract';
+import { $hex } from '@dequanto/utils/$hex';
+import { $require } from '@dequanto/utils/$require';
+
+export interface ISlotsStorageTransport {
+    getStorageAt (slot: string | number | bigint, position: number, size: number): Promise<string>
+    setStorageAt (slot: string | number | bigint, position: number, size: number, buffer: string | number | bigint | boolean): Promise<void>
+}
+
+
+export class SlotsCursorTransport implements ISlotsStorageTransport {
+
+    constructor(private cursor: {
+        slot: number | bigint,
+        position?: number,
+        size?: number,
+    } , private transport: ISlotsStorageTransport) {
+
+    }
+
+    getStorageAt(slot: string | number | bigint, position: number, size: number): Promise<string> {
+        let offsetSlot =  BigInt(this.cursor.slot);
+        let offsetPosition = position + (this.cursor.position ?? 0)
+
+        size ??= this.cursor.size;
+
+        return this.transport.getStorageAt(BigInt(slot) + offsetSlot, offsetPosition, size);
+    }
+
+    setStorageAt(slot: string | number | bigint, position: number, size: number, buffer: string | number | bigint | boolean): Promise<void> {
+        let offsetSlot =  BigInt(this.cursor.slot);
+        let offsetPosition = position + (this.cursor.position ?? 0)
+        return this.transport.setStorageAt(BigInt(slot) + offsetSlot, offsetPosition, size, buffer);
+    }
+
+}
+
+export class SlotsStorageTransport implements ISlotsStorageTransport {
+
+    constructor (private client: Web3Client, public address: TAddress, public params?: { blockNumber }) {
+
+    }
+
+    async getStorageAt (slot: string | number | bigint, position: number, size: number) {
+        slot = $hex.toHex(slot);
+
+        let mem  = await this.client.getStorageAt(this.address, slot, this.params?.blockNumber);
+        if (size != null && size < 256) {
+            mem = '0x' + $str.sliceFromEnd(mem, position, size);
+        }
+        return mem;
+    }
+
+    async setStorageAt (slot: string | number | bigint, position: number, size: number, buffer: string | number | bigint | boolean) {
+        $require.notNull(slot, `Slot position is undefined`);
+        $require.notNull(buffer, `Slot value is undefined`);
+
+        slot = $hex.toHex(slot);
+        buffer = $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.padBytes(buffer, bytesLen);
+            buffer = $str.writeFromEnd(current, buffer, position, size)
+            buffer = $hex.ensure(buffer);
+        }
+
+        buffer = $hex.padBytes(buffer, 32);
+        await this.client.debug.setStorageAt(this.address, slot, buffer);
+    }
+}
+
+export class SlotsStorageTransportForArray implements ISlotsStorageTransport {
+    constructor (private storage: ISlotsStorageTransport, private slotNr: number | bigint, private elementI: number = 0, private slotsPerElement: number = 1) {
+
+    }
+
+    async getStorageAt (slot: string | number | bigint, 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: string | number | bigint, position: number, size: number, buffer: string | number | bigint | boolean): Promise<void> {
+        let location = this.mapToGlobalSlot(Number(slot));
+        let memory = await this.storage.setStorageAt(location, position, size, buffer);
+        return memory;
+    }
+
+    private mapToGlobalSlot (slot: number) {
+        let slotPositionNr = this.elementI * this.slotsPerElement + slot;
+        let x = BigInt($contract.keccak256($abiUtils.encodePacked(
+            { value: $hex.toHex(this.slotNr), type: 'uint256' },
+        )));
+        let uint = x + BigInt(slotPositionNr);
+        return $bigint.toHex(uint);
+    }
+}
+
+export class SlotsStorageTransportForMapping implements ISlotsStorageTransport {
+    constructor (private storage: ISlotsStorageTransport, private slotNr: number, private key: any, private slotsPerElement: number = 1) {
+
+    }
+
+    async getStorageAt (slot: string | number | bigint) {
+        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: string | number | bigint, position: number, size: number, buffer: string | number | bigint | boolean): Promise<void> {
+        let location = this.mapToGlobalSlot(BigInt(slot));
+        let memory = await this.storage.setStorageAt(location, position, size, buffer);
+        return memory;
+    }
+
+
+    private mapToGlobalSlot (slotPositionNr: bigint = 0n) {
+        let key = this.key;
+        let slotMappingNr = this.slotNr;
+
+        if (typeof key === 'string' && /^\d+$/.test(key)) {
+            key = Number(key);
+        }
+
+        let packed = $abiUtils.encodePacked({
+            value: $hex.padBytes($hex.toHexBuffer(key), 32),
+            type: 'bytes32'
+        }, {
+            value: slotMappingNr,
+            type: 'uint256'
+        });
+
+        let x = BigInt($contract.keccak256(packed));
+        let uint = x + BigInt(slotPositionNr);
+        return $bigint.toHex(uint);
+    }
+}

package/src/solidity/storage/handlers/SlotDynamicArrayHandler.ts

@@ -0,0 +1,52 @@
+import alot from 'alot';
+import { SlotsParser } from '@dequanto/solidity/SlotsParser';
+import { $abiType } from '@dequanto/utils/$abiType';
+import { SlotsStorage } from '../../SlotsStorage';
+import { IAccessorItem } from '../Accessor';
+import { SlotsStorageTransportForArray } from '../SlotsStorageTransport';
+import { ASlotDynamicArray } from '../SlotDynamicArray';
+
+export class SlotDynamicArrayHandler extends ASlotDynamicArray {
+
+    async get(keys: IAccessorItem[]): Promise<any> {
+        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: IAccessorItem[], value: any): Promise<any> {
+        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.fromRange(0, arrLength).mapAsync(async i => {
+            return this.get([{ key: i, type: 'index' }]);
+        }).toArrayAsync()
+    }
+
+
+    private async getStorageInner(key: IAccessorItem): Promise<any> {
+
+        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.array.getBaseType(this.slot.type);
+        let baseSlots = await SlotsParser.slotsFromAbi(baseType);
+
+        let transport = new SlotsStorageTransportForArray(this.transport, this.slot.slot, key.key, baseSlots.length);
+        let storage = new SlotsStorage(transport, baseSlots);
+        return storage;
+    }
+
+}