@bradthomasbrown/75bb14 1.0.0

package/README.md

@@ -0,0 +1,46 @@
+# 75bb14
+This is a simple, convenience library for combining an EvmEntity and a Node in TypeScript/JavaScript. 
+
+## Why?
+An EvmEntity, to us, is just an EVM-flavored secpk256k1-and-keccak256 powered ECDSA thin wrapper.
+A Node is, to us, a wrapper over some EVM node (via JSON RPC API).
+It would seem natural then that to make these things more convenient to use together, that we combine the ideas, but somewhere separate (here).
+An ECDSA-focused concept like EvmEntity shouldn't be working in terms of EVM chain primitives like the `from`, `to`, `input` fields of some `transaction`, so this library bridges that gap so those simpler EVM chain primitives can be used.
+It also is a place for putting features like the ability to "wait" for a transaction (or to define what that means) and to define behaviors for how transacting should be done.
+For example, how do we want to manage the nonce? How do we want to manage the gas price? How do we want a consumer of a `75bb14`-generated class instance to specify how much gas they want to use?
+One can use the `75bb14` function to generate classes whose instances act in simple or complex ways, handling these matters.
+
+## Installation
+```sh
+npm i @bradthomasbrown/75bb14
+```
+
+## Usage
+```js
+import { _e4e1df_ } from "@bradthomasbrown/75bb14/e4e1df";
+import { _900ef2_ } from "@bradthomasbrown/900ef2";
+import { EvmEntity } from "@bradthomasbrown/entity/evm";
+
+const port = 8545;
+// 900ef2 is a sort of "containerized EVM node manager". can work with anvil, geth, etc.
+const Anvil = _900ef2_("ghcr.io/foundry-rs/foundry:v1.5.1", `anvil -b 1 -p ${port} --host 0.0.0.0`);
+const node = await Anvil.make(port);
+const alice = EvmEntity.random();
+const bob = EvmEntity.random();
+// e4e1df is a sort of "combining layer of an EvmEntity (itself just a light layer of secp256k1 and keccak256 over ECDSA
+// it knows nothing about transactions, just raw data) and a node (JSON RPC convenience)
+const _d5_ = new _e4e1df_(alice, node, null);
+await node.client.request("anvil_setBalance", [alice.address, "0x10000000000000"]);
+const [aliceStartBalance, bobStartBalance] = await Promise.all([alice, bob].map(entity => node.getBalance(entity.address, "latest")));
+// "promise" here is just the promise that the node has received and accepted our request, not necessarily a sign that the tranasction is in the blockhain at all
+const [txhash, promise] = await _d5_.send(bob.address, null, 1000000000000n);
+await Promise.all([promise, _d5_.wait(txhash)]);
+const [aliceEndBalance, bobEndBalance] = await Promise.all([alice, bob].map(entity => node.getBalance(entity.address, "latest")));
+console.log({ aliceStartBalance, bobStartBalance, aliceEndBalance, bobEndBalance });
+/* {
+  aliceStartBalance: 4503599627370496n,
+  bobStartBalance: 0n,
+  aliceEndBalance: 4460599627370496n,
+  bobEndBalance: 1000000000000n,
+} */
+```

package/dist/75bb14.d.ts

@@ -0,0 +1,27 @@
+import { EvmEntity } from "@bradthomasbrown/entity/evm";
+import { Node } from "@bradthomasbrown/ejra";
+/**
+ * A function which returns a class that can wrap an EvmEntity (`@bradthomasbrown/entity/evm`) and a Node (`@bradthomasbrown/ejra`)
+ * to make interacting with an EVM chain under an identity more convenient.
+ * @param _a6_ - A function that returns a promise for the nonce to use for some transaction.
+ * @param _66_ - A function that returns a promise for the gas price to use for some transaction.
+ * @param _f6_ - A function that returns a promise for the gas limit to use for some transaction.
+ * @param _a9_ - A function that converts an address into a Uint8Array.
+ * @param _c5_ - A function that converts data/input/calldata into a Uint8Array.
+ * @param _e4_ - A function that returns a promise for the chain ID to use for some transaction.
+ * @param _91_ - A synchronization barrier function that can be used to batch and execute the above promises, if the aforementioned functions don't already do so.
+ * @param _fe_ - A function that implements "waiting" for some transaction hash.
+ */
+declare function _75bb14_<_b6_ extends unknown[], R, S>(_a6_: (_45_: InstanceType<ReturnType<typeof _75bb14_>>) => Promise<bigint>, _66_: (_84_: InstanceType<ReturnType<typeof _75bb14_>>) => Promise<bigint>, _f6_: (_28_: InstanceType<ReturnType<typeof _75bb14_>>, _89__: null | string, _01_: null | string, _bc_: bigint) => Promise<bigint>, _a9_: (_03_: null | string) => Uint8Array, _c5_: (_47_: null | string) => Uint8Array, _e4_: (_2b_: InstanceType<ReturnType<typeof _75bb14_>>) => Promise<bigint>, _91_: () => void, _fe_: (_d3_: InstanceType<ReturnType<typeof _75bb14_>>, _e7_: string, ..._2a_: _b6_) => Promise<R>): {
+    new (entity: InstanceType<typeof EvmEntity>, node: InstanceType<typeof Node>, state: S): {
+        entity: InstanceType<typeof EvmEntity>;
+        node: InstanceType<typeof Node>;
+        state: S;
+        _78_(_e2_: null | string, _88_: null | string, value?: bigint): Promise<[bigint, string, Promise<string>]>;
+        send(to: null | string, input: null | string, value?: bigint): Promise<[string, Promise<string>]>;
+        deploy(input: string, value?: bigint): Promise<[string, string, Promise<string>]>;
+        wait(transactionHash: string, ...args: _b6_): Promise<R>;
+    };
+};
+export { _75bb14_ };
+//# sourceMappingURL=75bb14.d.ts.map

package/dist/75bb14.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"75bb14.d.ts","sourceRoot":"","sources":["../src/75bb14.ts"],"names":[],"mappings":"AAgCA,OAAO,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AACxD,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAE7C;;;;;;;;;;;GAWG;AACH,iBAAS,QAAQ,CAAC,IAAI,SAAS,OAAO,EAAE,EAAE,CAAC,EAAE,CAAC,EAC1C,IAAI,EAAC,CAAC,IAAI,EAAC,YAAY,CAAC,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC,KAAG,OAAO,CAAC,MAAM,CAAC,EACtE,IAAI,EAAC,CAAC,IAAI,EAAC,YAAY,CAAC,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC,KAAG,OAAO,CAAC,MAAM,CAAC,EACtE,IAAI,EAAC,CAAC,IAAI,EAAC,YAAY,CAAC,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAC,IAAI,GAAC,MAAM,EAAE,IAAI,EAAC,IAAI,GAAC,MAAM,EAAE,IAAI,EAAC,MAAM,KAAG,OAAO,CAAC,MAAM,CAAC,EACxH,IAAI,EAAC,CAAC,IAAI,EAAC,IAAI,GAAC,MAAM,KAAG,UAAU,EACnC,IAAI,EAAC,CAAC,IAAI,EAAC,IAAI,GAAC,MAAM,KAAG,UAAU,EACnC,IAAI,EAAC,CAAC,IAAI,EAAC,YAAY,CAAC,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC,KAAG,OAAO,CAAC,MAAM,CAAC,EACtE,IAAI,EAAC,MAAI,IAAI,EACb,IAAI,EAAC,CAAC,IAAI,EAAC,YAAY,CAAC,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAC,MAAM,EAAE,GAAG,IAAI,EAAC,IAAI,KAAG,OAAO,CAAC,CAAC,CAAC;iBAUrE,YAAY,CAAC,OAAO,SAAS,CAAC,QAAO,YAAY,CAAC,OAAO,IAAI,CAAC,SAAQ,CAAC;gBANnF,YAAY,CAAC,OAAO,SAAS,CAAC;cAEhC,YAAY,CAAC,OAAO,IAAI,CAAC;eAExB,CAAC;mBASE,IAAI,GAAC,MAAM,QACX,IAAI,GAAC,MAAM;iBAuBN,IAAI,GAAC,MAAM,SAAQ,IAAI,GAAC,MAAM;sBAKzB,MAAM;8BAQJ,MAAM,WAAU,IAAI;;EAKhD;AAED,OAAO,EAAE,QAAQ,EAAE,CAAC"}

package/dist/75bb14.js

@@ -0,0 +1,94 @@
+// <SCHIZO-NOTES feel-free-to-ignore>
+//      for testing, we want to make sure our balance is high enough for some set of transactions
+//      we need a chain id to make a transaction
+//      we need a gas estimate to set a gas limit for a legacy transaction
+//       we'll also need this for other transaction types
+//      we'll want the gas price
+//       we may need this or other information for other transaction types
+//      then we'll produce a signed transaction hex which can be sent via json rpc
+//      then we think we'll want some sort of a sync primitive in this sequence
+//       so maybe we want a "sync request handler"
+//       we're thinking GPU-style command queue stuff around here
+//      then we'll want to use some of the data from the sequence so far to build the next part of the sequence
+//      in GPU programming, i think we'd just have a memory block
+//       previous sequence block writes to the memory block
+//       later sequence block reads from the memory block
+//       maybe here we just have some typed object, loosely representing a struct
+//      we keep thinking that we want to write programs here
+//       opcodes
+//      but certain kinds of odd programs
+//       where opcodes may be asynchronous, then we have synchonization primitives or "barriers"
+//      so that we are effectively pipelining operations
+//      "machine" then will go through a sequence of opcodes until it hits a barrier then it will try to
+//          satisfy each opcode
+//      one such opcode may be "gasprice"
+//      one may be "sign EVM transaction (return hex)"
+//      one may be "sign EVM transaction given 'input' return hex"
+//      maybe we have an opcode "set gas price acquisition function"?
+//      maybe we have an opcode "update (to some satsifaction policy) gas price"?
+//  <SCHIZO-NOTES feel-free-to-ignore/>
+import { encode } from "@bradthomasbrown/rlp";
+import { keccak256 } from "@bradthomasbrown/keccak/keccak256";
+import { EvmEntity } from "@bradthomasbrown/entity/evm";
+import { Node } from "@bradthomasbrown/ejra";
+/**
+ * A function which returns a class that can wrap an EvmEntity (`@bradthomasbrown/entity/evm`) and a Node (`@bradthomasbrown/ejra`)
+ * to make interacting with an EVM chain under an identity more convenient.
+ * @param _a6_ - A function that returns a promise for the nonce to use for some transaction.
+ * @param _66_ - A function that returns a promise for the gas price to use for some transaction.
+ * @param _f6_ - A function that returns a promise for the gas limit to use for some transaction.
+ * @param _a9_ - A function that converts an address into a Uint8Array.
+ * @param _c5_ - A function that converts data/input/calldata into a Uint8Array.
+ * @param _e4_ - A function that returns a promise for the chain ID to use for some transaction.
+ * @param _91_ - A synchronization barrier function that can be used to batch and execute the above promises, if the aforementioned functions don't already do so.
+ * @param _fe_ - A function that implements "waiting" for some transaction hash.
+ */
+function _75bb14_(_a6_, _66_, _f6_, _a9_, _c5_, _e4_, _91_, _fe_) {
+    return class _57461f_ {
+        entity;
+        node;
+        state;
+        constructor(entity, node, state) {
+            this.entity = entity;
+            this.node = node;
+            this.state = state;
+        }
+        async _78_(_e2_, // to string
+        _88_, // calldata/input/data/bytecode string
+        value = 0n) {
+            const _8d_ = _a6_(this); // return nonce promise
+            const _ba_ = _66_(this); // return gas price promise
+            const _39_ = _f6_(this, _e2_, _88_, value); // return gas limit promise
+            const to = _a9_(_e2_); // derive the final "to"
+            const input = _c5_(_88_); // derive the final "data"/"input"
+            const _cd_ = _e4_(this); // return chain id promise
+            _91_(); // synchronization barrier trigger function
+            const [nonce, gasPrice, gasLimit, chainId] = await Promise.all([_8d_, _ba_, _39_, _cd_]);
+            const rawTxArray = [nonce, gasPrice, gasLimit, to, value, input, chainId, 0n, 0n];
+            const rawTxEncoded = encode(rawTxArray);
+            const signature = this.entity.sign(rawTxEncoded);
+            const _7f_ = chainId * 2n + 35n + signature.v;
+            const signedTxArray = [...rawTxArray.slice(0, 6), _7f_, signature.r, signature.s];
+            const signedTxEncoded = encode(signedTxArray);
+            const signedTxHex = `0x${signedTxEncoded.toHex()}`;
+            const signedTxHash = `0x${keccak256(signedTxEncoded).toHex()}`;
+            const promise = this.node.sendRawTransaction(signedTxHex);
+            return [nonce, signedTxHash, promise];
+        }
+        async send(to, input, value = 0n) {
+            const [_nonce, signedTxHash, promise] = await this._78_(to, input, value);
+            return [signedTxHash, promise];
+        }
+        async deploy(input, value = 0n) {
+            const [nonce, signedTxHash, promise] = await this._78_(null, input, value);
+            const _09_ = encode([Uint8Array.fromHex(this.entity.address.slice(2)), nonce]);
+            const _c0_ = keccak256(_09_);
+            const contractAddress = `0x${_c0_.slice(12).toHex()}`;
+            return [contractAddress, signedTxHash, promise];
+        }
+        wait(transactionHash, ...args) {
+            return _fe_(this, transactionHash, ...args);
+        }
+    };
+}
+export { _75bb14_ };

package/dist/concrete/e4e1df.d.ts

@@ -0,0 +1,193 @@
+import type { Node } from "@bradthomasbrown/ejra";
+/**
+ * A simple 75bb14 which will:
+ * - get the most recently available nonce from the node for each transaction
+ * - get the most recently available gas price from the node for each transaction
+ * - get the gas estimate from the node for each transaction
+ * - get the chain id from the node for each transaction
+ * without batching,
+ * and will perform a simple 5-attempt 250-ms delay poll for a transaction reciept from the node as a wait condition.
+ *
+ * "Good enough" for local development work, maybe.
+ */
+declare const _e4e1df_: {
+    new (entity: InstanceType<{
+        new (secret: bigint): {
+            _6e_: {
+                T: import("@bradthomasbrown/finite-domain").FiniteDomain;
+                _a7_: (M: Uint8Array) => bigint;
+                sign: (d: bigint, M: Uint8Array) => {
+                    r: bigint;
+                    s: bigint;
+                    v: bigint;
+                };
+                recover: (S: {
+                    r: bigint;
+                    s: bigint;
+                    v: bigint;
+                }, M: Uint8Array) => import("@bradthomasbrown/finite-curve").FinitePoint;
+                verify(Q: import("@bradthomasbrown/finite-curve").FinitePoint, S: {
+                    r: bigint;
+                    s: bigint;
+                    v: bigint;
+                }, M: Uint8Array): boolean;
+            };
+            secret: bigint;
+            sign: (M: Uint8Array) => {
+                r: bigint;
+                s: bigint;
+                v: bigint;
+            };
+            _public: undefined | import("@bradthomasbrown/finite-curve").FinitePoint;
+            _publicHex: undefined | string;
+            _hexlen: undefined | number;
+            _address: string | undefined;
+            get public(): import("@bradthomasbrown/finite-curve").FinitePoint;
+            get hashlen(): number;
+            get publicHex(): string;
+            get address(): string;
+        };
+        random(): {
+            _6e_: {
+                T: import("@bradthomasbrown/finite-domain").FiniteDomain;
+                _a7_: (M: Uint8Array) => bigint;
+                sign: (d: bigint, M: Uint8Array) => {
+                    r: bigint;
+                    s: bigint;
+                    v: bigint;
+                };
+                recover: (S: {
+                    r: bigint;
+                    s: bigint;
+                    v: bigint;
+                }, M: Uint8Array) => import("@bradthomasbrown/finite-curve").FinitePoint;
+                verify(Q: import("@bradthomasbrown/finite-curve").FinitePoint, S: {
+                    r: bigint;
+                    s: bigint;
+                    v: bigint;
+                }, M: Uint8Array): boolean;
+            };
+            secret: bigint;
+            sign: (M: Uint8Array) => {
+                r: bigint;
+                s: bigint;
+                v: bigint;
+            };
+            _public: undefined | import("@bradthomasbrown/finite-curve").FinitePoint;
+            _publicHex: undefined | string;
+            _hexlen: undefined | number;
+            _address: string | undefined;
+            get public(): import("@bradthomasbrown/finite-curve").FinitePoint;
+            get hashlen(): number;
+            get publicHex(): string;
+            get address(): string;
+        };
+    }>, node: InstanceType<typeof Node>, state: unknown): {
+        entity: InstanceType<{
+            new (secret: bigint): {
+                _6e_: {
+                    T: import("@bradthomasbrown/finite-domain").FiniteDomain;
+                    _a7_: (M: Uint8Array) => bigint;
+                    sign: (d: bigint, M: Uint8Array) => {
+                        r: bigint;
+                        s: bigint;
+                        v: bigint;
+                    };
+                    recover: (S: {
+                        r: bigint;
+                        s: bigint;
+                        v: bigint;
+                    }, M: Uint8Array) => import("@bradthomasbrown/finite-curve").FinitePoint;
+                    verify(Q: import("@bradthomasbrown/finite-curve").FinitePoint, S: {
+                        r: bigint;
+                        s: bigint;
+                        v: bigint;
+                    }, M: Uint8Array): boolean;
+                };
+                secret: bigint;
+                sign: (M: Uint8Array) => {
+                    r: bigint;
+                    s: bigint;
+                    v: bigint;
+                };
+                _public: undefined | import("@bradthomasbrown/finite-curve").FinitePoint;
+                _publicHex: undefined | string;
+                _hexlen: undefined | number;
+                _address: string | undefined;
+                get public(): import("@bradthomasbrown/finite-curve").FinitePoint;
+                get hashlen(): number;
+                get publicHex(): string;
+                get address(): string;
+            };
+            random(): {
+                _6e_: {
+                    T: import("@bradthomasbrown/finite-domain").FiniteDomain;
+                    _a7_: (M: Uint8Array) => bigint;
+                    sign: (d: bigint, M: Uint8Array) => {
+                        r: bigint;
+                        s: bigint;
+                        v: bigint;
+                    };
+                    recover: (S: {
+                        r: bigint;
+                        s: bigint;
+                        v: bigint;
+                    }, M: Uint8Array) => import("@bradthomasbrown/finite-curve").FinitePoint;
+                    verify(Q: import("@bradthomasbrown/finite-curve").FinitePoint, S: {
+                        r: bigint;
+                        s: bigint;
+                        v: bigint;
+                    }, M: Uint8Array): boolean;
+                };
+                secret: bigint;
+                sign: (M: Uint8Array) => {
+                    r: bigint;
+                    s: bigint;
+                    v: bigint;
+                };
+                _public: undefined | import("@bradthomasbrown/finite-curve").FinitePoint;
+                _publicHex: undefined | string;
+                _hexlen: undefined | number;
+                _address: string | undefined;
+                get public(): import("@bradthomasbrown/finite-curve").FinitePoint;
+                get hashlen(): number;
+                get publicHex(): string;
+                get address(): string;
+            };
+        }>;
+        node: InstanceType<typeof Node>;
+        state: unknown;
+        _78_(_e2_: null | string, _88_: null | string, value?: bigint): Promise<[bigint, string, Promise<string>]>;
+        send(to: null | string, input: null | string, value?: bigint): Promise<[string, Promise<string>]>;
+        deploy(input: string, value?: bigint): Promise<[string, string, Promise<string>]>;
+        wait(transactionHash: string): Promise<{
+            transactionHash: string;
+            transactionIndex: bigint;
+            blockHash: string;
+            blockNumber: bigint;
+            from: string;
+            to: string | null;
+            cumulativeGasUsed: bigint;
+            effectiveGasPrice: bigint;
+            gasUsed: bigint;
+            contractAddress: string | null;
+            logs: {
+                removed: boolean;
+                logIndex: bigint | null;
+                transactionIndex: bigint | null;
+                transactionHash: string | null;
+                blockHash: string | null;
+                blockNumber: bigint | null;
+                address: string;
+                data: string[];
+                topics: string[];
+            }[];
+            logsBloom: string;
+            type: number;
+            root: string | null;
+            status: number | null;
+        }>;
+    };
+};
+export { _e4e1df_ };
+//# sourceMappingURL=e4e1df.d.ts.map

package/dist/concrete/e4e1df.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"e4e1df.d.ts","sourceRoot":"","sources":["../../src/concrete/e4e1df.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AA6ClD;;;;;;;;;;GAUG;AACH,QAAA,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA2F,CAAC;AAE1G,OAAO,EAAE,QAAQ,EAAE,CAAC"}

package/dist/concrete/e4e1df.js

@@ -0,0 +1,50 @@
+import { _75bb14_ } from "../75bb14.js";
+function _4403dc_(_d2_) {
+    return _d2_.node.getTransactionCount(_d2_.entity.address, "latest");
+}
+function _0da055_(_ce_) {
+    return _ce_.node.gasPrice();
+}
+function _422b72_(_d6_, _fa_, _01_) {
+    const _5b_ = {};
+    _5b_.from = _d6_.entity.address;
+    if (_fa_ !== null)
+        _5b_.to = _fa_;
+    if (_01_ !== null)
+        _5b_.input = _01_;
+    return _d6_.node.estimateGas(_5b_, "latest");
+}
+function _e752dc_(_80_) {
+    if (_80_ === null)
+        return new Uint8Array();
+    if (_80_.startsWith("0x"))
+        return Uint8Array.fromHex(_80_.slice(2));
+    return Uint8Array.fromHex(_80_);
+}
+function _e4aeae_(_ef_) {
+    return _ef_.node.chainId();
+}
+function _3c6f98_() { }
+async function _022a28_(_ad_, _85_) {
+    let receipt;
+    for (let i = 0; i < 5; i++) {
+        receipt = await _ad_.node.getTransactionReceipt(_85_);
+        if (receipt != null)
+            return receipt;
+        await new Promise(r => setTimeout(r, 250));
+    }
+    throw new Error(`failed to wait for receipt from transaction hash: ${_85_}`);
+}
+/**
+ * A simple 75bb14 which will:
+ * - get the most recently available nonce from the node for each transaction
+ * - get the most recently available gas price from the node for each transaction
+ * - get the gas estimate from the node for each transaction
+ * - get the chain id from the node for each transaction
+ * without batching,
+ * and will perform a simple 5-attempt 250-ms delay poll for a transaction reciept from the node as a wait condition.
+ *
+ * "Good enough" for local development work, maybe.
+ */
+const _e4e1df_ = _75bb14_(_4403dc_, _0da055_, _422b72_, _e752dc_, _e752dc_, _e4aeae_, _3c6f98_, _022a28_);
+export { _e4e1df_ };

package/package.json

@@ -0,0 +1,25 @@
+{
+    "name": "@bradthomasbrown/75bb14",
+    "description": "A light, flexible, convenience layer library for `EvmEntity`s and (EVM) Nodes in JavaScript/TypeScript.",
+    "version": "1.0.0",
+    "author": "Brad Brown <https://t.me/bradthomasbrown>",
+    "type": "module",
+    "files": [
+        "dist/"
+    ],
+    "exports": {
+        ".": "./dist/75bb14.js",
+        "./e4e1df": "./dist/concrete/e4e1df.js"
+    },
+    "dependencies": {
+        "@bradthomasbrown/ecdsa": "^2.0.1",
+        "@bradthomasbrown/ejra": "^1.0.6",
+        "@bradthomasbrown/entity": "^1.0.1",
+        "@bradthomasbrown/keccak": "^1.0.1",
+        "@bradthomasbrown/rlp": "^1.0.0"
+    },
+    "devDependencies": {
+        "@bradthomasbrown/900ef2": "^1.0.0",
+        "@types/bun": "^1.3.5"
+    }
+}