dequanto 0.0.1

package/src/utils/$signSerializer.ts

@@ -0,0 +1,339 @@
+import * as ethUtil from 'ethereumjs-util';
+import * as ethAbi from 'ethereumjs-abi';
+
+export namespace $signSerializer {
+
+    interface MessageTypes {
+        EIP712Domain: MessageTypeProperty[];
+        [additionalProperties: string]: MessageTypeProperty[];
+    }
+
+    interface MessageTypeProperty {
+        name: string;
+        type: string;
+    }
+
+    interface EIP712TypedData {
+        name: string;
+        type: string;
+        value: any;
+    }
+
+    interface TypedMessage<T extends MessageTypes> {
+        types: T;
+        primaryType: string;
+        domain: {
+            name?: string;
+            version?: string;
+            chainId?: number;
+            verifyingContract?: string;
+        };
+        message: Record<string, unknown>;
+    }
+
+
+    type TypedData = string | EIP712TypedData | EIP712TypedData[];
+
+
+    const TYPED_MESSAGE_SCHEMA = {
+        type: 'object',
+        properties: {
+            types: {
+                type: 'object',
+                additionalProperties: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string' },
+                            type: { type: 'string' },
+                        },
+                        required: ['name', 'type'],
+                    },
+                },
+            },
+            primaryType: { type: 'string' },
+            domain: { type: 'object' },
+            message: { type: 'object' },
+        },
+        required: ['types', 'primaryType', 'domain', 'message'],
+    };
+
+
+    export function serializeTypedData<T extends MessageTypes>(data: TypedData | TypedMessage<T>, version: 'V3' | 'V4' = 'V4') {
+        let serializer = new TypedDataSerializer()
+        switch (version) {
+            case 'V3':
+                return serializer.serialize(data, false);
+            case 'V4':
+            default:
+                return serializer.serialize(data, true);
+        }
+    }
+
+
+    /**
+     * A collection of utility functions used for signing typed data
+     */
+    class TypedDataSerializer {
+
+        /**
+         * Encodes an object by encoding and concatenating each of its members
+         *
+         * @param {string} primaryType - Root type
+         * @param {Object} data - Object to encode
+         * @param {Object} types - Type definitions
+         * @returns {Buffer} - Encoded representation of an object
+         */
+        private encodeData(
+            primaryType: string,
+            data: Record<string, any>,
+            types: Record<string, MessageTypeProperty[]>,
+            useV4 = true
+        ): Buffer {
+            const encodedTypes = ['bytes32'];
+            const encodedValues = [this.hashType(primaryType, types)];
+
+            if (useV4) {
+                const encodeField = (name, type, value) => {
+                    if (types[type] !== undefined) {
+                        return [
+                            'bytes32',
+                            value == null // eslint-disable-line no-eq-null
+                                ? '0x0000000000000000000000000000000000000000000000000000000000000000'
+                                : ethUtil_keccak(this.encodeData(type, value, types, useV4)),
+                        ];
+                    }
+
+                    if (value === undefined) {
+                        throw new Error(`missing value for field ${name} of type ${type}`);
+                    }
+
+                    if (type === 'bytes') {
+                        return ['bytes32', ethUtil_keccak(value)];
+                    }
+
+                    if (type === 'string') {
+                        // convert string to buffer - prevents ethUtil from interpreting strings like '0xabcd' as hex
+                        if (typeof value === 'string') {
+                            value = Buffer.from(value, 'utf8');
+                        }
+                        return ['bytes32', ethUtil_keccak(value)];
+                    }
+
+                    if (type.lastIndexOf(']') === type.length - 1) {
+                        const parsedType = type.slice(0, type.lastIndexOf('['));
+                        const typeValuePairs = value.map((item) => encodeField(name, parsedType, item));
+                        return [
+                            'bytes32',
+                            ethUtil_keccak(
+                                ethAbi.rawEncode(
+                                    typeValuePairs.map(([t]) => t),
+                                    typeValuePairs.map(([, v]) => v)
+                                )
+                            ),
+                        ];
+                    }
+
+                    return [type, value];
+                };
+
+                for (const field of types[primaryType]) {
+                    const [type, value] = encodeField(
+                        field.name,
+                        field.type,
+                        data[field.name]
+                    );
+                    encodedTypes.push(type);
+                    encodedValues.push(value);
+                }
+            } else {
+                for (const field of types[primaryType]) {
+                    let value = data[field.name];
+                    if (value !== undefined) {
+                        if (field.type === 'bytes') {
+                            encodedTypes.push('bytes32');
+                            value = ethUtil_keccak(value);
+                            encodedValues.push(value);
+                        } else if (field.type === 'string') {
+                            encodedTypes.push('bytes32');
+                            // convert string to buffer - prevents ethUtil from interpreting strings like '0xabcd' as hex
+                            if (typeof value === 'string') {
+                                value = Buffer.from(value, 'utf8');
+                            }
+                            value = ethUtil_keccak(value);
+                            encodedValues.push(value);
+                        } else if (types[field.type] !== undefined) {
+                            encodedTypes.push('bytes32');
+                            value = ethUtil_keccak(
+                                this.encodeData(field.type, value, types, useV4)
+                            );
+                            encodedValues.push(value);
+                        } else if (field.type.lastIndexOf(']') === field.type.length - 1) {
+                            throw new Error(
+                                'Arrays are unimplemented in encodeData; use V4 extension'
+                            );
+                        } else {
+                            encodedTypes.push(field.type);
+                            encodedValues.push(value);
+                        }
+                    }
+                }
+            }
+
+            return ethAbi.rawEncode(encodedTypes, encodedValues);
+        }
+
+        /**
+         * Encodes the type of an object by encoding a comma delimited list of its members
+         *
+         * @param {string} primaryType - Root type to encode
+         * @param {Object} types - Type definitions
+         * @returns {string} - Encoded representation of the type of an object
+         */
+        private encodeType(
+            primaryType: string,
+            types: Record<string, MessageTypeProperty[]>
+        ): string {
+            let result = '';
+            let deps = this.findTypeDependencies(primaryType, types).filter(
+                (dep) => dep !== primaryType
+            );
+            deps = [primaryType].concat(deps.sort());
+            for (const type of deps) {
+                const children = types[type];
+                if (!children) {
+                    throw new Error(`No type definition specified: ${type}`);
+                }
+                result += `${type}(${types[type]
+                    .map(({ name, type: t }) => `${t} ${name}`)
+                    .join(',')})`;
+            }
+            return result;
+        }
+
+        /**
+         * Finds all types within a type definition object
+         *
+         * @param {string} primaryType - Root type
+         * @param {Object} types - Type definitions
+         * @param {Array} results - current set of accumulated types
+         * @returns {Array} - Set of all types found in the type definition
+         */
+        private findTypeDependencies(
+            primaryType: string,
+            types: Record<string, MessageTypeProperty[]>,
+            results: string[] = []
+        ): string[] {
+            [primaryType] = primaryType.match(/^\w*/u);
+            if (results.includes(primaryType) || types[primaryType] === undefined) {
+                return results;
+            }
+            results.push(primaryType);
+            for (const field of types[primaryType]) {
+                for (const dep of this.findTypeDependencies(field.type, types, results)) {
+                    !results.includes(dep) && results.push(dep);
+                }
+            }
+            return results;
+        }
+
+        /**
+         * Hashes an object
+         *
+         * @param {string} primaryType - Root type
+         * @param {Object} data - Object to hash
+         * @param {Object} types - Type definitions
+         * @returns {Buffer} - Hash of an object
+         */
+        private hashStruct(
+            primaryType: string,
+            data: Record<string, any>,
+            types: Record<string, any>,
+            useV4 = true
+        ): Buffer {
+            return ethUtil_keccak(this.encodeData(primaryType, data, types, useV4));
+        }
+
+        /**
+         * Hashes the type of an object
+         *
+         * @param {string} primaryType - Root type to hash
+         * @param {Object} types - Type definitions
+         * @returns {Buffer} - Hash of an object
+         */
+        private hashType(primaryType: string, types: Record<string, any>): Buffer {
+            return ethUtil_keccak(this.encodeType(primaryType, types));
+        }
+
+        /**
+         * Removes properties from a message object that are not defined per EIP-712
+         *
+         * @param {Object} data - typed message object
+         * @returns {Object} - typed message object with only allowed fields
+         */
+        private sanitizeData<T extends MessageTypes>(
+            data: Partial<TypedData | TypedMessage<T>>
+        ): TypedMessage<T> {
+            const sanitizedData: Partial<TypedMessage<T>> = {};
+            for (const key in TYPED_MESSAGE_SCHEMA.properties) {
+                if (data[key]) {
+                    sanitizedData[key] = data[key];
+                }
+            }
+            if ('types' in sanitizedData) {
+                sanitizedData.types = { EIP712Domain: [], ...sanitizedData.types };
+            }
+            return sanitizedData as Required<TypedMessage<T>>;
+        }
+
+        /**
+         * Signs a typed message as per EIP-712 and returns its keccak hash
+         *
+         * @param {Object} typedData - Types message data to sign
+         * @returns {Buffer} - keccak hash of the resulting signed message
+         */
+        serialize<T extends MessageTypes>(
+            typedData: Partial<TypedData | TypedMessage<T>>,
+            useV4 = true
+        ): Buffer {
+            const sanitizedData = this.sanitizeData(typedData);
+            const parts = [Buffer.from('1901', 'hex')];
+
+            parts.push(
+                this.hashStruct(
+                    'EIP712Domain',
+                    sanitizedData.domain,
+                    sanitizedData.types,
+                    useV4
+                )
+            );
+            if (sanitizedData.primaryType !== 'EIP712Domain') {
+                parts.push(
+                    this.hashStruct(
+                        sanitizedData.primaryType,
+                        sanitizedData.message,
+                        sanitizedData.types,
+                        useV4
+                    )
+                );
+            }
+
+            return ethUtil_keccak(Buffer.concat(parts));
+        }
+    };
+
+
+
+    function ethUtil_keccak (value: string | Buffer) {
+        if (typeof value === 'string') {
+            if (value.startsWith('0x')) {
+                value = Buffer.from(value.substring(2), 'hex');
+            } else {
+                value = Buffer.from(value);
+            }
+        }
+        return ethUtil.keccak(value);
+    }
+
+}

package/src/utils/$wallet.ts

@@ -0,0 +1,10 @@
+import { ChainAccount } from '@dequanto/ChainAccounts';
+import { Wallet, utils } from 'ethers';
+
+export namespace $wallet {
+    export async function ecdsaSign (account: ChainAccount, message: string) {
+        let wallet = new Wallet(account.key);
+        let signature = await wallet.signMessage(message);
+        return signature;
+    }
+}

package/src/utils/types.ts

@@ -0,0 +1,29 @@
+
+type NoneMethodKeys<T> = {
+    [P in keyof T]: T[P] extends ((...args) => any) ? never : P;
+}[keyof T];
+
+export type InterfaceOf<T> = Omit<T, Exclude<keyof T, NoneMethodKeys<T>>>;
+
+export type ValuesOf<T extends any[]>= T[number];
+
+export type DeepPartial<T> = {
+    [P in keyof T]?:
+        T[P] extends Array<infer U> ? Array<DeepPartial<U>> :
+        T[P] extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> :
+        DeepPartial<T[P]> | T[P]
+};
+
+
+
+export type IntersectionTypeWithArrays<T1, T2, arrayKeys extends (keyof T1 & keyof T2)> = (
+    Omit<T1, arrayKeys> &
+    Omit<T2, arrayKeys> & {
+        [key in arrayKeys]: (
+            (T1[key] extends Array<infer U1> ? U1 : never) &
+            (T2[key] extends Array<infer U2> ? U2 : never)
+        )[]
+    }
+);
+
+export type ThenArg<T> = T extends PromiseLike<infer U> ? U : T

package/src/wallets/Wallet.ts

@@ -0,0 +1,33 @@
+import di from 'a-di';
+import { IBlockChainExplorer } from '@dequanto/BlockchainExplorer/IBlockChainExplorer';
+import { Web3Client } from '@dequanto/clients/Web3Client';
+import { ERC20 } from '@dequanto/contracts/common/ERC20';
+import { TAddress } from '@dequanto/models/TAddress';
+import { TokensService } from '@dequanto/tokens/TokensService';
+import { TPlatform } from '@dequanto/models/TPlatform';
+
+export class Wallet {
+
+    tokensService = di.resolve(TokensService, this.account.platform, this.explorer)
+
+    constructor (
+        public account: { platform: TPlatform, address: TAddress },
+        public client: Web3Client,
+        public explorer: IBlockChainExplorer
+    ) {
+
+    }
+
+    async balanceOf (tokenAddress: TAddress)
+    async balanceOf (tokenSymbol: string)
+    async balanceOf (mix: string) {
+        let token = await this.tokensService.getToken(mix);
+        if (token == null) {
+            throw new Error(`Token ${mix} not found`);
+        }
+
+        let erc20 = new ERC20(token.address, this.client, this.explorer);
+        return erc20.balanceOf(this.account.address);
+    }
+
+}

package/src/wallets/WalletBsc.ts

@@ -0,0 +1,13 @@
+import di from 'a-di';
+import { BscWeb3Client } from '@dequanto/clients/BscWeb3Client';
+import { Wallet } from './Wallet';
+import { Bscscan } from '@dequanto/BlockchainExplorer/Bscscan';
+import { TPlatform } from '@dequanto/models/TPlatform';
+import { TAddress } from '@dequanto/models/TAddress';
+
+/** @deprecated use generic Wallet.ts */
+export class WalletBsc extends Wallet {
+    constructor (account: { platform: TPlatform, address: TAddress },) {
+        super(account, di.resolve(BscWeb3Client), di.resolve(Bscscan));
+    }
+}

package/src/wallets/WalletService.ts

@@ -0,0 +1,43 @@
+import di from 'a-di';
+import alot from 'alot';
+import { IToken } from '@dequanto/models/IToken';
+import { TokensService } from '@dequanto/tokens/TokensService';
+import { Wallet } from './Wallet';
+
+export class WalletService {
+    constructor (public wallet: Wallet) {
+
+    }
+
+    async getTokens (fromBlock?: number): Promise<IToken[]> {
+        let wallet = this.wallet;
+        let account = wallet.account;
+
+        let events = await wallet.explorer.getErc20Transfers(
+            account.address,
+            fromBlock,
+        );
+
+        let service = di.resolve(TokensService, account.platform, wallet.explorer);
+        let tokens = await alot(events)
+            .map(x => x.contractAddress)
+            .distinct()
+            .mapAsync(async address => {
+                let token = await service.getKnownToken(address);
+
+                if (token?.address == null) {
+                    return null;
+                }
+                return token
+            })
+            .toArrayAsync({ threads: 10 });
+
+        return tokens.filter(Boolean);
+    }
+}
+
+
+
+class WalletTokensEntity {
+
+}

package/src/www/utils/BlockChainExplorerFormatter.ts

@@ -0,0 +1,13 @@
+import { TAddress } from '@dequanto/models/TAddress';
+import { TPlatform } from '@dequanto/models/TPlatform';
+
+export namespace BlockChainExplorerFormatter {
+    export function getAddressLink(address: TAddress, platform: TPlatform) {
+        if (platform === 'bsc') {
+            return `https://bscscan.com/address/${address}`;
+        }
+        if (platform === 'eth') {
+            return `https://etherscan.io/address/${address}`;
+        }
+    }
+}

package/test/ChainAccount.spec.ts

@@ -0,0 +1,9 @@
+import { ChainAccountProvider } from '@dequanto/ChainAccounts'
+
+
+UTest({
+    async 'generate account' () {
+        let { key, address } = ChainAccountProvider.generate();
+        console.log(key, address);
+    }
+})

package/test/client.spec.ts

@@ -0,0 +1,59 @@
+import { TxDataBuilder } from '@dequanto/txs/TxDataBuilder';
+import { TestNode } from './hardhat/TestNode';
+
+const Accounts = [
+    {
+        address: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
+        key: '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
+    },
+    {
+        address: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+        key: '0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d',
+    }
+]
+UTest({
+    async 'get block' () {
+        let client = await TestNode.client()
+        let block = await client.getBlockNumber()
+        gte_(block, 0);
+    },
+    async 'check balance' () {
+        let client = await TestNode.client()
+        let balance = await client.getBalance('0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266');
+        lte_(balance, 10000n * 10n ** 18n);
+    },
+    async 'send eth' () {
+        let client = await TestNode.client();
+        let [ from, to ] = Accounts;
+        let before = await client.getBalance(to.address);
+
+        let tx = new TxDataBuilder(client, from, {
+            to: to.address
+        });
+
+        await tx.setGas();
+        gte_(BigInt(tx.data.gasPrice as string), 10n ** 8n);
+
+        await tx.setNonce();
+        gte_(Number(tx.data.nonce), 0);
+
+        let amount = 10n * 10n ** 18n;
+        tx.setValue(amount);
+
+        let message = tx.signToString(from.key);
+        let promi = client.sendSignedTransaction(message)
+
+        // promi.on('transactionHash', assert.await());
+        // promi.on('error', error => console.log('error', error));
+        // promi.on('confirmation', confirmation => console.log('confirmation', confirmation));
+        // promi.on('receipt', receipt => console.log('receipt', receipt));
+
+        let receipt = await promi;
+
+        let after = await client.getBalance(to.address);
+        eq_(before + amount, after);
+
+        let txMined = await client.getTransaction(receipt.transactionHash);
+        eq_(txMined.gasPrice, tx.data.gasPrice);
+    }
+})

package/test/fixtures/DaiTokenContract.ts

@@ -0,0 +1,13 @@
+/**
+ * dequanto
+ * name: DaiTokenContractBase
+ * platform: polygon
+ * source.abi: 0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063
+ * output: ./test/tmp/polygon/
+ */
+
+import { DaiTokenContractBase } from '../tmp/polygon/DaiTokenContractBase';
+
+export class DaiTokenContract extends DaiTokenContractBase {
+
+}

package/test/fixtures/receipts/swap.json

@@ -0,0 +1,94 @@
+{
+  "blockHash": "0x4ecb34ddd8737e0316f06251255d628fffcbf2d23887d5b119c1b45c85133357",
+  "blockNumber": 13853348,
+  "contractAddress": null,
+  "cumulativeGasUsed": 13147940,
+  "effectiveGasPrice": "0xc202913f3",
+  "from": "0xf7ca19894ae1cf00a8156d7b54c2f2cfd2c08a13",
+  "gasUsed": 153607,
+  "logs": [
+    {
+      "address": "0x6B175474E89094C44Da98b954EedeAC495271d0F",
+      "blockHash": "0x4ecb34ddd8737e0316f06251255d628fffcbf2d23887d5b119c1b45c85133357",
+      "blockNumber": 13853348,
+      "data": "0x00000000000000000000000000000000000000000000065a4da25d3016c00000",
+      "logIndex": 224,
+      "removed": false,
+      "topics": [
+        "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+        "0x000000000000000000000000f7ca19894ae1cf00a8156d7b54c2f2cfd2c08a13",
+        "0x000000000000000000000000ae461ca67b15dc8dc81ce7615e0320da1a9ab8d5"
+      ],
+      "transactionHash": "0x7e91bf011c11e5e8a553db696bd4b070507b7149af841eb0319010bbfb03502a",
+      "transactionIndex": 172,
+      "id": "log_ab56cd8d"
+    },
+    {
+      "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+      "blockHash": "0x4ecb34ddd8737e0316f06251255d628fffcbf2d23887d5b119c1b45c85133357",
+      "blockNumber": 13853348,
+      "data": "0x00000000000000000000000000000000000000000000000000000006f9ec5a56",
+      "logIndex": 225,
+      "removed": false,
+      "topics": [
+        "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+        "0x000000000000000000000000f7ca19894ae1cf00a8156d7b54c2f2cfd2c08a13",
+        "0x000000000000000000000000ae461ca67b15dc8dc81ce7615e0320da1a9ab8d5"
+      ],
+      "transactionHash": "0x7e91bf011c11e5e8a553db696bd4b070507b7149af841eb0319010bbfb03502a",
+      "transactionIndex": 172,
+      "id": "log_ef1a401e"
+    },
+    {
+      "address": "0xAE461cA67B15dc8dc81CE7615e0320dA1A9aB8D5",
+      "blockHash": "0x4ecb34ddd8737e0316f06251255d628fffcbf2d23887d5b119c1b45c85133357",
+      "blockNumber": 13853348,
+      "data": "0x000000000000000000000000000000000000000000000000005ee27fcad2c58f",
+      "logIndex": 226,
+      "removed": false,
+      "topics": [
+        "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+        "0x0000000000000000000000000000000000000000000000000000000000000000",
+        "0x000000000000000000000000f7ca19894ae1cf00a8156d7b54c2f2cfd2c08a13"
+      ],
+      "transactionHash": "0x7e91bf011c11e5e8a553db696bd4b070507b7149af841eb0319010bbfb03502a",
+      "transactionIndex": 172,
+      "id": "log_9506c662"
+    },
+    {
+      "address": "0xAE461cA67B15dc8dc81CE7615e0320dA1A9aB8D5",
+      "blockHash": "0x4ecb34ddd8737e0316f06251255d628fffcbf2d23887d5b119c1b45c85133357",
+      "blockNumber": 13853348,
+      "data": "0x00000000000000000000000000000000000000000011540e22133a3ab016e5c40000000000000000000000000000000000000000000000000000130773108005",
+      "logIndex": 227,
+      "removed": false,
+      "topics": [
+        "0x1c411e9a96e071241c2f21f7726b17ae89e3cab4c78be50e062b03a9fffbbad1"
+      ],
+      "transactionHash": "0x7e91bf011c11e5e8a553db696bd4b070507b7149af841eb0319010bbfb03502a",
+      "transactionIndex": 172,
+      "id": "log_54311d26"
+    },
+    {
+      "address": "0xAE461cA67B15dc8dc81CE7615e0320dA1A9aB8D5",
+      "blockHash": "0x4ecb34ddd8737e0316f06251255d628fffcbf2d23887d5b119c1b45c85133357",
+      "blockNumber": 13853348,
+      "data": "0x00000000000000000000000000000000000000000000065a4da25d3016c0000000000000000000000000000000000000000000000000000000000006f9ec5a56",
+      "logIndex": 228,
+      "removed": false,
+      "topics": [
+        "0x4c209b5fc8ad50758f13e2e1088ba56a560dff690a1c6fef26394f4c03821c4f",
+        "0x0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d"
+      ],
+      "transactionHash": "0x7e91bf011c11e5e8a553db696bd4b070507b7149af841eb0319010bbfb03502a",
+      "transactionIndex": 172,
+      "id": "log_7284d6fb"
+    }
+  ],
+  "logsBloom": "0x00000000000000000000000080000000000000000100000000010000000001000000000000000000000000000000000000000020000000000000000000000000000060000000000008000008000000000000000000000000000000000000000010000000020000000040000000000800000000000008000000000010000000800000000000000000044000000000000000000000010000080000000000000000000040000000200000100000000000000000000000000000000000000000000000000002000000000000000000020000000002000000001000000000000020000000000000000000000000000000000000000000000000000000000000000000",
+  "status": true,
+  "to": "0x7a250d5630b4cf539739df2c5dacb4c659f2488d",
+  "transactionHash": "0x7e91bf011c11e5e8a553db696bd4b070507b7149af841eb0319010bbfb03502a",
+  "transactionIndex": 172,
+  "type": "0x2"
+}