@bradthomasbrown/75bb14 1.0.1 → 2.0.0

package/dist/75bb14.d.ts

@@ -12,15 +12,13 @@ import { Node } from "@bradthomasbrown/ejra";
  * @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>;
+declare function _75bb14_<_54_, _b0_ extends Array<any>, _10_ extends Array<any>, _51_, _24_>(_8c_: (state: _54_, node: InstanceType<typeof Node>, entity: InstanceType<typeof EvmEntity>, ...args: _b0_) => _51_, _ff_: (state: _54_, node: InstanceType<typeof Node>, entity: InstanceType<typeof EvmEntity>, ...args: _10_) => _24_): {
+    new (state: _54_, node: InstanceType<typeof Node>, 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>;
+        entity: InstanceType<typeof EvmEntity>;
+        state: _54_;
+        send: (...args: _b0_) => _51_;
+        wait: (...args: _10_) => _24_;
     };
 };
 export { _75bb14_ };

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

@@ -1 +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"}
+{"version":3,"file":"75bb14.d.ts","sourceRoot":"","sources":["../src/75bb14.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AACxD,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAG7C;;;;;;;;;;;GAWG;AACH,iBAAS,QAAQ,CACb,IAAI,EACJ,IAAI,SAAS,KAAK,CAAC,GAAG,CAAC,EACvB,IAAI,SAAS,KAAK,CAAC,GAAG,CAAC,EACvB,IAAI,EACJ,IAAI,EAEJ,IAAI,EAAC,CAAC,KAAK,EAAC,IAAI,EAAE,IAAI,EAAC,YAAY,CAAC,OAAO,IAAI,CAAC,EAAE,MAAM,EAAC,YAAY,CAAC,OAAO,SAAS,CAAC,EAAE,GAAG,IAAI,EAAC,IAAI,KAAG,IAAI,EAC5G,IAAI,EAAC,CAAC,KAAK,EAAC,IAAI,EAAE,IAAI,EAAC,YAAY,CAAC,OAAO,IAAI,CAAC,EAAE,MAAM,EAAC,YAAY,CAAC,OAAO,SAAS,CAAC,EAAE,GAAG,IAAI,EAAC,IAAI,KAAG,IAAI;gBAUtF,IAAI,QAAO,YAAY,CAAC,OAAO,IAAI,CAAC,UAAS,YAAY,CAAC,OAAO,SAAS,CAAC;cANxF,YAAY,CAAC,OAAO,IAAI,CAAC;gBACvB,YAAY,CAAC,OAAO,SAAS,CAAC;eAC/B,IAAI;cACL,CAAC,GAAG,IAAI,EAAC,IAAI,KAAG,IAAI;cACpB,CAAC,GAAG,IAAI,EAAC,IAAI,KAAG,IAAI;;EAWhC;AAED,OAAO,EAAE,QAAQ,EAAE,CAAC"}

package/dist/75bb14.js

@@ -1,36 +1,8 @@
-// <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";
+import sendLegacyTransaction from "./lib/sendLegacyTransaction.js";
 /**
  * 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.
@@ -43,51 +15,19 @@ import { Node } from "@bradthomasbrown/ejra";
  * @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_) {
+function _75bb14_(_8c_, _ff_) {
     return class _57461f_ {
-        entity;
         node;
+        entity;
         state;
-        constructor(entity, node, state) {
+        send;
+        wait;
+        constructor(state, node, entity) {
             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);
+            this.send = function send(...args) { return _8c_(state, node, entity, ...args); };
+            this.wait = function wait(...args) { return _ff_(state, node, entity, ...args); };
         }
     };
 }

package/dist/concrete/dd2554.d.ts

@@ -0,0 +1,179 @@
+declare const _dd2554_: {
+    new (state: null, node: InstanceType<typeof import("@bradthomasbrown/ejra").Node>, 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 import("@bradthomasbrown/ejra").Node>;
+        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;
+            };
+        }>;
+        state: null;
+        send: (gasLimit: bigint, to: string | null, value: bigint, input: ArrayBuffer | null) => Promise<[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;
+        } | undefined>;
+    };
+};
+export { _dd2554_ };
+//# sourceMappingURL=dd2554.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dd2554.d.ts","sourceRoot":"","sources":["../../src/concrete/dd2554.ts"],"names":[],"mappings":"AAkCA,QAAA,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAuB,CAAC;AAEtC,OAAO,EAAE,QAAQ,EAAE,CAAC"}

package/dist/concrete/dd2554.js

@@ -0,0 +1,21 @@
+import { _75bb14_ } from "../75bb14.js";
+import sendLegacyTransaction from "../lib/sendLegacyTransaction.js";
+async function send(_state, node, entity, gasLimit, to, value, input) {
+    const nonce = await node.getTransactionCount(entity.address, "latest");
+    const gasPrice = await node.gasPrice();
+    const inputBytes = input === null ? new Uint8Array() : new Uint8Array(input);
+    const toBytes = to !== null ? Uint8Array.fromHex(to.slice(2)) : new Uint8Array();
+    const chainId = await node.chainId();
+    return sendLegacyTransaction(node, entity, nonce, gasPrice, gasLimit, toBytes, value, inputBytes, chainId);
+}
+async function wait(_state, node, _entity, transactionHash) {
+    let receipt;
+    for (let i = 0; i < 5; i++) {
+        receipt = await node.getTransactionReceipt(transactionHash);
+        if (receipt !== null)
+            return receipt;
+        await new Promise(r => setTimeout(r, 250));
+    }
+}
+const _dd2554_ = _75bb14_(send, wait);
+export { _dd2554_ };

package/dist/concrete/e4e1df.d.ts

@@ -1,17 +1,5 @@
-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 (state: null, node: InstanceType<typeof import("@bradthomasbrown/ejra").Node>, entity: InstanceType<{
         new (secret: bigint): {
             _6e_: {
                 T: import("@bradthomasbrown/finite-domain").FiniteDomain;
@@ -82,7 +70,8 @@ declare const _e4e1df_: {
             get publicHex(): string;
             get address(): string;
         };
-    }>, node: InstanceType<typeof Node>, state: unknown): {
+    }>): {
+        node: InstanceType<typeof import("@bradthomasbrown/ejra").Node>;
         entity: InstanceType<{
             new (secret: bigint): {
                 _6e_: {
@@ -155,12 +144,9 @@ declare const _e4e1df_: {
                 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<{
+        state: null;
+        send: (to: string | null, value: bigint, input: ArrayBuffer | null) => Promise<[string, Promise<string>]>;
+        wait: (transactionHash: string) => Promise<{
             transactionHash: string;
             transactionIndex: bigint;
             blockHash: string;
@@ -186,7 +172,7 @@ declare const _e4e1df_: {
             type: number;
             root: string | null;
             status: number | null;
-        }>;
+        } | undefined>;
     };
 };
 export { _e4e1df_ };

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

@@ -1 +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"}
+{"version":3,"file":"e4e1df.d.ts","sourceRoot":"","sources":["../../src/concrete/e4e1df.ts"],"names":[],"mappings":"AAsCA,QAAA,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAuB,CAAC;AAEtC,OAAO,EAAE,QAAQ,EAAE,CAAC"}

package/dist/concrete/e4e1df.js

@@ -1,50 +1,28 @@
 import { _75bb14_ } from "../75bb14.js";
-function _4403dc_(_d2_) {
-    return _d2_.node.getTransactionCount(_d2_.entity.address, "latest");
+import sendLegacyTransaction from "../lib/sendLegacyTransaction.js";
+async function send(_state, node, entity, to, value, input) {
+    const nonce = await node.getTransactionCount(entity.address, "latest");
+    const gasPrice = await node.gasPrice();
+    const inputBytes = input === null ? new Uint8Array() : new Uint8Array(input);
+    const inputHex = `0x${inputBytes.toHex()}`;
+    let _ca_ = { from: entity.address, value: `0x${value.toString(16)}` };
+    if (to !== null)
+        _ca_.to = to;
+    if (input !== null)
+        _ca_.input = inputHex;
+    const gasLimit = await node.estimateGas(_ca_, "latest");
+    const toBytes = to !== null ? Uint8Array.fromHex(to.slice(2)) : new Uint8Array();
+    const chainId = await node.chainId();
+    return sendLegacyTransaction(node, entity, nonce, gasPrice, gasLimit, toBytes, value, inputBytes, chainId);
 }
-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_) {
+async function wait(_state, node, _entity, transactionHash) {
     let receipt;
     for (let i = 0; i < 5; i++) {
-        receipt = await _ad_.node.getTransactionReceipt(_85_);
-        if (receipt != null)
+        receipt = await node.getTransactionReceipt(transactionHash);
+        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_);
+const _e4e1df_ = _75bb14_(send, wait);
 export { _e4e1df_ };

package/dist/lib/sendLegacyTransaction.d.ts

@@ -0,0 +1,4 @@
+import { EvmEntity } from "@bradthomasbrown/entity/evm";
+import { Node } from "@bradthomasbrown/ejra";
+export default function (node: InstanceType<typeof Node>, entity: InstanceType<typeof EvmEntity>, nonce: bigint, gasPrice: bigint, gasLimit: bigint, to: Uint8Array, value: bigint, input: Uint8Array, chainId: bigint): [string, Promise<string>];
+//# sourceMappingURL=sendLegacyTransaction.d.ts.map

package/dist/lib/sendLegacyTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sendLegacyTransaction.d.ts","sourceRoot":"","sources":["../../src/lib/sendLegacyTransaction.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AACxD,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAE7C,MAAM,CAAC,OAAO,WACV,IAAI,EAAC,YAAY,CAAC,OAAO,IAAI,CAAC,EAC9B,MAAM,EAAC,YAAY,CAAC,OAAO,SAAS,CAAC,EACrC,KAAK,EAAC,MAAM,EACZ,QAAQ,EAAC,MAAM,EACf,QAAQ,EAAC,MAAM,EACf,EAAE,EAAC,UAAU,EACb,KAAK,EAAC,MAAM,EACZ,KAAK,EAAC,UAAU,EAChB,OAAO,EAAC,MAAM,GAChB,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,CAW1B"}

package/dist/lib/sendLegacyTransaction.js

@@ -0,0 +1,16 @@
+import { encode } from "@bradthomasbrown/rlp";
+import { keccak256 } from "@bradthomasbrown/keccak/keccak256";
+import { EvmEntity } from "@bradthomasbrown/entity/evm";
+import { Node } from "@bradthomasbrown/ejra";
+export default function (node, entity, nonce, gasPrice, gasLimit, to, value, input, chainId) {
+    const rawTxArray = [nonce, gasPrice, gasLimit, to, value, input, chainId, 0n, 0n];
+    const rawTxEncoded = encode(rawTxArray);
+    const signature = 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 = node.sendRawTransaction(signedTxHex);
+    return [signedTxHash, promise];
+}

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@bradthomasbrown/75bb14",
     "description": "A light, flexible, convenience layer library for `EvmEntity`s and (EVM) Nodes in JavaScript/TypeScript.",
-    "version": "1.0.1",
+    "version": "2.0.0",
     "author": "Brad Brown <https://t.me/bradthomasbrown>",
     "type": "module",
     "files": [
@@ -9,7 +9,8 @@
     ],
     "exports": {
         ".": "./dist/75bb14.js",
-        "./e4e1df": "./dist/concrete/e4e1df.js"
+        "./e4e1df": "./dist/concrete/e4e1df.js",
+        "./dd2554": "./dist/concrete/dd2554.js"
     },
     "dependencies": {
         "@bradthomasbrown/ecdsa": "^2.0.2",