dequanto 0.0.1 → 0.1.3

package/src/utils/$sign.ts

@@ -1,36 +1,136 @@
-import { hashPersonalMessage, ecsign } from 'ethereumjs-util';
-
-export namespace $sign {
-    export function signEC (message: string | Buffer, privateKey: string | Buffer) {
-        const sig = ecsign(
-            toBuffer(message),
-            toBuffer(privateKey, { encoding: 'hex' })
-        );
-
-        let r = sig.r.toString('hex').padStart(64, '0')
-        let s = sig.s.toString('hex').padStart(64, '0');
-        let v = sig.v.toString(16);
-
-        return {
-            v: `0x${v}`,
-            r: `0x${r}`,
-            s: `0x${s}`,
-            signature: `0x${r}${s}${v}`,
-            signatureVRS: `0x${v}${r}${s}`
-        }
-    }
-    export function signEIPHashed (message: string | Buffer, privateKey: string) {
-        const hash = hashPersonalMessage(toBuffer(message, { encoding: 'utf8' }));
-        return signEC(hash, privateKey);
-    }
-
-    function toBuffer (message: string | Buffer, opts?: { encoding?: 'utf8' | 'hex' }) {
-        if (typeof message === 'string') {
-            if (/^0x[\da-f]+$/i.test(message)) {
-                return Buffer.from(message.substring(2), 'hex');
-            }
-            return Buffer.from(message, opts?.encoding ?? 'utf8');
-        }
-        return message;
-    }
-}
+import { Web3Client } from '@dequanto/clients/Web3Client';
+import { EoAccount } from '@dequanto/models/TAccount';
+import { $buffer, TBytes } from './$buffer';
+import { $is } from './$is';
+import { TEth } from '@dequanto/models/TEth';
+
+throw new Error(`Deprecated. Use @dequanto/utils/$sig instead.`);
+
+// export namespace $sign {
+//     export type TSignature = {
+//         v: string
+//         r: string
+//         s: string
+//         signature?: string
+//         signatureVRS?: string
+//     };
+
+//     /** Adds  "Ethereum Signed Message" */
+//     export async function signEIPHashed (client: Web3Client, message: string, account: EoAccount, accountPss?: string): Promise<TSignature> {
+//         const web3 = await client.getWeb3();
+//         //const buffer = toBuffer(message);
+//         //const hash = hashPersonalMessage(buffer as Buffer);
+//         const str = message;
+//         const key = account.key != null
+//             ? account.key
+//             : null;
+
+//         if (key != null) {
+//             let sig = web3.eth.accounts.sign(str, key);
+//             let r = sig.r.substring(2)
+//             let s = sig.s.substring(2)
+//             let v = sig.v.substring(2);
+//             return toSignature({ r, s, v });
+//         }
+
+//         let signature =  accountPss == null
+//             ? await web3.eth.sign(message.toString(), account.address)
+//             : await web3.eth.personal.sign(message.toString(), account.address, accountPss);
+
+//         return toSignature(splitSignature(signature));
+
+//     }
+
+//     export async function signTx (client: Web3Client, tx: TEth.Tx, account: EoAccount, accountPss?: string): Promise<ReturnType<typeof splitSignature>> {
+//         const web3 = await client.getWeb3();
+//         const key = account.key != null
+//             ? account.key
+//             : null;
+
+//         if (key != null) {
+//             if (typeof tx.chainId === 'string') {
+//                 // chainIDBN in @ethereumjs supports HEX only if base is specified, otherwise 10 base is taken, and hex numbers are wrongly parsed to a number
+//                 tx.chainId = Number(tx.chainId);
+//             }
+//             let sig = await web3.eth.accounts.signTransaction(tx, key);
+//             return toSignature(sig);
+//         }
+
+//         let signed =  accountPss == null
+//             ? await web3.eth.signTransaction(tx)
+//             : await web3.eth.personal.signTransaction(tx, accountPss);
+
+//         return toSignature(signed.tx);
+//     }
+
+//     export async function serializeTx (tx, signature: string | TSignature): Promise<string> {
+//         let sig = getSignature(signature);
+//         if (Number(sig.v) === 0) {
+//             // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-155.md
+//             sig.v = '0x25';
+//         }
+//         return ethers.utils.serializeTransaction(tx, {
+//             ...sig,
+//             v: Number(sig.v)
+//         });
+//     }
+//     export async function recoverTx(client: Web3Client, tx: TransactionConfig, signature: string | TSignature) {
+//         const web3 = await client.getWeb3();
+//         const sig = getSignature(signature);
+//         const rawTransaction = await serializeTx(tx, sig);
+//         return web3.eth.accounts.recoverTransaction(rawTransaction);
+//     }
+
+//     function splitSignature (signature: string): TSignature {
+//         let r = signature.substring(2, 2 + 64);
+//         let s = signature.substring(2 + 64, 2 + 64 + 64);
+//         let v = signature.substring(2 + 64 + 64);
+//         return { r, s ,v };
+//     }
+//     function toSignature (sign: { r, s, v }) {
+//         let { r, s, v } = sign;
+//         r = remove0x(r);
+//         s = remove0x(s);
+//         if (typeof v === 'number') {
+//             v = v.toString(16);
+//         }
+//         v = remove0x(v);
+//         return {
+//             v: `0x${v}`,
+//             r: `0x${r}`,
+//             s: `0x${s}`,
+//             signature: `0x${r}${s}${v}`,
+//             signatureVRS: `0x${v}${r}${s}`
+//         }
+//     }
+//     function remove0x(hex:string) {
+//         return hex.startsWith('0x') ? hex.substring(2) : hex;
+//     }
+
+//     function toBuffer (message: string | TBytes, opts?: { encoding?: 'utf8' | 'hex' }) {
+//         if (typeof message === 'string') {
+//             let encoding = opts?.encoding;
+//             if (encoding == null && $is.Hex(message)) {
+//                 encoding = 'hex';
+//                 message = message.substring(2);
+//             }
+//             if (encoding === 'hex') {
+//                 return $buffer.fromHex(message);
+//             }
+//             return $buffer.fromString(message, opts?.encoding ?? 'utf8');
+//         }
+//         return message;
+//     }
+
+
+//     function getSignature(signature: string | TSignature): TSignature {
+//         let sig = typeof signature === 'string'
+//                 ? splitSignature(signature)
+//                 : signature;
+
+//         if (sig?.r == null || sig?.v == null || sig?.s == null) {
+//             throw new Error(`Invalid signature ${JSON.stringify(sig)}`);
+//         }
+//         return sig;
+//     }
+// }

package/src/utils/$signRaw.ts

@@ -0,0 +1,50 @@
+import { $buffer } from './$buffer';
+import { $is } from './$is';
+import { TAddress } from '@dequanto/models/TAddress';
+
+throw new Error(`Deprecated. Use @dequanto/utils/$sig instead.`);
+
+// export namespace $signRaw {
+//     export function signEC (message: string | Buffer, privateKey: string | Buffer) {
+//         const sig = ecsign(
+//             toBuffer(message) as Buffer,
+//             toBuffer(privateKey, { encoding: 'hex' }) as Buffer
+//         );
+
+//         let r = sig.r.toString('hex').padStart(64, '0')
+//         let s = sig.s.toString('hex').padStart(64, '0');
+//         let v = sig.v.toString(16);
+
+//         return {
+//             v: `0x${v}`,
+//             r: `0x${r}`,
+//             s: `0x${s}`,
+//             signature: `0x${r}${s}${v}`,
+//             signatureVRS: `0x${v}${r}${s}`
+//         }
+//     }
+//     export function signEIPHashed (message: string | Buffer, privateKey: string) {
+//         const buffer = toBuffer(message);
+//         const hash = hashPersonalMessage(buffer as Buffer);
+//         return signEC(hash, privateKey);
+//     }
+
+//     export function ecrecover (message: string, signature: string | { v, r, s}): TAddress {
+//         return utils.recoverAddress(message, signature) as TAddress;
+//     }
+
+//     function toBuffer (message: string | Buffer, opts?: { encoding?: 'utf8' | 'hex' }) {
+//         if (typeof message === 'string') {
+//             let encoding = opts?.encoding;
+//             if (encoding == null && $is.Hex(message)) {
+//                 encoding = 'hex';
+//                 message = message.substring(2);
+//             }
+//             if (encoding === 'hex') {
+//                 return $buffer.fromHex(message);
+//             }
+//             return $buffer.fromString(message, opts?.encoding ?? 'utf8');
+//         }
+//         return message;
+//     }
+// }

package/src/utils/$signRawNative.ts

@@ -0,0 +1,105 @@
+import { secp256k1 } from '@noble/curves/secp256k1'
+import { TEth } from '@dequanto/models/TEth';
+import { $buffer } from './$buffer';
+import { $contract } from './$contract';
+import { $is } from './$is';
+import { $hex } from './$hex';
+import { $address } from './$address';
+
+throw new Error(`Deprecated. Use @dequanto/utils/$sig instead.`);
+
+// export namespace $signRawNative {
+//     export function signEC (message: string | Uint8Array, privateKey: string | Uint8Array, chainId?: number) {
+//         const sig = secp256k1.sign(
+//             toUint8Array(message) as Uint8Array,
+//             toUint8Array(privateKey, { encoding: 'hex' }) as Uint8Array
+//         );
+
+//         let r = sig.r.toString(16).padStart(64, '0');
+//         let s = sig.s.toString(16).padStart(64, '0');
+//         // https://eips.ethereum.org/EIPS/eip-155
+//         let v = (chainId != null
+//             ? sig.recovery + chainId * 2 + 35
+//             : sig.recovery + 27
+//         ).toString(16);
+
+//         return {
+//             v: `0x${v}`,
+//             r: `0x${r}`,
+//             s: `0x${s}`,
+//             signature: `0x${r}${s}${v}`,
+//             signatureVRS: `0x${v}${r}${s}`
+//         }
+//     }
+//     export function signEIPHashed (message: string | Uint8Array, privateKey: string) {
+//         const buffer = toUint8Array(message);
+//         const hash = hashPersonalMessage(buffer);
+//         return signEC(hash, privateKey);
+//     }
+
+//     export function ecrecover (digest: TEth.Hex | Uint8Array, signature: TEth.Hex | { v, r, s }): TEth.Address {
+//         return recoverAddress(digest, signature);
+//     }
+//     export function eipRecover (message: string | Uint8Array, signature: TEth.Hex | { v, r, s }): TEth.Address {
+//         const buffer = toUint8Array(message);
+//         const hash = hashPersonalMessage(buffer);
+//         return recoverAddress(hash, signature);
+//     }
+
+//     export function recoverAddress (digest: TEth.Hex | Uint8Array, signature: TEth.Hex | { v, r, s }): Promise<TEth.Address> {
+//         const publicKey = recoverPubKey(digest, signature);
+//         const address = $contract.keccak256(`0x${publicKey.substring(4)}`).slice(-40)
+//         return $address.toChecksum(`0x${address}`);
+//     }
+//     export function recoverPubKey (digest: TEth.Hex | Uint8Array, signature: TEth.Hex | { v, r, s }) {
+//         let { v, r, s } = $is.Hex(signature)
+//             ? splitSignature(signature)
+//             : signature;
+
+//         let vNum = Number(v);
+//         let recovery: 0 | 1;
+//         if (vNum === 0 || vNum === 1) {
+//             recovery = vNum;
+//         } else if (vNum === 27 || vNum === 28) {
+//             recovery = (vNum - 27) as 0 | 1;
+//         } else if (vNum > 35) {
+//             vNum -= 35;
+//             recovery = vNum % 2 === 0 ? 0 : 1;
+//         }
+//         r = r.substring(2);
+//         s = s.substring(2);
+
+//         const publicKey = secp256k1.Signature.fromCompact(`${r}${s}`)
+//             .addRecoveryBit(recovery)
+//             .recoverPublicKey($hex.raw($hex.ensure(digest)))
+//             .toHex(false);
+//           return `0x${publicKey}`
+//     }
+
+//     function splitSignature (signature: TEth.Hex): { v, r, s} {
+//         let r = signature.substring(2, 2 + 64);
+//         let s = signature.substring(2 + 64, 2 + 64 + 64);
+//         let v = signature.substring(2 + 64 + 64);
+//         return { r, s ,v };
+//     }
+
+//     function hashPersonalMessage (buffer: Uint8Array) {
+//         const prefix = $buffer.fromString(`\u0019Ethereum Signed Message:\n${buffer.length}`, 'utf-8')
+//         return $contract.keccak256($buffer.concat([prefix, buffer]))
+//     }
+
+//     function toUint8Array (message: string | Uint8Array, opts?: { encoding?: 'utf8' | 'hex' }): Uint8Array {
+//         if (typeof message === 'string') {
+//             let encoding = opts?.encoding;
+//             if (encoding == null && $is.Hex(message)) {
+//                 encoding = 'hex';
+//                 message = message.substring(2);
+//             }
+//             if (encoding === 'hex') {
+//                 return $buffer.fromHex(message);
+//             }
+//             return $buffer.fromString(message, opts?.encoding ?? 'utf8');
+//         }
+//         return message;
+//     }
+// }

package/src/utils/$signSerializer.ts

@@ -1,5 +1,9 @@
-import * as ethUtil from 'ethereumjs-util';
-import * as ethAbi from 'ethereumjs-abi';
+import { $buffer } from './$buffer';
+import { $bigint } from './$bigint';
+import { $abiCoder } from '@dequanto/abi/$abiCoder';
+import { $contract } from './$contract';
+import { TEth } from '@dequanto/models/TEth';
+import { $is } from './$is';
 
 export namespace $signSerializer {
 
@@ -90,7 +94,7 @@ export namespace $signSerializer {
             data: Record<string, any>,
             types: Record<string, MessageTypeProperty[]>,
             useV4 = true
-        ): Buffer {
+        ): TEth.Hex {
             const encodedTypes = ['bytes32'];
             const encodedValues = [this.hashType(primaryType, types)];
 
@@ -116,7 +120,7 @@ export namespace $signSerializer {
                     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');
+                            value = $buffer.fromString(value);
                         }
                         return ['bytes32', ethUtil_keccak(value)];
                     }
@@ -127,7 +131,7 @@ export namespace $signSerializer {
                         return [
                             'bytes32',
                             ethUtil_keccak(
-                                ethAbi.rawEncode(
+                                $abiCoder.encode(
                                     typeValuePairs.map(([t]) => t),
                                     typeValuePairs.map(([, v]) => v)
                                 )
@@ -159,7 +163,7 @@ export namespace $signSerializer {
                             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 = $buffer.fromString(value, 'utf8');
                             }
                             value = ethUtil_keccak(value);
                             encodedValues.push(value);
@@ -181,7 +185,13 @@ export namespace $signSerializer {
                 }
             }
 
-            return ethAbi.rawEncode(encodedTypes, encodedValues);
+            for (let i = 0; i < encodedValues.length; i++) {
+                let val = encodedValues[i];
+                if (typeof val === 'bigint') {
+                    encodedValues[i] = $bigint.toHex(val) as any;
+                }
+            }
+            return $abiCoder.encode(encodedTypes, encodedValues);
         }
 
         /**
@@ -251,7 +261,7 @@ export namespace $signSerializer {
             data: Record<string, any>,
             types: Record<string, any>,
             useV4 = true
-        ): Buffer {
+        ): Uint8Array {
             return ethUtil_keccak(this.encodeData(primaryType, data, types, useV4));
         }
 
@@ -262,7 +272,7 @@ export namespace $signSerializer {
          * @param {Object} types - Type definitions
          * @returns {Buffer} - Hash of an object
          */
-        private hashType(primaryType: string, types: Record<string, any>): Buffer {
+        private hashType(primaryType: string, types: Record<string, any>): Uint8Array {
             return ethUtil_keccak(this.encodeType(primaryType, types));
         }
 
@@ -296,9 +306,9 @@ export namespace $signSerializer {
         serialize<T extends MessageTypes>(
             typedData: Partial<TypedData | TypedMessage<T>>,
             useV4 = true
-        ): Buffer {
+        ): Uint8Array {
             const sanitizedData = this.sanitizeData(typedData);
-            const parts = [Buffer.from('1901', 'hex')];
+            const parts = [$buffer.fromHex('1901')];
 
             parts.push(
                 this.hashStruct(
@@ -319,21 +329,17 @@ export namespace $signSerializer {
                 );
             }
 
-            return ethUtil_keccak(Buffer.concat(parts));
+            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);
+    function ethUtil_keccak(mix: string | TEth.BufferLike) {
+        const bytes = typeof mix === 'string' && $is.Hex(mix) === false
+            ? $buffer.fromString(mix)
+            : $buffer.ensure(mix);
+        return $contract.keccak256(bytes, 'buffer');
     }
 
 }

package/src/utils/$txData.ts

@@ -0,0 +1,23 @@
+import { TEth } from '@dequanto/models/TEth';
+import { $bigint } from './$bigint';
+
+export namespace $txData {
+    export function getJson(txData: TEth.TxLike, defaults?: { defaultTxType?: number, chainId?: number}): TEth.TxLike {
+        let json = <TEth.TxLike> {
+            ...txData,
+            type: txData.type ?? defaults?.defaultTxType,
+            chainId: txData.chainId ?? defaults?.chainId
+        };
+        if (json.type === 1) {
+            // delete `type` field in case old tx type. Some old nodes may reject type field presence
+            delete json.type;
+        }
+        for (let key in json) {
+            let value = json[key];
+            if (typeof value === 'bigint') {
+                json[key] = $bigint.toHex(value);
+            }
+        }
+        return json;
+    }
+}

package/src/utils/$wallet.ts

@@ -1,10 +1,3 @@
-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;
-    }
-}
+export namespace $wallet {
+
+}

package/src/utils/types.ts

@@ -1,29 +1,58 @@
-
-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
+import { TEth } from '@dequanto/models/TEth';
+
+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
+
+export type ParametersFromSecond<T extends (x, ...args: any) => any> = T extends (x, ...args: infer P) => any ? P : never;
+
+
+export type TCallback<TResult = any> = (error: Error, result?: TResult) => void
+export type TFnWithCallback<TArgs extends any[], TResult> = (...args: [...TArgs, TCallback<TResult>]) => void
+
+
+export type DataLike<T> = T extends bigint
+    ? bigint | number | TEth.Hex
+    : (T extends number
+        ? number | TEth.Hex
+        : (T extends {}
+            ? { [P in keyof T]?: DataLike<T[P]> }
+            : (T extends []
+                ? DataLike<T[0]>[]
+                : T
+            )
+        )
+    );
+
+
+
+export type TOverrideReturns<TObject extends { }, TReturn> = {
+    [P in keyof TObject]: TObject[P] extends (...args: infer TParams) => any
+        ? (...args: TParams) => TReturn
+        : never;
+}

package/src/wallets/Wallet.ts

@@ -1,33 +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);
-    }
-
-}
+import di from 'a-di';
+import { IBlockChainExplorer } from '@dequanto/explorer/IBlockChainExplorer';
+import { Web3Client } from '@dequanto/clients/Web3Client';
+import { TAddress } from '@dequanto/models/TAddress';
+import { TokensService } from '@dequanto/tokens/TokensService';
+import { TPlatform } from '@dequanto/models/TPlatform';
+import { ERC20 } from '@dequanto-contracts/openzeppelin/ERC20';
+
+export class Wallet {
+
+    tokensService: TokensService
+
+    constructor (
+        public account: { platform: TPlatform, address: TAddress },
+        public client: Web3Client,
+        public explorer: IBlockChainExplorer
+    ) {
+        this.tokensService = di.resolve(TokensService, this.account.platform, this.explorer)
+    }
+
+    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);
+    }
+
+}