@quentinadam/evm-base 0.1.0

package/src/ClientHelper.ts

@@ -0,0 +1,131 @@
+import assert from '@quentinadam/assert';
+import * as z from '@quentinadam/zod';
+import ABI from './ABI.ts';
+import DataEncoder from './DataEncoder.ts';
+import type Log from './Log.ts';
+import type Transaction from './Transaction.ts';
+import type TransactionReceipt from './TransactionReceipt.ts';
+
+export default class ClientHelper {
+  readonly #addressFromBytes: (bytes: Uint8Array<ArrayBuffer>) => string;
+  readonly #bytesFromAddress: (address: string) => Uint8Array<ArrayBuffer>;
+  readonly #deserializeHash: (hash: string) => string;
+  readonly #serializeHash: (hash: string) => string;
+  readonly #dataEncoder: DataEncoder;
+
+  readonly BytesSchema: z.Schema<Uint8Array<ArrayBuffer>> = z.string().transform((string) => {
+    assert(/0x[0-9a-f]*/.test(string));
+    return Uint8Array.fromHex(string.slice(2));
+  });
+
+  readonly HexNumberSchema: z.Schema<number> = z.string().transform((string) => {
+    assert(/0x[0-9a-f]+/.test(string));
+    return Number(string);
+  });
+
+  readonly HexBigIntSchema: z.Schema<bigint> = z.string().transform((string) => {
+    assert(/0x[0-9a-f]+/.test(string));
+    return BigInt(string);
+  });
+
+  readonly AddressSchema: z.Schema<string> = z.string().transform((value) => this.deserializeAddress(value));
+  readonly HashSchema: z.Schema<string> = z.string().transform((value) => this.#deserializeHash(value));
+
+  readonly LogSchema: z.ObjectSchema<Log> = z.object({
+    address: this.AddressSchema,
+    topics: z.array(this.BytesSchema),
+    data: this.BytesSchema,
+    blockHash: this.HashSchema,
+    transactionHash: this.HashSchema,
+    blockNumber: this.HexNumberSchema,
+    transactionIndex: this.HexNumberSchema,
+    logIndex: this.HexNumberSchema,
+    removed: z.boolean(),
+  });
+
+  readonly TransactionSchema: z.Schema<Transaction | undefined> = z.union([
+    z.null().transform(() => undefined),
+    z.object({
+      blockHash: this.HashSchema,
+      blockNumber: this.HexNumberSchema,
+      from: this.AddressSchema,
+      gasPrice: this.HexNumberSchema,
+      hash: this.HashSchema,
+      nonce: this.HexNumberSchema,
+      r: this.HexBigIntSchema,
+      s: this.HexBigIntSchema,
+      to: this.AddressSchema,
+      transactionIndex: this.HexNumberSchema,
+      type: this.HexNumberSchema,
+      value: this.HexNumberSchema,
+      v: this.HexNumberSchema,
+    }),
+  ]);
+
+  readonly TransactionReceiptSchema: z.Schema<TransactionReceipt | undefined> = z.union([
+    z.null().transform(() => undefined),
+    z.object({
+      blockHash: this.HashSchema,
+      blockNumber: this.HexNumberSchema,
+      from: this.AddressSchema,
+      logs: z.array(this.LogSchema),
+      status: this.HexNumberSchema,
+      to: this.AddressSchema,
+      transactionHash: this.HashSchema,
+      transactionIndex: this.HexNumberSchema,
+      type: this.HexNumberSchema,
+    }).transform(({ status, transactionHash, ...rest }) => ({
+      ...rest,
+      hash: transactionHash,
+      success: (() => {
+        if (status === 0) {
+          return false;
+        }
+        if (status === 1) {
+          return true;
+        }
+        throw new Error('Invalid transaction status');
+      })(),
+    })),
+  ]);
+
+  constructor({ addressFromBytes, bytesFromAddress, deserializeHash, serializeHash }: {
+    addressFromBytes: (bytes: Uint8Array<ArrayBuffer>) => string;
+    bytesFromAddress: (address: string) => Uint8Array<ArrayBuffer>;
+    deserializeHash: (hash: string) => string;
+    serializeHash: (hash: string) => string;
+  }) {
+    this.#addressFromBytes = addressFromBytes;
+    this.#bytesFromAddress = bytesFromAddress;
+    this.#deserializeHash = deserializeHash;
+    this.#serializeHash = serializeHash;
+    this.#dataEncoder = new DataEncoder((type) => this.createABI(type));
+  }
+
+  deserializeAddress(address: string): string {
+    assert(/0x[0-9a-f]{40}/.test(address));
+    return this.#addressFromBytes(Uint8Array.fromHex(address.slice(2)));
+  }
+
+  serializeAddress(address: string): string {
+    return '0x' + this.#bytesFromAddress(address).toHex();
+  }
+
+  deserializeHash(hash: string): string {
+    return this.#deserializeHash(hash);
+  }
+
+  serializeHash(hash: string): string {
+    return this.#serializeHash(hash);
+  }
+
+  createABI(type: string): ABI {
+    return new ABI(type, { bytesFromAddress: this.#bytesFromAddress, addressFromBytes: this.#addressFromBytes });
+  }
+
+  normalizeData(
+    data: Uint8Array<ArrayBuffer> | { method: string; parameters: Uint8Array<ArrayBuffer> | unknown[] },
+  ): Uint8Array<ArrayBuffer> {
+    return this.#dataEncoder.normalize(data);
+  }
+}

package/src/DataEncoder.ts

@@ -0,0 +1,28 @@
+import concat from '@quentinadam/uint8array-extension/concat';
+import keccak256 from '@quentinadam/hash/keccak256';
+import type ABI from './ABI.ts';
+
+export default class DataEncoder {
+  readonly #createABI: (type: string) => ABI;
+
+  constructor(createABI: (type: string) => ABI) {
+    this.#createABI = createABI;
+  }
+
+  encode({ method, parameters }: {
+    method: string;
+    parameters: Uint8Array<ArrayBuffer> | unknown[];
+  }): Uint8Array<ArrayBuffer> {
+    if (parameters instanceof Uint8Array) {
+      return concat([keccak256(method).slice(0, 4), parameters]);
+    } else {
+      return this.#createABI(method).encode(parameters);
+    }
+  }
+
+  normalize(
+    data: Uint8Array<ArrayBuffer> | { method: string; parameters: Uint8Array<ArrayBuffer> | unknown[] },
+  ): Uint8Array<ArrayBuffer> {
+    return (data instanceof Uint8Array) ? data : this.encode(data);
+  }
+}

package/src/Log.ts

@@ -0,0 +1,13 @@
+type Log = {
+  address: string;
+  topics: Uint8Array<ArrayBuffer>[];
+  data: Uint8Array<ArrayBuffer>;
+  blockHash: string;
+  transactionHash: string;
+  blockNumber: number;
+  transactionIndex: number;
+  logIndex: number;
+  removed: boolean;
+};
+
+export default Log;

package/src/MulticallClient.ts

@@ -0,0 +1,87 @@
+import ensure from '@quentinadam/ensure';
+import * as z from '@quentinadam/zod';
+import type Client from './Client.ts';
+
+export default class MulticallClient {
+  readonly #client;
+  readonly #multicallAddress;
+  #pendingCalls = new Array<{
+    contract: string;
+    data: Uint8Array<ArrayBuffer>;
+    resolve: (value: Uint8Array<ArrayBuffer>) => void;
+    reject: (reason: unknown) => void;
+  }>();
+
+  constructor({ client, multicallAddress }: {
+    client: Client;
+    multicallAddress: string;
+  }) {
+    this.#client = client;
+    this.#multicallAddress = multicallAddress;
+  }
+
+  async getBlockNumber(): Promise<number> {
+    const result = await this.call({
+      contract: this.#multicallAddress,
+      data: { method: 'getBlockNumber()', parameters: [] },
+    });
+    return Number(z.bigint().parse(this.#client.createABI('uint256').decode(result)));
+  }
+
+  async call({ contract, data }: {
+    contract: string;
+    data: Uint8Array<ArrayBuffer> | { method: string; parameters: unknown[] };
+  }): Promise<Uint8Array<ArrayBuffer>> {
+    return await new Promise<Uint8Array<ArrayBuffer>>((resolve, reject) => {
+      if (data instanceof Uint8Array === false) {
+        const { method, parameters } = data;
+        data = this.#client.createABI(method).encode(parameters);
+      }
+      this.#pendingCalls.push({ contract, data, resolve, reject });
+      setTimeout(async () => {
+        if (this.#pendingCalls.length > 0) {
+          const pendingCalls = this.#pendingCalls;
+          this.#pendingCalls = [];
+          if (pendingCalls.length > 1) {
+            const data = this.#client.createABI('aggregate3((address,bool,bytes)[])').encode(
+              [pendingCalls.map(({ contract, data }) => [contract, true, data])],
+            );
+            try {
+              const result = await this.#client.call({ contract: this.#multicallAddress, data });
+              const [decoded] = z.tuple([z.array(z.tuple([z.boolean(), z.instanceof(Uint8Array)]))]).parse(
+                this.#client.createABI('((bool,bytes)[])').decode(result),
+              );
+              decoded.forEach(([success, data], index) => {
+                const { resolve, reject } = ensure(pendingCalls[index]);
+                if (success) {
+                  resolve(data);
+                } else {
+                  reject(new Error(`Execution reverted ${data.toHex()}`));
+                }
+              });
+            } catch (error) {
+              for (const { reject } of pendingCalls) {
+                reject(error);
+              }
+            }
+          } else {
+            const { contract, data, resolve, reject } = ensure(pendingCalls[0]);
+            try {
+              resolve(await this.#client.call({ contract, data }));
+            } catch (error) {
+              reject(error);
+            }
+          }
+        }
+      }, 0);
+    });
+  }
+
+  async getBalance(address: string): Promise<bigint> {
+    const result = await this.call({
+      contract: this.#multicallAddress,
+      data: { method: 'getEthBalance(address)', parameters: [address] },
+    });
+    return z.bigint().parse(this.#client.createABI('uint256').decode(result));
+  }
+}

package/src/Transaction.ts

@@ -0,0 +1,17 @@
+type Transaction = {
+  blockHash: string;
+  blockNumber: number;
+  from: string;
+  gasPrice: number;
+  hash: string;
+  nonce: number;
+  r: bigint;
+  s: bigint;
+  to: string;
+  transactionIndex: number;
+  type: number;
+  value: number;
+  v: number;
+};
+
+export default Transaction;

package/src/TransactionReceipt.ts

@@ -0,0 +1,15 @@
+import type Log from './Log.ts';
+
+type TransactionReceipt = {
+  hash: string;
+  success: boolean;
+  blockHash: string;
+  blockNumber: number;
+  from: string;
+  logs: Log[];
+  to: string;
+  transactionIndex: number;
+  type: number;
+};
+
+export default TransactionReceipt;

package/src/computeCREATE2Address.ts

@@ -0,0 +1,32 @@
+import keccak256 from '@quentinadam/hash/keccak256';
+import { concat, fromUintBE } from '@quentinadam/uint8array-extension';
+
+export default function computeCREATE2Address(
+  params:
+    & { deployer: string; salt: bigint | number | Uint8Array<ArrayBuffer> }
+    & (
+      | { bytecodeHash: Uint8Array<ArrayBuffer>; bytecode?: undefined; constructorArguments?: undefined }
+      | { bytecodeHash?: undefined; bytecode: Uint8Array<ArrayBuffer>; constructorArguments?: Uint8Array<ArrayBuffer> }
+    ),
+  { prefixByte, addressFromBytes, bytesFromAddress }: {
+    prefixByte: number;
+    addressFromBytes: (bytes: Uint8Array<ArrayBuffer>) => string;
+    bytesFromAddress: (address: string) => Uint8Array<ArrayBuffer>;
+  },
+): string {
+  const { deployer, salt } = params;
+  const bytecodeHash = (() => {
+    const { bytecodeHash, bytecode, constructorArguments } = params;
+    if (bytecodeHash !== undefined) {
+      return bytecodeHash;
+    }
+    return keccak256(concat([bytecode, constructorArguments].filter((chunk) => chunk !== undefined)));
+  })();
+  const bytes = keccak256(concat([
+    new Uint8Array(prefixByte),
+    bytesFromAddress(deployer),
+    salt instanceof Uint8Array ? salt : fromUintBE(salt, 32),
+    bytecodeHash,
+  ])).slice(-20);
+  return addressFromBytes(bytes);
+}

package/src/computeCREATEAddress.ts

@@ -0,0 +1,13 @@
+import keccak256 from '@quentinadam/hash/keccak256';
+import * as rlp from '@quentinadam/rlp';
+
+export default function computeCREATEAddress(
+  { deployer, nonce }: { deployer: string; nonce: bigint | number },
+  { addressFromBytes, bytesFromAddress }: {
+    addressFromBytes: (bytes: Uint8Array<ArrayBuffer>) => string;
+    bytesFromAddress: (address: string) => Uint8Array<ArrayBuffer>;
+  },
+): string {
+  const bytes = keccak256(rlp.encode([bytesFromAddress(deployer), nonce])).slice(-20);
+  return addressFromBytes(bytes);
+}

package/src/mod.ts

@@ -0,0 +1,25 @@
+import ABI from './ABI.ts';
+import type Block from './Block.ts';
+import computeCREATE2Address from './computeCREATE2Address.ts';
+import computeCREATEAddress from './computeCREATEAddress.ts';
+import Client from './Client.ts';
+import ClientError from './ClientError.ts';
+import DataEncoder from './DataEncoder.ts';
+import ClientHelper from './ClientHelper.ts';
+import type Log from './Log.ts';
+import MulticallClient from './MulticallClient.ts';
+import type Transaction from './Transaction.ts';
+import type TransactionReceipt from './TransactionReceipt.ts';
+
+export {
+  ABI,
+  Client,
+  ClientError,
+  ClientHelper,
+  computeCREATE2Address,
+  computeCREATEAddress,
+  DataEncoder,
+  MulticallClient,
+};
+
+export type { Block, Log, Transaction, TransactionReceipt };