@beclab/olaresid 0.1.1

package/src/tag/index.ts

@@ -0,0 +1,170 @@
+import {
+	Tag,
+	TagType,
+	TagBase,
+	readByte,
+	parserHolder,
+	read2Byte,
+	Box,
+	ProviderHolder
+} from './tag';
+import { Int } from './int';
+import Uint from './uint';
+import Bool from './bool';
+import Array from './array';
+import String from './string';
+import FixedLengthArray from './flarray';
+import Tuple from './tuple';
+import Address from './address';
+import FixedLengthBytes from './flbytes';
+import Bytes from './bytes';
+import { AbiCoder, ethers } from 'ethers';
+
+const isHex = (hex: string) => {
+	return (
+		typeof hex === 'string' &&
+		hex.length % 2 === 0 &&
+		!isNaN(Number('0x' + hex))
+	);
+};
+
+const formatType = (typeBytes: string): Tag => {
+	if (typeBytes.startsWith('0x')) {
+		typeBytes = typeBytes.substring(2);
+	}
+
+	if (!isHex(typeBytes)) {
+		throw new Error('input is not a valid hex string');
+	}
+
+	let { cursor, tag } = parse(typeBytes, 0);
+
+	if (cursor !== typeBytes.length) {
+		throw new Error(`input is not a valid typeBytes`);
+	}
+
+	if (tag == undefined) {
+		throw new Error(`format type error, please check version`);
+	}
+
+	return tag;
+};
+
+const encode = (tag: Tag, data: any) => {
+	const paramTypes = [];
+	const parameters = [];
+
+	paramTypes.push(tag.getParamTypes());
+	parameters.push(tag.getParameters(data));
+
+	const coder = new AbiCoder();
+
+	// console.log('paramTypes', paramTypes);
+	// console.dir(parameters, { depth: null });
+
+	return coder.encode(paramTypes, parameters);
+};
+
+// {cursor: number, tag: Tag}
+const parse = (
+	typeBytes: string,
+	index: number
+): { cursor: number; tag: Tag | undefined } => {
+	let cursor = 0;
+	let tag: Tag | undefined = undefined;
+
+	let typeFlag = readByte(typeBytes, index);
+	switch (typeFlag) {
+		case TagType.INT:
+			tag = new Int(typeBytes, index, false);
+			break;
+		case TagType.UINT:
+			tag = new Uint(typeBytes, index, false);
+			break;
+		case TagType.BOOL:
+			tag = new Bool(typeBytes, index, false);
+			break;
+		case TagType.STRING:
+			tag = new String(typeBytes, index, false);
+			break;
+		case TagType.ARRAY:
+			tag = new Array(typeBytes, index, false);
+			break;
+		case TagType.FL_ARRAY:
+			tag = new FixedLengthArray(typeBytes, index, false);
+			break;
+		case TagType.TUPLE:
+			tag = new Tuple(typeBytes, index, false);
+			break;
+		case TagType.ADDRESS:
+			tag = new Address(typeBytes, index, false);
+			break;
+		case TagType.FL_BYTES:
+			tag = new FixedLengthBytes(typeBytes, index, false);
+			break;
+		case TagType.BYTES:
+			tag = new Bytes(typeBytes, index, false);
+			break;
+		default:
+			break;
+	}
+	if (tag != undefined && tag.cursor != undefined) {
+		// // console.log('cursor', tag)
+		cursor = tag.cursor;
+	}
+
+	return {
+		cursor,
+		tag
+	};
+};
+
+parserHolder.setParser(parse);
+
+namespace DIDTag {
+	export type TagParser = Tag;
+
+	export type TagParserType = TagType;
+
+	export type TagParserBase = TagBase;
+
+	export type TagParserBox = Box;
+
+	export type ABITypeProviderHolder = ProviderHolder;
+
+	isHex;
+
+	readByte;
+
+	read2Byte;
+
+	export const doFormatType = (typeBytes: string): TagParser => {
+		return formatType(typeBytes);
+	};
+
+	export const doEncode = (tag: TagParser, data: any) => {
+		return encode(tag, data);
+	};
+
+	export const TagValueTypeInt = Int;
+
+	export const TagValueTypeUint = Uint;
+
+	export const TagValueTypeBool = Bool;
+
+	export const TagValueTypeArray = Array;
+
+	export const TagValueTypeString = String;
+
+	export const TagValueTypeFlarray = FixedLengthArray;
+
+	export const TagValueTypeTuple = Tuple;
+
+	export const TagValueTypeAddress = Address;
+
+	export const TagValueTypeFlbytes = FixedLengthBytes;
+
+	export const TagValueTypeBytes = Bytes;
+}
+
+export default DIDTag;

package/src/tag/int.ts

@@ -0,0 +1,51 @@
+import { Tag, TagBase, ProviderHolder } from './tag';
+import { ethers } from 'ethers';
+import ABITypeABI from '../abi/ABITypeABI';
+export class Int extends TagBase {
+	formatType(typeBytes: any, index: number): number {
+		let bit = parseInt(typeBytes, 16);
+		bit = bit * 2 * 2 * 2;
+		if (bit < 8 || bit % 8 !== 0 || bit > 256) {
+			throw new Error(`input is not a valid int type`);
+		}
+		this.boxData = {
+			length: bit
+		};
+		return index + 4;
+	}
+
+	getAbiTypeString(): string {
+		return `int${this.boxData.length}`;
+	}
+
+	setSize = (size: number) => {
+		this.boxData.size = size;
+	};
+
+	getAbiType = (providerHolder: ProviderHolder) =>
+		new Promise<void>(async (resolve, reject) => {
+			const c = new ethers.Contract(
+				providerHolder.contractAbiType,
+				ABITypeABI.abi,
+				providerHolder.getProvider()
+			);
+
+			const resp = await c.intT(this.boxData.size);
+			// console.log('getAbiType', 'int', resp);
+			resolve(resp);
+		});
+
+	getParamTypes(): string {
+		return `int${this.boxData.length}`;
+	}
+
+	getParameters(data: any) {
+		return data;
+	}
+
+	doHydration(d: any) {
+		return (d as BigInt).toString();
+	}
+}
+
+export default Int;

package/src/tag/string.ts

@@ -0,0 +1,38 @@
+import { Tag, TagBase, ProviderHolder } from './tag';
+import { ethers } from 'ethers';
+import ABITypeABI from '../abi/ABITypeABI';
+export class String extends TagBase {
+	name: string = 'string';
+
+	formatType(typeBytes: any, index: number): number {
+		this.name = 'string';
+		return index + 2;
+	}
+
+	getAbiTypeString(): string {
+		return 'string';
+	}
+
+	getAbiType = (providerHolder: ProviderHolder) =>
+		new Promise<void>(async (resolve, reject) => {
+			const c = new ethers.Contract(
+				providerHolder.contractAbiType,
+				ABITypeABI.abi,
+				providerHolder.getProvider()
+			);
+
+			const resp = await c.stringT();
+			// console.log('getAbiType', 'string', resp);
+			resolve(resp);
+		});
+
+	getParamTypes(): string {
+		return 'string';
+	}
+
+	getParameters(data: any) {
+		return data;
+	}
+}
+
+export default String;

package/src/tag/tag.ts

@@ -0,0 +1,229 @@
+import { ethers } from 'ethers';
+
+export enum TagType {
+	INT = '00',
+	UINT = '01',
+	BOOL = '02',
+	STRING = '03',
+	ARRAY = '04',
+	FL_ARRAY = '05',
+	TUPLE = '06',
+	ADDRESS = '07',
+	FL_BYTES = '08',
+	BYTES = '09'
+}
+
+export const needLength = (type: TagType) => {
+	return type == TagType.INT;
+};
+
+export const read2Byte = (hex: string, index: number) => {
+	return hex.substring(index, index + 4);
+};
+
+export const readByte = (hex: string, index: number) => {
+	return hex.substring(index, index + 2);
+};
+
+export interface ProviderHolder {
+	contractAbiType: string;
+	getProvider(): ethers.JsonRpcProvider;
+}
+
+export interface Tag {
+	formatType(typeBytes: any, index: number | undefined): number;
+
+	parseValue(data: any): any;
+
+	getParamTypes(): string;
+
+	getParameters(data: any): any;
+
+	cursor: number | undefined;
+
+	type: TagType | undefined;
+
+	boxData: any;
+
+	fieldName: string | undefined;
+}
+
+export type Parse = (
+	typeBytes: string,
+	index: number
+) => { cursor: number; tag: Tag | undefined };
+export class ParserHolder {
+	parse: Parse | undefined = undefined;
+
+	setParser = (parse: Parse) => {
+		this.parse = parse;
+	};
+}
+
+export const parserHolder = new ParserHolder();
+
+export abstract class TagBase implements Tag {
+	type: TagType | undefined;
+	cursor: number | undefined;
+	boxData: any;
+	fieldName: string | undefined;
+
+	abstract getAbiType(providerHolder: ProviderHolder): Promise<any>;
+
+	abstract getParamTypes(): string;
+
+	abstract getParameters(data: any): any; // 包装类负责解析对应字段,并验证字段是否存在, 基础类型负责验证数据格式正确性
+
+	getFieldNames = (): string[][] => {
+		if (this instanceof Box) {
+			let a: string[][] = this.getFieldName();
+			return a;
+		} else {
+			let a: string[][] = [];
+			return a;
+		}
+	};
+
+	typeName = (): string => {
+		switch (this.type) {
+			case TagType.INT:
+				return `int${this.boxData.length}`;
+			case TagType.UINT:
+				return `uint${this.boxData.length}`;
+			case TagType.BOOL:
+				return `bool`;
+			case TagType.STRING:
+				return 'string';
+			case TagType.ARRAY:
+				return `array<${this.boxData.arrayTag.typeName()}>`;
+			case TagType.FL_ARRAY:
+				return `array<${this.boxData.arrayTag.typeName()}>(${
+					this.boxData.length
+				})`;
+			case TagType.TUPLE:
+				return 'tuple';
+			case TagType.ADDRESS:
+				return 'address';
+			case TagType.FL_BYTES:
+				return `bytes${this.boxData.length}`;
+			case TagType.BYTES:
+				return 'bytes';
+			default:
+				return 'error';
+		}
+	};
+
+	constructor(
+		typeBytes: string | undefined,
+		index: number | undefined,
+		builder: boolean
+	) {
+		this.boxData = {};
+
+		if (builder) {
+		} else {
+			if (typeBytes == undefined || index == undefined) {
+				throw new Error(
+					"constructor value error, typeBytes and index can't be undefined"
+				);
+			}
+
+			let typeFlag = readByte(typeBytes, index);
+
+			switch (typeFlag) {
+				case TagType.INT:
+					this.type = TagType.INT;
+					this.cursor = this.formatType(
+						readByte(typeBytes, index + 2),
+						index
+					);
+					break;
+				case TagType.UINT:
+					this.type = TagType.UINT;
+					this.cursor = this.formatType(
+						readByte(typeBytes, index + 2),
+						index
+					);
+					break;
+				case TagType.BOOL:
+					this.type = TagType.BOOL;
+					this.cursor = this.formatType(typeBytes, index);
+					break;
+				case TagType.STRING:
+					this.type = TagType.STRING;
+					this.cursor = this.formatType(typeBytes, index);
+					break;
+				case TagType.ARRAY:
+					this.type = TagType.ARRAY;
+					this.cursor = this.formatType(typeBytes, index);
+					break;
+				case TagType.FL_ARRAY:
+					this.type = TagType.FL_ARRAY;
+					this.cursor = this.formatType(typeBytes, index);
+					break;
+				case TagType.TUPLE:
+					this.type = TagType.TUPLE;
+					this.cursor = this.formatType(typeBytes, index);
+					break;
+				case TagType.ADDRESS:
+					this.type = TagType.ADDRESS;
+					this.cursor = this.formatType(typeBytes, index);
+					break;
+				case TagType.FL_BYTES:
+					this.type = TagType.FL_BYTES;
+					this.cursor = this.formatType(typeBytes, index);
+					break;
+				case TagType.BYTES:
+					this.type = TagType.BYTES;
+					this.cursor = this.formatType(typeBytes, index);
+					break;
+
+				default:
+					throw new Error('formatType error');
+					break;
+			}
+			// // console.log('cursor', this)
+		}
+	}
+
+	abstract formatType(typeBytes: any, index: number | undefined): number;
+
+	parseValue(data: any) {
+		let abiCoder = new ethers.AbiCoder();
+
+		// // console.log('AbiTypeString', this.getAbiTypeString());
+		// // console.dir(this, { depth: null });
+		return abiCoder.decode([this.getAbiTypeString()], data, false);
+	}
+
+	hydration(data: any) {
+		let d = this.parseValue(data);
+
+		return this.doHydration(d[0]);
+	}
+
+	doHydration(d: any) {
+		return d;
+	}
+
+	abstract getAbiTypeString(): string;
+}
+
+export abstract class Box extends TagBase {
+	abstract formatType(typeBytes: any, index: number | undefined): number;
+
+	abstract setFieldNames(names: string[] | string[][], index: number): number;
+
+	formatChild(
+		typeBytes: any,
+		index: number
+	): { cursor: number; tag: Tag | undefined } {
+		if (!parserHolder.parse) throw new Error('not found parse');
+
+		return parserHolder.parse(typeBytes, index);
+	}
+
+	abstract getFieldName(): string[][];
+}
+
+export default Tag;

package/src/tag/tuple.ts

@@ -0,0 +1,193 @@
+import { Tag, TagBase, Box, read2Byte, ProviderHolder } from './tag';
+import { ethers } from 'ethers';
+import ABITypeABI from '../abi/ABITypeABI';
+export class Tuple extends Box {
+	constructor(
+		typeBytes: string | undefined,
+		index: number | undefined,
+		builder: boolean
+	) {
+		super(typeBytes, index, builder);
+	}
+
+	formatType(typeBytes: any, index: number): number {
+		let lt = read2Byte(typeBytes, index + 2);
+		let length = parseInt(lt, 16);
+
+		let parsedLen = index + 6;
+		let tagArr: Tag[] = [];
+		for (let k = 0; k < length; k++) {
+			let { cursor, tag } = this.formatChild(typeBytes, parsedLen);
+			parsedLen = cursor;
+			if (tag == undefined) {
+				throw new Error('formatType error in tuple');
+			}
+			tagArr.push(tag);
+		}
+
+		this.boxData = {
+			tags: tagArr as TagBase[]
+		};
+		// this.boxData.tags = tagArr as TagBase[]
+
+		// console.log('this.boxData', this.boxData);
+		return parsedLen;
+	}
+
+	getAbiTypeString(): string {
+		let str = '';
+		for (const tag of this.boxData.tags) {
+			// // console.log (tag)
+			if (tag.fieldName == undefined) {
+				str = str + ',' + tag.getAbiTypeString();
+			} else {
+				str = str + ',' + `${tag.getAbiTypeString()} ${tag.fieldName}`;
+			}
+		}
+
+		return `tuple(${str.substring(1)})`;
+	}
+
+	setFieldNames(names: string[] | string[][], index: number): number {
+		// console.log('setFieldNames');
+		// console.log(names);
+		// console.log(this.boxData.tags);
+
+		let fieldNames = names[index];
+		index++;
+
+		let indexInBox = 0;
+		for (const tag of this.boxData.tags) {
+			tag.fieldName = fieldNames[indexInBox];
+			indexInBox++;
+
+			// console.log('set FieldNames');
+			// console.log(tag);
+			// console.log('indexInBox', indexInBox);
+
+			if (tag instanceof Box) {
+				// // console.log('in Box')
+				// // console.log(names [index])
+				// // console.log(tag)
+				// // console.log(names)
+
+				// fix build
+				// if (indexInBox >= names.length) {
+				//     indexInBox = index
+				// }
+
+				tag.setFieldNames(names, indexInBox);
+				index++;
+			}
+			// if (tag instanceof Box) {
+			//     // console.log(tag)
+			//     // console.log(this)
+			//     throw new Error('tuple not support 2 level and more')
+			// }
+		}
+		return index;
+	}
+
+	doHydration(d: any) {
+		// console.log('doHydration');
+		// console.log(d);
+		// console.log(this);
+
+		let i = 0;
+		let data: { [key: string]: any } = {};
+		for (const tag of this.boxData.tags) {
+			// console.log(tag);
+			// console.log(d);
+			// console.log(i);
+
+			data[`${tag.fieldName as string}`] = tag.doHydration(d[i]);
+			i++;
+		}
+		return data;
+	}
+
+	setField(name: string, type: TagBase) {
+		type.fieldName = name;
+
+		if (this.boxData.tags == undefined) {
+			this.boxData.tags = [];
+		}
+		this.boxData.tags.push(type);
+	}
+
+	getAbiType = (providerHolder: ProviderHolder) =>
+		new Promise<void>(async (resolve, reject) => {
+			const c = new ethers.Contract(
+				providerHolder.contractAbiType,
+				ABITypeABI.abi,
+				providerHolder.getProvider()
+			);
+
+			let arr: string = '0x';
+			for (const tag of this.boxData.tags) {
+				let r = await tag.getAbiType(providerHolder);
+				arr += r.substring(2);
+			}
+
+			// console.log('arr', arr);
+			const resp = await c.tupleT(arr);
+			// console.log('getAbiType', 'Tuple', resp);
+			resolve(resp);
+		});
+
+	getFieldName(): string[][] {
+		let arr: string[][] = [];
+		let names: string[] = [];
+		for (const tag of this.boxData.tags) {
+			let tagFieldNames = tag.getFieldNames();
+			if (tagFieldNames.length > 0) {
+				arr.push(...tagFieldNames);
+				// arr = Object.assign(arr, tagFieldNames)
+			}
+			names.push(tag.fieldName as string);
+		}
+
+		let arr2: string[][] = [];
+		arr2.push(names);
+		// arr2 = Object.assign(arr2, arr)
+		arr2.push(...arr);
+
+		// console.log('arr', arr2);
+
+		return arr2;
+	}
+
+	getParamTypes(): string {
+		let paramTypes = 'tuple(';
+
+		let i = 0;
+		for (const t of this.boxData.tags) {
+			paramTypes += t.getParamTypes();
+
+			i++;
+			if (i >= this.boxData.tags.length) {
+			} else {
+				paramTypes += ',';
+			}
+		}
+		paramTypes += ')';
+
+		return paramTypes;
+	}
+
+	getParameters(data: any) {
+		const values = [];
+		let i = 0;
+		// console.log('data', data);
+		// console.log('this.boxData.tags', this.boxData.tags);
+		for (const t of this.boxData.tags) {
+			// console.log(t, t.fieldName, data[t.fieldName]);
+
+			values.push(t.getParameters(data[t.fieldName]));
+			i++;
+		}
+		return values;
+	}
+}
+
+export default Tuple;