@futpib/parser 1.0.1 → 1.0.3

package/src/dalvikExecutable.ts

@@ -0,0 +1,282 @@
+
+export type DalvikExecutableAccessFlags = {
+	public: boolean;
+	private: boolean;
+	protected: boolean;
+	static: boolean;
+	final: boolean;
+	synchronized: boolean;
+	volatile: boolean;
+	bridge: boolean;
+	transient: boolean;
+	varargs: boolean;
+	native: boolean;
+	interface: boolean;
+	abstract: boolean;
+	strict: boolean;
+	synthetic: boolean;
+	annotation: boolean;
+	enum: boolean;
+	constructor: boolean;
+	declaredSynchronized: boolean;
+};
+
+export function dalvikExecutableAccessFlagsDefault(): DalvikExecutableAccessFlags {
+	return {
+		public: false,
+		private: false,
+		protected: false,
+		static: false,
+		final: false,
+		synchronized: false,
+		volatile: false,
+		bridge: false,
+		transient: false,
+		varargs: false,
+		native: false,
+		interface: false,
+		abstract: false,
+		strict: false,
+		synthetic: false,
+		annotation: false,
+		enum: false,
+		constructor: false,
+		declaredSynchronized: false,
+	};
+}
+
+export type DalvikExecutableEncodedValue =
+	| { type: 'byte'; value: number }
+	| { type: 'short'; value: number }
+	| { type: 'char'; value: number }
+	| { type: 'int'; value: number }
+	| { type: 'long'; value: bigint }
+	| { type: 'float'; value: number }
+	| { type: 'double'; value: number }
+	| { type: 'methodType'; value: DalvikExecutablePrototype }
+	| { type: 'methodHandle'; value: number }
+	| { type: 'string'; value: string }
+	| { type: 'type'; value: string }
+	| { type: 'field'; value: DalvikExecutableField }
+	| { type: 'method'; value: DalvikExecutableMethod }
+	| { type: 'enum'; value: DalvikExecutableField }
+	| { type: 'array'; value: DalvikExecutableEncodedValue[] }
+	| { type: 'annotation'; value: DalvikExecutableAnnotation }
+	// eslint-disable-next-line @typescript-eslint/no-restricted-types
+	| { type: 'null'; value: null }
+	| { type: 'boolean'; value: boolean };
+
+type DalvikExecutableTry = {
+	startAddress: number;
+	instructionCount: number;
+	handler: DalvikExecutableEncodedCatchHandler;
+};
+
+type DalvikExecutableEncodedTypeAddressPair = {
+	type: string;
+	address: number;
+};
+
+type DalvikExecutableEncodedCatchHandler = {
+	handlers: DalvikExecutableEncodedTypeAddressPair[];
+	catchAllAddress: undefined | number;
+};
+
+export type DalvikExecutableCode<Instructions> = {
+	registersSize: number;
+	insSize: number;
+	outsSize: number;
+	debugInfo: undefined | DalvikExecutableDebugInfo;
+	instructions: Instructions;
+	tries: DalvikExecutableTry[];
+};
+
+type DalvikExecutableDebugByteCodeValue =
+	| {
+		type: 'advancePc';
+		addressDiff: number;
+	}
+	| {
+		type: 'advanceLine';
+		lineDiff: number;
+	}
+	| {
+		type: 'startLocal';
+		registerNum: number;
+		name: undefined | string;
+		type_: undefined | string;
+	}
+	| {
+		type: 'startLocalExtended';
+		registerNum: number;
+		name: undefined | string;
+		type_: undefined | string;
+		signature: undefined | string;
+	}
+	| {
+		type: 'endLocal';
+		registerNum: number;
+	}
+	| {
+		type: 'restartLocal';
+		registerNum: number;
+	}
+	| {
+		type: 'setPrologueEnd';
+	}
+	| {
+		type: 'setEpilogueBegin';
+	}
+	| {
+		type: 'setFile';
+		name: undefined | string;
+	}
+	| {
+		type: 'special';
+		value: number;
+	}
+;
+
+type DalvikExecutableDebugByteCode = DalvikExecutableDebugByteCodeValue[];
+
+export type DalvikExecutableDebugInfo = {
+	lineStart: number;
+	parameterNames: Array<undefined | string>;
+	bytecode: DalvikExecutableDebugByteCode;
+};
+
+type DalvikExecutableAnnotationItemVisibility =
+	| 'build'
+	| 'runtime'
+	| 'system'
+;
+
+type DalvikExecutableAnnotationElement = {
+	name: string;
+	value: DalvikExecutableEncodedValue;
+};
+
+export type DalvikExecutableAnnotation = {
+	visibility: DalvikExecutableAnnotationItemVisibility;
+	type: string;
+	elements: DalvikExecutableAnnotationElement[];
+};
+
+export type DalvikExecutablePrototype = {
+	shorty: string;
+	returnType: string;
+	parameters: string[];
+};
+
+export type DalvikExecutableField = {
+	class: string;
+	type: string;
+	name: string;
+};
+
+export function isDalvikExecutableField(x: unknown): x is DalvikExecutableField {
+	return (
+		x !== null
+		&& typeof x === 'object'
+		&& 'class' in x
+		&& 'type' in x
+		&& 'name' in x
+		&& typeof (x as DalvikExecutableField).class === 'string'
+		&& typeof (x as DalvikExecutableField).type === 'string'
+		&& typeof (x as DalvikExecutableField).name === 'string'
+	);
+}
+
+export function dalvikExecutableFieldEquals(a: DalvikExecutableField, b: DalvikExecutableField): boolean {
+	return (
+		a.class === b.class
+		&& a.type === b.type
+		&& a.name === b.name
+	);
+}
+
+export type DalvikExecutableFieldWithAccess = {
+	field: DalvikExecutableField;
+	accessFlags: DalvikExecutableAccessFlags;
+};
+
+export type DalvikExecutableMethod = {
+	class: string;
+	prototype: DalvikExecutablePrototype;
+	name: string;
+};
+
+export function isDalvikExecutableMethod(x: unknown): x is DalvikExecutableMethod {
+	return (
+		x !== null
+		&& typeof x === 'object'
+		&& 'class' in x
+		&& 'prototype' in x
+		&& 'name' in x
+		&& typeof (x as DalvikExecutableMethod).class === 'string'
+		&& typeof (x as DalvikExecutableMethod).prototype === 'object'
+		&& typeof (x as DalvikExecutableMethod).name === 'string'
+	);
+}
+
+export function dalvikExecutableMethodEquals(a: DalvikExecutableMethod, b: DalvikExecutableMethod): boolean {
+	return (
+		a.class === b.class
+		&& a.name === b.name
+		&& a.prototype.shorty === b.prototype.shorty
+		&& a.prototype.returnType === b.prototype.returnType
+		&& a.prototype.parameters.length === b.prototype.parameters.length
+		&& a.prototype.parameters.every((v, i) => v === b.prototype.parameters[i])
+	);
+}
+
+export type DalvikExecutableMethodWithAccess<Instructions> = {
+	method: DalvikExecutableMethod;
+	accessFlags: DalvikExecutableAccessFlags;
+	code: undefined | DalvikExecutableCode<Instructions>;
+};
+
+export type DalvikExecutableClassFieldAnnotation = {
+	field: DalvikExecutableField;
+	annotations: undefined | DalvikExecutableAnnotation[];
+};
+
+export type DalvikExecutableClassMethodAnnotation = {
+	method: DalvikExecutableMethod;
+	annotations: DalvikExecutableAnnotation[];
+};
+
+export type DalvikExecutableClassParameterAnnotation = {
+	method: DalvikExecutableMethod;
+	annotations: DalvikExecutableAnnotation[][];
+};
+
+export type DalvikExecutableClassAnnotations = {
+	classAnnotations: DalvikExecutableAnnotation[];
+	fieldAnnotations: DalvikExecutableClassFieldAnnotation[];
+	methodAnnotations: DalvikExecutableClassMethodAnnotation[];
+	parameterAnnotations: DalvikExecutableClassParameterAnnotation[];
+};
+
+export type DalvikExecutableClassData<Instructions> = {
+	staticFields: DalvikExecutableFieldWithAccess[];
+	instanceFields: DalvikExecutableFieldWithAccess[];
+	directMethods: Array<DalvikExecutableMethodWithAccess<Instructions>>;
+	virtualMethods: Array<DalvikExecutableMethodWithAccess<Instructions>>;
+};
+
+export type DalvikExecutableClassDefinition<Instructions> = {
+	class: string;
+	accessFlags: DalvikExecutableAccessFlags;
+	superclass: string;
+	interfaces: string[];
+	sourceFile: undefined | string;
+	annotations: undefined | DalvikExecutableClassAnnotations;
+	staticValues: DalvikExecutableEncodedValue[];
+	classData: undefined | DalvikExecutableClassData<Instructions>;
+};
+
+export type DalvikExecutable<Instructions> = {
+	classDefinitions: Array<DalvikExecutableClassDefinition<Instructions>>;
+	link: undefined | Uint8Array;
+};

package/src/dalvikExecutableParser/stringSyntaxParser.ts

@@ -0,0 +1,145 @@
+import invariant from 'invariant';
+import { type Parser, setParserName } from '../parser.js';
+import { type ParserContext } from '../parserContext.js';
+import { promiseCompose } from '../promiseCompose.js';
+import { createSeparatedArrayParser } from '../separatedArrayParser.js';
+import { createExactSequenceParser } from '../exactSequenceParser.js';
+import { createUnionParser } from '../unionParser.js';
+import { createTupleParser } from '../tupleParser.js';
+import { createArrayParser } from '../arrayParser.js';
+
+export const smaliSimpleNameParser: Parser<string, string> = async (parserContext: ParserContext<string, string>) => {
+	const characters: string[] = [];
+
+	while (true) {
+		const character = await parserContext.peek(0);
+
+		parserContext.invariant(character !== undefined, 'Unexpected end of input');
+
+		invariant(character !== undefined, 'Unexpected end of input');
+
+		if (
+			(
+				character >= 'a' && character <= 'z'
+			)
+			|| (
+				character >= 'A' && character <= 'Z'
+			)
+			|| (
+				character >= '0' && character <= '9'
+			)
+			|| (
+				character === ' '
+			)
+			|| (
+				character === '$'
+			)
+			|| (
+				character === '-'
+			)
+				|| (
+					character === '_'
+				)
+				|| (
+					character === '\u00A0'
+				)
+				|| (
+					character >= '\u00A1' && character <= '\u1FFF'
+				)
+				|| (
+					character >= '\u2000' && character <= '\u200A'
+				)
+				|| (
+					character >= '\u2010' && character <= '\u2027'
+				)
+				|| (
+					character === '\u202F'
+				)
+				|| (
+					character >= '\u2030' && character <= '\uD7FF'
+				)
+				|| (
+					character >= '\uE000' && character <= '\uFFEF'
+				)
+				|| (
+					character >= '\uD800' && character <= '\uDBFF'
+				)
+		) {
+			parserContext.skip(1);
+
+			characters.push(character);
+
+			continue;
+		}
+
+		parserContext.invariant(characters.length > 0, 'Expected at least one character');
+
+		break;
+	}
+
+	return characters.join('');
+};
+
+setParserName(smaliSimpleNameParser, 'smaliSimpleNameParser');
+
+export const smaliMemberNameParser: Parser<string, string> = createUnionParser([
+	smaliSimpleNameParser,
+	promiseCompose(
+		createTupleParser([
+			createExactSequenceParser('<'),
+			smaliSimpleNameParser,
+			createExactSequenceParser('>'),
+		]),
+		strings => strings.join(''),
+	),
+]);
+
+setParserName(smaliMemberNameParser, 'smaliMemberNameParser');
+
+const smaliFullClassNameParser: Parser<string, string> = promiseCompose(
+	createSeparatedArrayParser(
+		smaliMemberNameParser,
+		createExactSequenceParser('/'),
+	),
+	pathSegments => pathSegments.join('/'),
+);
+
+setParserName(smaliFullClassNameParser, 'smaliFullClassNameParser');
+
+const smaliNonArrayFieldTypeDescriptorParser: Parser<string, string> = createUnionParser([
+	createExactSequenceParser('Z'),
+	createExactSequenceParser('B'),
+	createExactSequenceParser('S'),
+	createExactSequenceParser('C'),
+	createExactSequenceParser('I'),
+	createExactSequenceParser('J'),
+	createExactSequenceParser('F'),
+	createExactSequenceParser('D'),
+	promiseCompose(
+		createTupleParser([
+			createExactSequenceParser('L'),
+			smaliFullClassNameParser,
+			createExactSequenceParser(';'),
+		]),
+		strings => strings.join(''),
+	),
+]);
+
+setParserName(smaliNonArrayFieldTypeDescriptorParser, 'smaliNonArrayFieldTypeDescriptorParser');
+
+const smaliFieldTypeDescriptorParser: Parser<string, string> = promiseCompose(
+	createTupleParser([
+		createArrayParser(createExactSequenceParser('[')),
+		smaliNonArrayFieldTypeDescriptorParser,
+	]),
+	([ strings, string ]) => strings.join('') + string,
+);
+
+setParserName(smaliFieldTypeDescriptorParser, 'smaliFieldTypeDescriptorParser');
+
+export const smaliTypeDescriptorParser: Parser<string, string> = createUnionParser([
+	createExactSequenceParser('V'),
+	smaliFieldTypeDescriptorParser,
+]);
+
+setParserName(smaliTypeDescriptorParser, 'smaliTypeDescriptorParser');

package/src/dalvikExecutableParser/typeParsers.ts

@@ -0,0 +1,74 @@
+import { createElementParser } from '../elementParser.js';
+import { createFixedLengthSequenceParser } from '../fixedLengthSequenceParser.js';
+import { uleb128NumberParser } from '../leb128Parser.js';
+import { type Parser } from '../parser.js';
+import { parserCreatorCompose } from '../parserCreatorCompose.js';
+import { promiseCompose } from '../promiseCompose.js';
+
+export const uleb128p1NumberParser: Parser<number, Uint8Array> = async parserContext => {
+	const value = await uleb128NumberParser(parserContext);
+	return value - 1;
+};
+
+export const ubyteParser: Parser<number, Uint8Array> = createElementParser();
+
+export const byteParser: Parser<number, Uint8Array> = promiseCompose(
+	ubyteParser,
+	ubyte => ubyte > 127 ? ubyte - 256 : ubyte,
+);
+
+export const shortParser: Parser<number, Uint8Array> = promiseCompose(
+	createFixedLengthSequenceParser<Uint8Array>(2),
+	uint8Array => {
+		const buffer = Buffer.from(uint8Array);
+		return buffer.readInt16LE(0);
+	},
+);
+
+export const ushortParser: Parser<number, Uint8Array> = promiseCompose(
+	createFixedLengthSequenceParser<Uint8Array>(2),
+	uint8Array => {
+		const buffer = Buffer.from(uint8Array);
+		return buffer.readUInt16LE(0);
+	},
+);
+
+export const createExactUshortParser = (expectedValue: number): Parser<number, Uint8Array> => parserCreatorCompose(
+	() => ushortParser,
+	ushortValue => async parserContext => {
+		parserContext.invariant(ushortValue === expectedValue, `Expected ushort value ${expectedValue}, got ${ushortValue}`);
+		return ushortValue;
+	},
+)();
+
+export const intParser: Parser<number, Uint8Array> = promiseCompose(
+	createFixedLengthSequenceParser<Uint8Array>(4),
+	uint8Array => {
+		const buffer = Buffer.from(uint8Array);
+		return buffer.readInt32LE(0);
+	},
+);
+
+export const uintParser: Parser<number, Uint8Array> = promiseCompose(
+	createFixedLengthSequenceParser<Uint8Array>(4),
+	uint8Array => {
+		const buffer = Buffer.from(uint8Array);
+		return buffer.readUInt32LE(0);
+	},
+);
+
+export const longParser: Parser<bigint, Uint8Array> = promiseCompose(
+	createFixedLengthSequenceParser<Uint8Array>(8),
+	uint8Array => {
+		const buffer = Buffer.from(uint8Array);
+		return buffer.readBigInt64LE(0);
+	},
+);
+
+export const ulongParser: Parser<bigint, Uint8Array> = promiseCompose(
+	createFixedLengthSequenceParser<Uint8Array>(8),
+	uint8Array => {
+		const buffer = Buffer.from(uint8Array);
+		return buffer.readBigUInt64LE(0);
+	},
+);

package/src/dalvikExecutableParser/typedNumbers.ts

@@ -0,0 +1,57 @@
+import { type Newtype, iso } from 'newtype-ts';
+
+export type IndexIntoStringIds = {} & Newtype<{ readonly IndexIntoStringIds: unique symbol }, number>;
+export const isoIndexIntoStringIds = iso<IndexIntoStringIds>();
+
+export type IndexIntoTypeIds = {} & Newtype<{ readonly IndexIntoTypeIds: unique symbol }, number>;
+export const isoIndexIntoTypeIds = iso<IndexIntoTypeIds>();
+
+export type IndexIntoPrototypeIds = {} & Newtype<{ readonly IndexIntoPrototypeIds: unique symbol }, number>;
+export const isoIndexIntoPrototypeIds = iso<IndexIntoPrototypeIds>();
+
+export type IndexIntoFieldIds = {} & Newtype<{ readonly IndexIntoFieldIds: unique symbol }, number>;
+export const isoIndexIntoFieldIds = iso<IndexIntoFieldIds>();
+
+export type IndexIntoMethodIds = {} & Newtype<{ readonly IndexIntoMethodIds: unique symbol }, number>;
+export const isoIndexIntoMethodIds = iso<IndexIntoMethodIds>();
+
+export type OffsetToStringDataItem = {} & Newtype<{ readonly OffsetToStringDataItem: unique symbol }, number>;
+export const isoOffsetToStringDataItem = iso<OffsetToStringDataItem>();
+
+export type OffsetToTypeList = {} & Newtype<{ readonly OffsetToTypeList: unique symbol }, number>;
+export const isoOffsetToTypeList = iso<OffsetToTypeList>();
+
+export type OffsetToAnnotationsDirectoryItem = {} & Newtype<{ readonly OffsetToAnnotationsDirectoryItem: unique symbol }, number>;
+export const isoOffsetToAnnotationsDirectoryItem = iso<OffsetToAnnotationsDirectoryItem>();
+
+export type OffsetToAnnotationSetItem = {} & Newtype<{ readonly OffsetToAnnotationSetItem: unique symbol }, number>;
+export const isoOffsetToAnnotationSetItem = iso<OffsetToAnnotationSetItem>();
+
+export type OffsetToAnnotationSetRefListItem = {} & Newtype<{ readonly OffsetToAnnotationSetRefListItem: unique symbol }, number>;
+export const isoOffsetToAnnotationSetRefListItem = iso<OffsetToAnnotationSetRefListItem>();
+
+export type OffsetToClassDataItem = {} & Newtype<{ readonly OffsetToClassDataItem: unique symbol }, number>;
+export const isoOffsetToClassDataItem = iso<OffsetToClassDataItem>();
+
+export type OffsetToEncodedArrayItem = {} & Newtype<{ readonly OffsetToEncodedArrayItem: unique symbol }, number>;
+export const isoOffsetToEncodedArrayItem = iso<OffsetToEncodedArrayItem>();
+
+export type OffsetToCodeItem = {} & Newtype<{ readonly OffsetToCodeItem: unique symbol }, number>;
+export const isoOffsetToCodeItem = iso<OffsetToCodeItem>();
+
+export type OffsetToDebugInfoItem = {} & Newtype<{ readonly OffsetToDebugInfoItem: unique symbol }, number>;
+export const isoOffsetToDebugInfoItem = iso<OffsetToDebugInfoItem>();
+
+export type OffsetToAnnotationItem = {} & Newtype<{ readonly OffsetToAnnotationItem: unique symbol }, number>;
+export const isoOffsetToAnnotationItem = iso<OffsetToAnnotationItem>();
+
+export type OffsetFromEncodedCatchHandlerListToEncodedCatchHandler = {} & Newtype<{ readonly OffsetFromEncodedCatchHandlerListToEncodedCatchHandler: unique symbol }, number>;
+export const isoOffsetFromEncodedCatchHandlerListToEncodedCatchHandler = iso<OffsetFromEncodedCatchHandlerListToEncodedCatchHandler>();
+
+export type TypedNumberArray<IndexType, ValueType> = {
+	get length(): number;
+	at(index: IndexType): undefined | ValueType;
+	map<NewValueType>(fn: (value: ValueType, index: IndexType) => NewValueType): TypedNumberArray<IndexType, NewValueType>;
+	[Symbol.iterator](): IterableIterator<ValueType>;
+} & Newtype<{ readonly TypedNumberArray: unique symbol }, ValueType[]>;
+export const getIsoTypedNumberArray = <IndexType, ValueType>() => iso<TypedNumberArray<IndexType, ValueType>>();

package/src/dalvikExecutableParser.test.ts

@@ -0,0 +1,89 @@
+import test from 'ava';
+import { runParser } from './parser.js';
+import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
+import { dalvikExecutableParser, dalvikExecutableWithRawInstructionsParser } from './dalvikExecutableParser.js';
+import { fetchCid } from './fetchCid.js';
+
+const dexWithRawInstructionsMacro = test.macro({
+	title: (providedTitle, dexCid: string) => providedTitle ?? `dex (with instructions as bytes) ${dexCid}`,
+	async exec(t, dexCid: string, shouldSnapshot: boolean) {
+		const dexStream = await fetchCid(dexCid);
+
+		const actual = await runParser(dalvikExecutableWithRawInstructionsParser, dexStream, uint8ArrayParserInputCompanion, {
+			errorJoinMode: 'all',
+		});
+
+		if (shouldSnapshot) {
+			t.snapshot(actual);
+		} else {
+			// Console.dir(actual, { depth: null });
+			t.pass();
+		}
+	},
+});
+
+test.serial(dexWithRawInstructionsMacro, 'bafkreibb4gsprc3fvmnyqx6obswvm7e7wngnfj64gz65ey72r7xgyzymt4', true);
+test.serial(dexWithRawInstructionsMacro, 'bafybeiebe27ylo53trgitu6fqfbmba43c4ivxj3nt4kumsilkucpbdxtqq', false);
+test.serial(dexWithRawInstructionsMacro, 'bafybeibbupm7uzhuq4pa674rb2amxsenbdaoijigmaf4onaodaql4mh7yy', false);
+test.serial(dexWithRawInstructionsMacro, 'bafybeicb3qajmwy6li7hche2nkucvytaxcyxhwhphmi73tgydjzmyoqoda', false);
+
+type ObjectPath = Array<string | symbol | number>;
+
+function objectWalk(object: unknown, f: (path: ObjectPath, value: unknown) => void, initialPath: ObjectPath = []) {
+	f(initialPath, object);
+
+	if (
+		!object
+		|| typeof object !== 'object'
+	) {
+		return;
+	}
+
+	if (Array.isArray(object)) {
+		for (const [ index, value ] of object.entries()) {
+			objectWalk(value, f, [ ...initialPath, index ]);
+		}
+	} else {
+		for (const [ key, value ] of Object.entries(object)) {
+			objectWalk(value, f, [ ...initialPath, key ]);
+		}
+	}
+}
+
+const dexWithParsedInstructionsMacro = test.macro({
+	title: (providedTitle, dexCid: string) => providedTitle ?? `dex (with parsed instructions) ${dexCid}`,
+	async exec(t, dexCid: string, shouldSnapshot: boolean) {
+		const dexStream = await fetchCid(dexCid);
+
+		debugger;
+
+		const actual = await runParser(dalvikExecutableParser, dexStream, uint8ArrayParserInputCompanion, {
+			errorJoinMode: 'all',
+		});
+
+		debugger;
+
+		objectWalk(actual, path => {
+			const key = path.at(-1);
+
+			if (typeof key !== 'string') {
+				return;
+			}
+
+			t.false(key.endsWith('Offset') && key !== 'branchOffset', 'All offsets should be resolved: ' + path.join('.'));
+			t.false(key.endsWith('Index'), 'All indexes should be resolved: ' + path.join('.'));
+		});
+
+		if (shouldSnapshot) {
+			t.snapshot(actual);
+		} else {
+			// Console.dir(actual, { depth: null });
+			t.pass();
+		}
+	},
+});
+
+test.serial.only(dexWithParsedInstructionsMacro, 'bafkreibb4gsprc3fvmnyqx6obswvm7e7wngnfj64gz65ey72r7xgyzymt4', true);
+test.serial.skip(dexWithParsedInstructionsMacro, 'bafybeiebe27ylo53trgitu6fqfbmba43c4ivxj3nt4kumsilkucpbdxtqq', false);
+test.serial.skip(dexWithParsedInstructionsMacro, 'bafybeibbupm7uzhuq4pa674rb2amxsenbdaoijigmaf4onaodaql4mh7yy', false);
+test.serial.skip(dexWithParsedInstructionsMacro, 'bafybeicb3qajmwy6li7hche2nkucvytaxcyxhwhphmi73tgydjzmyoqoda', false);