@inco/js 0.1.11 → 0.1.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -40,8 +40,15 @@ var __export = (target, all) => {
40
40
  });
41
41
  };
42
42
  var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
43
+ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
44
+ get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
45
+ }) : x)(function(x) {
46
+ if (typeof require !== "undefined")
47
+ return require.apply(this, arguments);
48
+ throw Error('Dynamic require of "' + x + '" is not supported');
49
+ });
43
50
 
44
- // node_modules/viem/_esm/utils/data/isHex.js
51
+ // ../node_modules/viem/_esm/utils/data/isHex.js
45
52
  function isHex(value6, { strict: strict2 = true } = {}) {
46
53
  if (!value6)
47
54
  return false;
@@ -50,19 +57,18 @@ function isHex(value6, { strict: strict2 = true } = {}) {
50
57
  return strict2 ? /^0x[0-9a-fA-F]*$/.test(value6) : value6.startsWith("0x");
51
58
  }
52
59
 
53
- // node_modules/viem/_esm/utils/data/size.js
60
+ // ../node_modules/viem/_esm/utils/data/size.js
54
61
  function size21(value6) {
55
62
  if (isHex(value6, { strict: false }))
56
63
  return Math.ceil((value6.length - 2) / 2);
57
64
  return value6.length;
58
65
  }
59
- var init_size = () => {
60
- };
66
+ var init_size = () => {};
61
67
 
62
- // node_modules/viem/_esm/errors/version.js
63
- var version = "2.22.23";
68
+ // ../node_modules/viem/_esm/errors/version.js
69
+ var version = "2.24.3";
64
70
 
65
- // node_modules/viem/_esm/errors/base.js
71
+ // ../node_modules/viem/_esm/errors/base.js
66
72
  function walk(err, fn) {
67
73
  if (fn?.(err))
68
74
  return err;
@@ -150,7 +156,7 @@ var init_base = __esm(() => {
150
156
  };
151
157
  });
152
158
 
153
- // node_modules/viem/_esm/errors/abi.js
159
+ // ../node_modules/viem/_esm/errors/abi.js
154
160
  var AbiEncodingLengthMismatchError, BytesSizeMismatchError, UnsupportedPackedAbiType;
155
161
  var init_abi = __esm(() => {
156
162
  init_base();
@@ -180,15 +186,10 @@ var init_abi = __esm(() => {
180
186
  };
181
187
  });
182
188
 
183
- // node_modules/viem/_esm/errors/data.js
184
- var SliceOffsetOutOfBoundsError, SizeExceedsPaddingSizeError;
189
+ // ../node_modules/viem/_esm/errors/data.js
190
+ var SizeExceedsPaddingSizeError;
185
191
  var init_data = __esm(() => {
186
192
  init_base();
187
- SliceOffsetOutOfBoundsError = class SliceOffsetOutOfBoundsError extends BaseError {
188
- constructor({ offset, position, size: size22 }) {
189
- super(`Slice ${position === "start" ? "starting" : "ending"} at offset "${offset}" is out-of-bounds (size: ${size22}).`, { name: "SliceOffsetOutOfBoundsError" });
190
- }
191
- };
192
193
  SizeExceedsPaddingSizeError = class SizeExceedsPaddingSizeError extends BaseError {
193
194
  constructor({ size: size22, targetSize, type: type2 }) {
194
195
  super(`${type2.charAt(0).toUpperCase()}${type2.slice(1).toLowerCase()} size (${size22}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
@@ -196,7 +197,7 @@ var init_data = __esm(() => {
196
197
  };
197
198
  });
198
199
 
199
- // node_modules/viem/_esm/utils/data/pad.js
200
+ // ../node_modules/viem/_esm/utils/data/pad.js
200
201
  function pad(hexOrBytes, { dir: dir2, size: size22 = 32 } = {}) {
201
202
  if (typeof hexOrBytes === "string")
202
203
  return padHex(hexOrBytes, { dir: dir2, size: size22 });
@@ -234,7 +235,7 @@ var init_pad = __esm(() => {
234
235
  init_data();
235
236
  });
236
237
 
237
- // node_modules/viem/_esm/errors/encoding.js
238
+ // ../node_modules/viem/_esm/errors/encoding.js
238
239
  var IntegerOutOfRangeError, SizeOverflowError;
239
240
  var init_encoding = __esm(() => {
240
241
  init_base();
@@ -250,26 +251,7 @@ var init_encoding = __esm(() => {
250
251
  };
251
252
  });
252
253
 
253
- // node_modules/viem/_esm/utils/data/trim.js
254
- function trim(hexOrBytes, { dir: dir2 = "left" } = {}) {
255
- let data = typeof hexOrBytes === "string" ? hexOrBytes.replace("0x", "") : hexOrBytes;
256
- let sliceLength = 0;
257
- for (let i = 0;i < data.length - 1; i++) {
258
- if (data[dir2 === "left" ? i : data.length - i - 1].toString() === "0")
259
- sliceLength++;
260
- else
261
- break;
262
- }
263
- data = dir2 === "left" ? data.slice(sliceLength) : data.slice(0, data.length - sliceLength);
264
- if (typeof hexOrBytes === "string") {
265
- if (data.length === 1 && dir2 === "right")
266
- data = `${data}0`;
267
- return `0x${data.length % 2 === 1 ? `0${data}` : data}`;
268
- }
269
- return data;
270
- }
271
-
272
- // node_modules/viem/_esm/utils/encoding/fromHex.js
254
+ // ../node_modules/viem/_esm/utils/encoding/fromHex.js
273
255
  function assertSize(hexOrBytes, { size: size22 }) {
274
256
  if (size21(hexOrBytes) > size22)
275
257
  throw new SizeOverflowError({
@@ -277,28 +259,12 @@ function assertSize(hexOrBytes, { size: size22 }) {
277
259
  maxSize: size22
278
260
  });
279
261
  }
280
- function hexToBigInt(hex, opts = {}) {
281
- const { signed } = opts;
282
- if (opts.size)
283
- assertSize(hex, { size: opts.size });
284
- const value6 = BigInt(hex);
285
- if (!signed)
286
- return value6;
287
- const size22 = (hex.length - 2) / 2;
288
- const max6 = (1n << BigInt(size22) * 8n - 1n) - 1n;
289
- if (value6 <= max6)
290
- return value6;
291
- return value6 - BigInt(`0x${"f".padStart(size22 * 2, "f")}`) - 1n;
292
- }
293
- function hexToNumber(hex, opts = {}) {
294
- return Number(hexToBigInt(hex, opts));
295
- }
296
262
  var init_fromHex = __esm(() => {
297
263
  init_encoding();
298
264
  init_size();
299
265
  });
300
266
 
301
- // node_modules/viem/_esm/utils/encoding/toHex.js
267
+ // ../node_modules/viem/_esm/utils/encoding/toHex.js
302
268
  function toHex(value6, opts = {}) {
303
269
  if (typeof value6 === "number" || typeof value6 === "bigint")
304
270
  return numberToHex(value6, opts);
@@ -370,7 +336,7 @@ var init_toHex = __esm(() => {
370
336
  encoder2 = /* @__PURE__ */ new TextEncoder;
371
337
  });
372
338
 
373
- // node_modules/viem/_esm/utils/encoding/toBytes.js
339
+ // ../node_modules/viem/_esm/utils/encoding/toBytes.js
374
340
  function toBytes(value6, opts = {}) {
375
341
  if (typeof value6 === "number" || typeof value6 === "bigint")
376
342
  return numberToBytes(value6, opts);
@@ -475,8 +441,7 @@ function aoutput(out, instance) {
475
441
  throw new Error("digestInto() expects output buffer of length at least " + min4);
476
442
  }
477
443
  }
478
- var init__assert = () => {
479
- };
444
+ var init__assert = () => {};
480
445
 
481
446
  // ../node_modules/@noble/hashes/esm/_u64.js
482
447
  function fromBig(n, le = false) {
@@ -503,12 +468,6 @@ var init__u64 = __esm(() => {
503
468
  function u32(arr) {
504
469
  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
505
470
  }
506
- function createView(arr) {
507
- return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
508
- }
509
- function rotr(word, shift2) {
510
- return word << 32 - shift2 | word >>> shift2;
511
- }
512
471
  function byteSwap(word) {
513
472
  return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
514
473
  }
@@ -744,7 +703,7 @@ var init_sha3 = __esm(() => {
744
703
  shake256 = /* @__PURE__ */ genShake(31, 136, 256 / 8);
745
704
  });
746
705
 
747
- // node_modules/viem/_esm/utils/hash/keccak256.js
706
+ // ../node_modules/viem/_esm/utils/hash/keccak256.js
748
707
  function keccak256(value6, to_) {
749
708
  const to = to_ || "hex";
750
709
  const bytes = keccak_256(isHex(value6, { strict: false }) ? toBytes(value6) : value6);
@@ -758,7 +717,7 @@ var init_keccak256 = __esm(() => {
758
717
  init_toHex();
759
718
  });
760
719
 
761
- // node_modules/viem/_esm/errors/address.js
720
+ // ../node_modules/viem/_esm/errors/address.js
762
721
  var InvalidAddressError;
763
722
  var init_address = __esm(() => {
764
723
  init_base();
@@ -775,7 +734,7 @@ var init_address = __esm(() => {
775
734
  };
776
735
  });
777
736
 
778
- // node_modules/viem/_esm/utils/lru.js
737
+ // ../node_modules/viem/_esm/utils/lru.js
779
738
  var LruMap;
780
739
  var init_lru = __esm(() => {
781
740
  LruMap = class LruMap extends Map {
@@ -809,7 +768,7 @@ var init_lru = __esm(() => {
809
768
  };
810
769
  });
811
770
 
812
- // node_modules/viem/_esm/utils/address/getAddress.js
771
+ // ../node_modules/viem/_esm/utils/address/getAddress.js
813
772
  function checksumAddress(address_, chainId) {
814
773
  if (checksumAddressCache.has(`${address_}.${chainId}`))
815
774
  return checksumAddressCache.get(`${address_}.${chainId}`);
@@ -836,7 +795,7 @@ var init_getAddress = __esm(() => {
836
795
  checksumAddressCache = /* @__PURE__ */ new LruMap(8192);
837
796
  });
838
797
 
839
- // node_modules/viem/_esm/utils/address/isAddress.js
798
+ // ../node_modules/viem/_esm/utils/address/isAddress.js
840
799
  function isAddress(address, options) {
841
800
  const { strict: strict2 = true } = options ?? {};
842
801
  const cacheKey = `${address}.${strict2}`;
@@ -862,58 +821,12 @@ var init_isAddress = __esm(() => {
862
821
  isAddressCache = /* @__PURE__ */ new LruMap(8192);
863
822
  });
864
823
 
865
- // node_modules/viem/_esm/utils/data/concat.js
824
+ // ../node_modules/viem/_esm/utils/data/concat.js
866
825
  function concatHex(values7) {
867
826
  return `0x${values7.reduce((acc, x) => acc + x.replace("0x", ""), "")}`;
868
827
  }
869
828
 
870
- // node_modules/viem/_esm/utils/data/slice.js
871
- function slice(value6, start5, end6, { strict: strict2 } = {}) {
872
- if (isHex(value6, { strict: false }))
873
- return sliceHex(value6, start5, end6, {
874
- strict: strict2
875
- });
876
- return sliceBytes(value6, start5, end6, {
877
- strict: strict2
878
- });
879
- }
880
- function assertStartOffset(value6, start5) {
881
- if (typeof start5 === "number" && start5 > 0 && start5 > size21(value6) - 1)
882
- throw new SliceOffsetOutOfBoundsError({
883
- offset: start5,
884
- position: "start",
885
- size: size21(value6)
886
- });
887
- }
888
- function assertEndOffset(value6, start5, end6) {
889
- if (typeof start5 === "number" && typeof end6 === "number" && size21(value6) !== end6 - start5) {
890
- throw new SliceOffsetOutOfBoundsError({
891
- offset: end6,
892
- position: "end",
893
- size: size21(value6)
894
- });
895
- }
896
- }
897
- function sliceBytes(value_, start5, end6, { strict: strict2 } = {}) {
898
- assertStartOffset(value_, start5);
899
- const value6 = value_.slice(start5, end6);
900
- if (strict2)
901
- assertEndOffset(value6, start5, end6);
902
- return value6;
903
- }
904
- function sliceHex(value_, start5, end6, { strict: strict2 } = {}) {
905
- assertStartOffset(value_, start5);
906
- const value6 = `0x${value_.replace("0x", "").slice((start5 ?? 0) * 2, (end6 ?? value_.length) * 2)}`;
907
- if (strict2)
908
- assertEndOffset(value6, start5, end6);
909
- return value6;
910
- }
911
- var init_slice = __esm(() => {
912
- init_data();
913
- init_size();
914
- });
915
-
916
- // node_modules/viem/_esm/utils/regex.js
829
+ // ../node_modules/viem/_esm/utils/regex.js
917
830
  var arrayRegex, bytesRegex, integerRegex;
918
831
  var init_regex = __esm(() => {
919
832
  arrayRegex = /^(.*)\[([0-9]*)\]$/;
@@ -921,861 +834,6 @@ var init_regex = __esm(() => {
921
834
  integerRegex = /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
922
835
  });
923
836
 
924
- // node_modules/viem/_esm/errors/cursor.js
925
- var NegativeOffsetError, PositionOutOfBoundsError, RecursiveReadLimitExceededError;
926
- var init_cursor = __esm(() => {
927
- init_base();
928
- NegativeOffsetError = class NegativeOffsetError extends BaseError {
929
- constructor({ offset }) {
930
- super(`Offset \`${offset}\` cannot be negative.`, {
931
- name: "NegativeOffsetError"
932
- });
933
- }
934
- };
935
- PositionOutOfBoundsError = class PositionOutOfBoundsError extends BaseError {
936
- constructor({ length: length4, position }) {
937
- super(`Position \`${position}\` is out of bounds (\`0 < position < ${length4}\`).`, { name: "PositionOutOfBoundsError" });
938
- }
939
- };
940
- RecursiveReadLimitExceededError = class RecursiveReadLimitExceededError extends BaseError {
941
- constructor({ count: count5, limit }) {
942
- super(`Recursive read limit of \`${limit}\` exceeded (recursive read count: \`${count5}\`).`, { name: "RecursiveReadLimitExceededError" });
943
- }
944
- };
945
- });
946
-
947
- // node_modules/viem/_esm/utils/cursor.js
948
- function createCursor(bytes, { recursiveReadLimit = 8192 } = {}) {
949
- const cursor = Object.create(staticCursor);
950
- cursor.bytes = bytes;
951
- cursor.dataView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
952
- cursor.positionReadCount = new Map;
953
- cursor.recursiveReadLimit = recursiveReadLimit;
954
- return cursor;
955
- }
956
- var staticCursor;
957
- var init_cursor2 = __esm(() => {
958
- init_cursor();
959
- staticCursor = {
960
- bytes: new Uint8Array,
961
- dataView: new DataView(new ArrayBuffer(0)),
962
- position: 0,
963
- positionReadCount: new Map,
964
- recursiveReadCount: 0,
965
- recursiveReadLimit: Number.POSITIVE_INFINITY,
966
- assertReadLimit() {
967
- if (this.recursiveReadCount >= this.recursiveReadLimit)
968
- throw new RecursiveReadLimitExceededError({
969
- count: this.recursiveReadCount + 1,
970
- limit: this.recursiveReadLimit
971
- });
972
- },
973
- assertPosition(position) {
974
- if (position < 0 || position > this.bytes.length - 1)
975
- throw new PositionOutOfBoundsError({
976
- length: this.bytes.length,
977
- position
978
- });
979
- },
980
- decrementPosition(offset) {
981
- if (offset < 0)
982
- throw new NegativeOffsetError({ offset });
983
- const position = this.position - offset;
984
- this.assertPosition(position);
985
- this.position = position;
986
- },
987
- getReadCount(position) {
988
- return this.positionReadCount.get(position || this.position) || 0;
989
- },
990
- incrementPosition(offset) {
991
- if (offset < 0)
992
- throw new NegativeOffsetError({ offset });
993
- const position = this.position + offset;
994
- this.assertPosition(position);
995
- this.position = position;
996
- },
997
- inspectByte(position_) {
998
- const position = position_ ?? this.position;
999
- this.assertPosition(position);
1000
- return this.bytes[position];
1001
- },
1002
- inspectBytes(length4, position_) {
1003
- const position = position_ ?? this.position;
1004
- this.assertPosition(position + length4 - 1);
1005
- return this.bytes.subarray(position, position + length4);
1006
- },
1007
- inspectUint8(position_) {
1008
- const position = position_ ?? this.position;
1009
- this.assertPosition(position);
1010
- return this.bytes[position];
1011
- },
1012
- inspectUint16(position_) {
1013
- const position = position_ ?? this.position;
1014
- this.assertPosition(position + 1);
1015
- return this.dataView.getUint16(position);
1016
- },
1017
- inspectUint24(position_) {
1018
- const position = position_ ?? this.position;
1019
- this.assertPosition(position + 2);
1020
- return (this.dataView.getUint16(position) << 8) + this.dataView.getUint8(position + 2);
1021
- },
1022
- inspectUint32(position_) {
1023
- const position = position_ ?? this.position;
1024
- this.assertPosition(position + 3);
1025
- return this.dataView.getUint32(position);
1026
- },
1027
- pushByte(byte) {
1028
- this.assertPosition(this.position);
1029
- this.bytes[this.position] = byte;
1030
- this.position++;
1031
- },
1032
- pushBytes(bytes) {
1033
- this.assertPosition(this.position + bytes.length - 1);
1034
- this.bytes.set(bytes, this.position);
1035
- this.position += bytes.length;
1036
- },
1037
- pushUint8(value6) {
1038
- this.assertPosition(this.position);
1039
- this.bytes[this.position] = value6;
1040
- this.position++;
1041
- },
1042
- pushUint16(value6) {
1043
- this.assertPosition(this.position + 1);
1044
- this.dataView.setUint16(this.position, value6);
1045
- this.position += 2;
1046
- },
1047
- pushUint24(value6) {
1048
- this.assertPosition(this.position + 2);
1049
- this.dataView.setUint16(this.position, value6 >> 8);
1050
- this.dataView.setUint8(this.position + 2, value6 & ~4294967040);
1051
- this.position += 3;
1052
- },
1053
- pushUint32(value6) {
1054
- this.assertPosition(this.position + 3);
1055
- this.dataView.setUint32(this.position, value6);
1056
- this.position += 4;
1057
- },
1058
- readByte() {
1059
- this.assertReadLimit();
1060
- this._touch();
1061
- const value6 = this.inspectByte();
1062
- this.position++;
1063
- return value6;
1064
- },
1065
- readBytes(length4, size22) {
1066
- this.assertReadLimit();
1067
- this._touch();
1068
- const value6 = this.inspectBytes(length4);
1069
- this.position += size22 ?? length4;
1070
- return value6;
1071
- },
1072
- readUint8() {
1073
- this.assertReadLimit();
1074
- this._touch();
1075
- const value6 = this.inspectUint8();
1076
- this.position += 1;
1077
- return value6;
1078
- },
1079
- readUint16() {
1080
- this.assertReadLimit();
1081
- this._touch();
1082
- const value6 = this.inspectUint16();
1083
- this.position += 2;
1084
- return value6;
1085
- },
1086
- readUint24() {
1087
- this.assertReadLimit();
1088
- this._touch();
1089
- const value6 = this.inspectUint24();
1090
- this.position += 3;
1091
- return value6;
1092
- },
1093
- readUint32() {
1094
- this.assertReadLimit();
1095
- this._touch();
1096
- const value6 = this.inspectUint32();
1097
- this.position += 4;
1098
- return value6;
1099
- },
1100
- get remaining() {
1101
- return this.bytes.length - this.position;
1102
- },
1103
- setPosition(position) {
1104
- const oldPosition = this.position;
1105
- this.assertPosition(position);
1106
- this.position = position;
1107
- return () => this.position = oldPosition;
1108
- },
1109
- _touch() {
1110
- if (this.recursiveReadLimit === Number.POSITIVE_INFINITY)
1111
- return;
1112
- const count5 = this.getReadCount();
1113
- this.positionReadCount.set(this.position, count5 + 1);
1114
- if (count5 > 0)
1115
- this.recursiveReadCount++;
1116
- }
1117
- };
1118
- });
1119
-
1120
- // node_modules/viem/_esm/constants/unit.js
1121
- var gweiUnits;
1122
- var init_unit = __esm(() => {
1123
- gweiUnits = {
1124
- ether: -9,
1125
- wei: 9
1126
- };
1127
- });
1128
-
1129
- // node_modules/viem/_esm/utils/unit/formatUnits.js
1130
- function formatUnits(value6, decimals) {
1131
- let display = value6.toString();
1132
- const negative2 = display.startsWith("-");
1133
- if (negative2)
1134
- display = display.slice(1);
1135
- display = display.padStart(decimals, "0");
1136
- let [integer3, fraction] = [
1137
- display.slice(0, display.length - decimals),
1138
- display.slice(display.length - decimals)
1139
- ];
1140
- fraction = fraction.replace(/(0+)$/, "");
1141
- return `${negative2 ? "-" : ""}${integer3 || "0"}${fraction ? `.${fraction}` : ""}`;
1142
- }
1143
-
1144
- // node_modules/viem/_esm/utils/unit/formatGwei.js
1145
- function formatGwei(wei, unit = "wei") {
1146
- return formatUnits(wei, gweiUnits[unit]);
1147
- }
1148
- var init_formatGwei = __esm(() => {
1149
- init_unit();
1150
- });
1151
-
1152
- // node_modules/viem/_esm/errors/transaction.js
1153
- function prettyPrint(args2) {
1154
- const entries3 = Object.entries(args2).map(([key, value6]) => {
1155
- if (value6 === undefined || value6 === false)
1156
- return null;
1157
- return [key, value6];
1158
- }).filter(Boolean);
1159
- const maxLength2 = entries3.reduce((acc, [key]) => Math.max(acc, key.length), 0);
1160
- return entries3.map(([key, value6]) => ` ${`${key}:`.padEnd(maxLength2 + 1)} ${value6}`).join(`
1161
- `);
1162
- }
1163
- var InvalidLegacyVError, InvalidSerializableTransactionError, InvalidStorageKeySizeError;
1164
- var init_transaction = __esm(() => {
1165
- init_base();
1166
- InvalidLegacyVError = class InvalidLegacyVError extends BaseError {
1167
- constructor({ v }) {
1168
- super(`Invalid \`v\` value "${v}". Expected 27 or 28.`, {
1169
- name: "InvalidLegacyVError"
1170
- });
1171
- }
1172
- };
1173
- InvalidSerializableTransactionError = class InvalidSerializableTransactionError extends BaseError {
1174
- constructor({ transaction }) {
1175
- super("Cannot infer a transaction type from provided transaction.", {
1176
- metaMessages: [
1177
- "Provided Transaction:",
1178
- "{",
1179
- prettyPrint(transaction),
1180
- "}",
1181
- "",
1182
- "To infer the type, either provide:",
1183
- "- a `type` to the Transaction, or",
1184
- "- an EIP-1559 Transaction with `maxFeePerGas`, or",
1185
- "- an EIP-2930 Transaction with `gasPrice` & `accessList`, or",
1186
- "- an EIP-4844 Transaction with `blobs`, `blobVersionedHashes`, `sidecars`, or",
1187
- "- an EIP-7702 Transaction with `authorizationList`, or",
1188
- "- a Legacy Transaction with `gasPrice`"
1189
- ],
1190
- name: "InvalidSerializableTransactionError"
1191
- });
1192
- }
1193
- };
1194
- InvalidStorageKeySizeError = class InvalidStorageKeySizeError extends BaseError {
1195
- constructor({ storageKey }) {
1196
- super(`Size for storage key "${storageKey}" is invalid. Expected 32 bytes. Got ${Math.floor((storageKey.length - 2) / 2)} bytes.`, { name: "InvalidStorageKeySizeError" });
1197
- }
1198
- };
1199
- });
1200
-
1201
- // node_modules/viem/_esm/errors/node.js
1202
- var ExecutionRevertedError, FeeCapTooHighError, FeeCapTooLowError, NonceTooHighError, NonceTooLowError, NonceMaxValueError, InsufficientFundsError, IntrinsicGasTooHighError, IntrinsicGasTooLowError, TransactionTypeNotSupportedError, TipAboveFeeCapError;
1203
- var init_node = __esm(() => {
1204
- init_formatGwei();
1205
- init_base();
1206
- ExecutionRevertedError = class ExecutionRevertedError extends BaseError {
1207
- constructor({ cause: cause2, message } = {}) {
1208
- const reason = message?.replace("execution reverted: ", "")?.replace("execution reverted", "");
1209
- super(`Execution reverted ${reason ? `with reason: ${reason}` : "for an unknown reason"}.`, {
1210
- cause: cause2,
1211
- name: "ExecutionRevertedError"
1212
- });
1213
- }
1214
- };
1215
- Object.defineProperty(ExecutionRevertedError, "code", {
1216
- enumerable: true,
1217
- configurable: true,
1218
- writable: true,
1219
- value: 3
1220
- });
1221
- Object.defineProperty(ExecutionRevertedError, "nodeMessage", {
1222
- enumerable: true,
1223
- configurable: true,
1224
- writable: true,
1225
- value: /execution reverted/
1226
- });
1227
- FeeCapTooHighError = class FeeCapTooHighError extends BaseError {
1228
- constructor({ cause: cause2, maxFeePerGas } = {}) {
1229
- super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}) cannot be higher than the maximum allowed value (2^256-1).`, {
1230
- cause: cause2,
1231
- name: "FeeCapTooHighError"
1232
- });
1233
- }
1234
- };
1235
- Object.defineProperty(FeeCapTooHighError, "nodeMessage", {
1236
- enumerable: true,
1237
- configurable: true,
1238
- writable: true,
1239
- value: /max fee per gas higher than 2\^256-1|fee cap higher than 2\^256-1/
1240
- });
1241
- FeeCapTooLowError = class FeeCapTooLowError extends BaseError {
1242
- constructor({ cause: cause2, maxFeePerGas } = {}) {
1243
- super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)}` : ""} gwei) cannot be lower than the block base fee.`, {
1244
- cause: cause2,
1245
- name: "FeeCapTooLowError"
1246
- });
1247
- }
1248
- };
1249
- Object.defineProperty(FeeCapTooLowError, "nodeMessage", {
1250
- enumerable: true,
1251
- configurable: true,
1252
- writable: true,
1253
- value: /max fee per gas less than block base fee|fee cap less than block base fee|transaction is outdated/
1254
- });
1255
- NonceTooHighError = class NonceTooHighError extends BaseError {
1256
- constructor({ cause: cause2, nonce } = {}) {
1257
- super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is higher than the next one expected.`, { cause: cause2, name: "NonceTooHighError" });
1258
- }
1259
- };
1260
- Object.defineProperty(NonceTooHighError, "nodeMessage", {
1261
- enumerable: true,
1262
- configurable: true,
1263
- writable: true,
1264
- value: /nonce too high/
1265
- });
1266
- NonceTooLowError = class NonceTooLowError extends BaseError {
1267
- constructor({ cause: cause2, nonce } = {}) {
1268
- super([
1269
- `Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is lower than the current nonce of the account.`,
1270
- "Try increasing the nonce or find the latest nonce with `getTransactionCount`."
1271
- ].join(`
1272
- `), { cause: cause2, name: "NonceTooLowError" });
1273
- }
1274
- };
1275
- Object.defineProperty(NonceTooLowError, "nodeMessage", {
1276
- enumerable: true,
1277
- configurable: true,
1278
- writable: true,
1279
- value: /nonce too low|transaction already imported|already known/
1280
- });
1281
- NonceMaxValueError = class NonceMaxValueError extends BaseError {
1282
- constructor({ cause: cause2, nonce } = {}) {
1283
- super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}exceeds the maximum allowed nonce.`, { cause: cause2, name: "NonceMaxValueError" });
1284
- }
1285
- };
1286
- Object.defineProperty(NonceMaxValueError, "nodeMessage", {
1287
- enumerable: true,
1288
- configurable: true,
1289
- writable: true,
1290
- value: /nonce has max value/
1291
- });
1292
- InsufficientFundsError = class InsufficientFundsError extends BaseError {
1293
- constructor({ cause: cause2 } = {}) {
1294
- super([
1295
- "The total cost (gas * gas fee + value) of executing this transaction exceeds the balance of the account."
1296
- ].join(`
1297
- `), {
1298
- cause: cause2,
1299
- metaMessages: [
1300
- "This error could arise when the account does not have enough funds to:",
1301
- " - pay for the total gas fee,",
1302
- " - pay for the value to send.",
1303
- " ",
1304
- "The cost of the transaction is calculated as `gas * gas fee + value`, where:",
1305
- " - `gas` is the amount of gas needed for transaction to execute,",
1306
- " - `gas fee` is the gas fee,",
1307
- " - `value` is the amount of ether to send to the recipient."
1308
- ],
1309
- name: "InsufficientFundsError"
1310
- });
1311
- }
1312
- };
1313
- Object.defineProperty(InsufficientFundsError, "nodeMessage", {
1314
- enumerable: true,
1315
- configurable: true,
1316
- writable: true,
1317
- value: /insufficient funds|exceeds transaction sender account balance/
1318
- });
1319
- IntrinsicGasTooHighError = class IntrinsicGasTooHighError extends BaseError {
1320
- constructor({ cause: cause2, gas } = {}) {
1321
- super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction exceeds the limit allowed for the block.`, {
1322
- cause: cause2,
1323
- name: "IntrinsicGasTooHighError"
1324
- });
1325
- }
1326
- };
1327
- Object.defineProperty(IntrinsicGasTooHighError, "nodeMessage", {
1328
- enumerable: true,
1329
- configurable: true,
1330
- writable: true,
1331
- value: /intrinsic gas too high|gas limit reached/
1332
- });
1333
- IntrinsicGasTooLowError = class IntrinsicGasTooLowError extends BaseError {
1334
- constructor({ cause: cause2, gas } = {}) {
1335
- super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction is too low.`, {
1336
- cause: cause2,
1337
- name: "IntrinsicGasTooLowError"
1338
- });
1339
- }
1340
- };
1341
- Object.defineProperty(IntrinsicGasTooLowError, "nodeMessage", {
1342
- enumerable: true,
1343
- configurable: true,
1344
- writable: true,
1345
- value: /intrinsic gas too low/
1346
- });
1347
- TransactionTypeNotSupportedError = class TransactionTypeNotSupportedError extends BaseError {
1348
- constructor({ cause: cause2 }) {
1349
- super("The transaction type is not supported for this chain.", {
1350
- cause: cause2,
1351
- name: "TransactionTypeNotSupportedError"
1352
- });
1353
- }
1354
- };
1355
- Object.defineProperty(TransactionTypeNotSupportedError, "nodeMessage", {
1356
- enumerable: true,
1357
- configurable: true,
1358
- writable: true,
1359
- value: /transaction type not valid/
1360
- });
1361
- TipAboveFeeCapError = class TipAboveFeeCapError extends BaseError {
1362
- constructor({ cause: cause2, maxPriorityFeePerGas, maxFeePerGas } = {}) {
1363
- super([
1364
- `The provided tip (\`maxPriorityFeePerGas\`${maxPriorityFeePerGas ? ` = ${formatGwei(maxPriorityFeePerGas)} gwei` : ""}) cannot be higher than the fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}).`
1365
- ].join(`
1366
- `), {
1367
- cause: cause2,
1368
- name: "TipAboveFeeCapError"
1369
- });
1370
- }
1371
- };
1372
- Object.defineProperty(TipAboveFeeCapError, "nodeMessage", {
1373
- enumerable: true,
1374
- configurable: true,
1375
- writable: true,
1376
- value: /max priority fee per gas higher than max fee per gas|tip higher than fee cap/
1377
- });
1378
- });
1379
-
1380
- // node_modules/viem/_esm/utils/formatters/formatter.js
1381
- function defineFormatter(type2, format7) {
1382
- return ({ exclude: exclude3, format: overrides }) => {
1383
- return {
1384
- exclude: exclude3,
1385
- format: (args2) => {
1386
- const formatted = format7(args2);
1387
- if (exclude3) {
1388
- for (const key of exclude3) {
1389
- delete formatted[key];
1390
- }
1391
- }
1392
- return {
1393
- ...formatted,
1394
- ...overrides(args2)
1395
- };
1396
- },
1397
- type: type2
1398
- };
1399
- };
1400
- }
1401
-
1402
- // node_modules/viem/_esm/constants/number.js
1403
- var maxInt8, maxInt16, maxInt24, maxInt32, maxInt40, maxInt48, maxInt56, maxInt64, maxInt72, maxInt80, maxInt88, maxInt96, maxInt104, maxInt112, maxInt120, maxInt128, maxInt136, maxInt144, maxInt152, maxInt160, maxInt168, maxInt176, maxInt184, maxInt192, maxInt200, maxInt208, maxInt216, maxInt224, maxInt232, maxInt240, maxInt248, maxInt256, minInt8, minInt16, minInt24, minInt32, minInt40, minInt48, minInt56, minInt64, minInt72, minInt80, minInt88, minInt96, minInt104, minInt112, minInt120, minInt128, minInt136, minInt144, minInt152, minInt160, minInt168, minInt176, minInt184, minInt192, minInt200, minInt208, minInt216, minInt224, minInt232, minInt240, minInt248, minInt256, maxUint8, maxUint16, maxUint24, maxUint32, maxUint40, maxUint48, maxUint56, maxUint64, maxUint72, maxUint80, maxUint88, maxUint96, maxUint104, maxUint112, maxUint120, maxUint128, maxUint136, maxUint144, maxUint152, maxUint160, maxUint168, maxUint176, maxUint184, maxUint192, maxUint200, maxUint208, maxUint216, maxUint224, maxUint232, maxUint240, maxUint248, maxUint256;
1404
- var init_number = __esm(() => {
1405
- maxInt8 = 2n ** (8n - 1n) - 1n;
1406
- maxInt16 = 2n ** (16n - 1n) - 1n;
1407
- maxInt24 = 2n ** (24n - 1n) - 1n;
1408
- maxInt32 = 2n ** (32n - 1n) - 1n;
1409
- maxInt40 = 2n ** (40n - 1n) - 1n;
1410
- maxInt48 = 2n ** (48n - 1n) - 1n;
1411
- maxInt56 = 2n ** (56n - 1n) - 1n;
1412
- maxInt64 = 2n ** (64n - 1n) - 1n;
1413
- maxInt72 = 2n ** (72n - 1n) - 1n;
1414
- maxInt80 = 2n ** (80n - 1n) - 1n;
1415
- maxInt88 = 2n ** (88n - 1n) - 1n;
1416
- maxInt96 = 2n ** (96n - 1n) - 1n;
1417
- maxInt104 = 2n ** (104n - 1n) - 1n;
1418
- maxInt112 = 2n ** (112n - 1n) - 1n;
1419
- maxInt120 = 2n ** (120n - 1n) - 1n;
1420
- maxInt128 = 2n ** (128n - 1n) - 1n;
1421
- maxInt136 = 2n ** (136n - 1n) - 1n;
1422
- maxInt144 = 2n ** (144n - 1n) - 1n;
1423
- maxInt152 = 2n ** (152n - 1n) - 1n;
1424
- maxInt160 = 2n ** (160n - 1n) - 1n;
1425
- maxInt168 = 2n ** (168n - 1n) - 1n;
1426
- maxInt176 = 2n ** (176n - 1n) - 1n;
1427
- maxInt184 = 2n ** (184n - 1n) - 1n;
1428
- maxInt192 = 2n ** (192n - 1n) - 1n;
1429
- maxInt200 = 2n ** (200n - 1n) - 1n;
1430
- maxInt208 = 2n ** (208n - 1n) - 1n;
1431
- maxInt216 = 2n ** (216n - 1n) - 1n;
1432
- maxInt224 = 2n ** (224n - 1n) - 1n;
1433
- maxInt232 = 2n ** (232n - 1n) - 1n;
1434
- maxInt240 = 2n ** (240n - 1n) - 1n;
1435
- maxInt248 = 2n ** (248n - 1n) - 1n;
1436
- maxInt256 = 2n ** (256n - 1n) - 1n;
1437
- minInt8 = -(2n ** (8n - 1n));
1438
- minInt16 = -(2n ** (16n - 1n));
1439
- minInt24 = -(2n ** (24n - 1n));
1440
- minInt32 = -(2n ** (32n - 1n));
1441
- minInt40 = -(2n ** (40n - 1n));
1442
- minInt48 = -(2n ** (48n - 1n));
1443
- minInt56 = -(2n ** (56n - 1n));
1444
- minInt64 = -(2n ** (64n - 1n));
1445
- minInt72 = -(2n ** (72n - 1n));
1446
- minInt80 = -(2n ** (80n - 1n));
1447
- minInt88 = -(2n ** (88n - 1n));
1448
- minInt96 = -(2n ** (96n - 1n));
1449
- minInt104 = -(2n ** (104n - 1n));
1450
- minInt112 = -(2n ** (112n - 1n));
1451
- minInt120 = -(2n ** (120n - 1n));
1452
- minInt128 = -(2n ** (128n - 1n));
1453
- minInt136 = -(2n ** (136n - 1n));
1454
- minInt144 = -(2n ** (144n - 1n));
1455
- minInt152 = -(2n ** (152n - 1n));
1456
- minInt160 = -(2n ** (160n - 1n));
1457
- minInt168 = -(2n ** (168n - 1n));
1458
- minInt176 = -(2n ** (176n - 1n));
1459
- minInt184 = -(2n ** (184n - 1n));
1460
- minInt192 = -(2n ** (192n - 1n));
1461
- minInt200 = -(2n ** (200n - 1n));
1462
- minInt208 = -(2n ** (208n - 1n));
1463
- minInt216 = -(2n ** (216n - 1n));
1464
- minInt224 = -(2n ** (224n - 1n));
1465
- minInt232 = -(2n ** (232n - 1n));
1466
- minInt240 = -(2n ** (240n - 1n));
1467
- minInt248 = -(2n ** (248n - 1n));
1468
- minInt256 = -(2n ** (256n - 1n));
1469
- maxUint8 = 2n ** 8n - 1n;
1470
- maxUint16 = 2n ** 16n - 1n;
1471
- maxUint24 = 2n ** 24n - 1n;
1472
- maxUint32 = 2n ** 32n - 1n;
1473
- maxUint40 = 2n ** 40n - 1n;
1474
- maxUint48 = 2n ** 48n - 1n;
1475
- maxUint56 = 2n ** 56n - 1n;
1476
- maxUint64 = 2n ** 64n - 1n;
1477
- maxUint72 = 2n ** 72n - 1n;
1478
- maxUint80 = 2n ** 80n - 1n;
1479
- maxUint88 = 2n ** 88n - 1n;
1480
- maxUint96 = 2n ** 96n - 1n;
1481
- maxUint104 = 2n ** 104n - 1n;
1482
- maxUint112 = 2n ** 112n - 1n;
1483
- maxUint120 = 2n ** 120n - 1n;
1484
- maxUint128 = 2n ** 128n - 1n;
1485
- maxUint136 = 2n ** 136n - 1n;
1486
- maxUint144 = 2n ** 144n - 1n;
1487
- maxUint152 = 2n ** 152n - 1n;
1488
- maxUint160 = 2n ** 160n - 1n;
1489
- maxUint168 = 2n ** 168n - 1n;
1490
- maxUint176 = 2n ** 176n - 1n;
1491
- maxUint184 = 2n ** 184n - 1n;
1492
- maxUint192 = 2n ** 192n - 1n;
1493
- maxUint200 = 2n ** 200n - 1n;
1494
- maxUint208 = 2n ** 208n - 1n;
1495
- maxUint216 = 2n ** 216n - 1n;
1496
- maxUint224 = 2n ** 224n - 1n;
1497
- maxUint232 = 2n ** 232n - 1n;
1498
- maxUint240 = 2n ** 240n - 1n;
1499
- maxUint248 = 2n ** 248n - 1n;
1500
- maxUint256 = 2n ** 256n - 1n;
1501
- });
1502
-
1503
- // ../node_modules/@noble/hashes/esm/_md.js
1504
- function setBigUint64(view, byteOffset, value6, isLE2) {
1505
- if (typeof view.setBigUint64 === "function")
1506
- return view.setBigUint64(byteOffset, value6, isLE2);
1507
- const _32n2 = BigInt(32);
1508
- const _u32_max = BigInt(4294967295);
1509
- const wh = Number(value6 >> _32n2 & _u32_max);
1510
- const wl = Number(value6 & _u32_max);
1511
- const h = isLE2 ? 4 : 0;
1512
- const l = isLE2 ? 0 : 4;
1513
- view.setUint32(byteOffset + h, wh, isLE2);
1514
- view.setUint32(byteOffset + l, wl, isLE2);
1515
- }
1516
- function Chi(a, b, c) {
1517
- return a & b ^ ~a & c;
1518
- }
1519
- function Maj(a, b, c) {
1520
- return a & b ^ a & c ^ b & c;
1521
- }
1522
- var HashMD;
1523
- var init__md = __esm(() => {
1524
- init__assert();
1525
- init_utils();
1526
- HashMD = class HashMD extends Hash {
1527
- constructor(blockLen, outputLen, padOffset, isLE2) {
1528
- super();
1529
- this.blockLen = blockLen;
1530
- this.outputLen = outputLen;
1531
- this.padOffset = padOffset;
1532
- this.isLE = isLE2;
1533
- this.finished = false;
1534
- this.length = 0;
1535
- this.pos = 0;
1536
- this.destroyed = false;
1537
- this.buffer = new Uint8Array(blockLen);
1538
- this.view = createView(this.buffer);
1539
- }
1540
- update(data) {
1541
- aexists(this);
1542
- const { view, buffer: buffer3, blockLen } = this;
1543
- data = toBytes2(data);
1544
- const len = data.length;
1545
- for (let pos = 0;pos < len; ) {
1546
- const take10 = Math.min(blockLen - this.pos, len - pos);
1547
- if (take10 === blockLen) {
1548
- const dataView = createView(data);
1549
- for (;blockLen <= len - pos; pos += blockLen)
1550
- this.process(dataView, pos);
1551
- continue;
1552
- }
1553
- buffer3.set(data.subarray(pos, pos + take10), this.pos);
1554
- this.pos += take10;
1555
- pos += take10;
1556
- if (this.pos === blockLen) {
1557
- this.process(view, 0);
1558
- this.pos = 0;
1559
- }
1560
- }
1561
- this.length += data.length;
1562
- this.roundClean();
1563
- return this;
1564
- }
1565
- digestInto(out) {
1566
- aexists(this);
1567
- aoutput(out, this);
1568
- this.finished = true;
1569
- const { buffer: buffer3, view, blockLen, isLE: isLE2 } = this;
1570
- let { pos } = this;
1571
- buffer3[pos++] = 128;
1572
- this.buffer.subarray(pos).fill(0);
1573
- if (this.padOffset > blockLen - pos) {
1574
- this.process(view, 0);
1575
- pos = 0;
1576
- }
1577
- for (let i = pos;i < blockLen; i++)
1578
- buffer3[i] = 0;
1579
- setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE2);
1580
- this.process(view, 0);
1581
- const oview = createView(out);
1582
- const len = this.outputLen;
1583
- if (len % 4)
1584
- throw new Error("_sha2: outputLen should be aligned to 32bit");
1585
- const outLen = len / 4;
1586
- const state = this.get();
1587
- if (outLen > state.length)
1588
- throw new Error("_sha2: outputLen bigger than state");
1589
- for (let i = 0;i < outLen; i++)
1590
- oview.setUint32(4 * i, state[i], isLE2);
1591
- }
1592
- digest() {
1593
- const { buffer: buffer3, outputLen } = this;
1594
- this.digestInto(buffer3);
1595
- const res = buffer3.slice(0, outputLen);
1596
- this.destroy();
1597
- return res;
1598
- }
1599
- _cloneInto(to) {
1600
- to || (to = new this.constructor);
1601
- to.set(...this.get());
1602
- const { blockLen, buffer: buffer3, length: length4, finished, destroyed, pos } = this;
1603
- to.length = length4;
1604
- to.pos = pos;
1605
- to.finished = finished;
1606
- to.destroyed = destroyed;
1607
- if (length4 % blockLen)
1608
- to.buffer.set(buffer3);
1609
- return to;
1610
- }
1611
- };
1612
- });
1613
-
1614
- // ../node_modules/@noble/hashes/esm/sha256.js
1615
- var SHA256_K, SHA256_IV, SHA256_W, SHA256, sha256;
1616
- var init_sha256 = __esm(() => {
1617
- init__md();
1618
- init_utils();
1619
- SHA256_K = /* @__PURE__ */ new Uint32Array([
1620
- 1116352408,
1621
- 1899447441,
1622
- 3049323471,
1623
- 3921009573,
1624
- 961987163,
1625
- 1508970993,
1626
- 2453635748,
1627
- 2870763221,
1628
- 3624381080,
1629
- 310598401,
1630
- 607225278,
1631
- 1426881987,
1632
- 1925078388,
1633
- 2162078206,
1634
- 2614888103,
1635
- 3248222580,
1636
- 3835390401,
1637
- 4022224774,
1638
- 264347078,
1639
- 604807628,
1640
- 770255983,
1641
- 1249150122,
1642
- 1555081692,
1643
- 1996064986,
1644
- 2554220882,
1645
- 2821834349,
1646
- 2952996808,
1647
- 3210313671,
1648
- 3336571891,
1649
- 3584528711,
1650
- 113926993,
1651
- 338241895,
1652
- 666307205,
1653
- 773529912,
1654
- 1294757372,
1655
- 1396182291,
1656
- 1695183700,
1657
- 1986661051,
1658
- 2177026350,
1659
- 2456956037,
1660
- 2730485921,
1661
- 2820302411,
1662
- 3259730800,
1663
- 3345764771,
1664
- 3516065817,
1665
- 3600352804,
1666
- 4094571909,
1667
- 275423344,
1668
- 430227734,
1669
- 506948616,
1670
- 659060556,
1671
- 883997877,
1672
- 958139571,
1673
- 1322822218,
1674
- 1537002063,
1675
- 1747873779,
1676
- 1955562222,
1677
- 2024104815,
1678
- 2227730452,
1679
- 2361852424,
1680
- 2428436474,
1681
- 2756734187,
1682
- 3204031479,
1683
- 3329325298
1684
- ]);
1685
- SHA256_IV = /* @__PURE__ */ new Uint32Array([
1686
- 1779033703,
1687
- 3144134277,
1688
- 1013904242,
1689
- 2773480762,
1690
- 1359893119,
1691
- 2600822924,
1692
- 528734635,
1693
- 1541459225
1694
- ]);
1695
- SHA256_W = /* @__PURE__ */ new Uint32Array(64);
1696
- SHA256 = class SHA256 extends HashMD {
1697
- constructor() {
1698
- super(64, 32, 8, false);
1699
- this.A = SHA256_IV[0] | 0;
1700
- this.B = SHA256_IV[1] | 0;
1701
- this.C = SHA256_IV[2] | 0;
1702
- this.D = SHA256_IV[3] | 0;
1703
- this.E = SHA256_IV[4] | 0;
1704
- this.F = SHA256_IV[5] | 0;
1705
- this.G = SHA256_IV[6] | 0;
1706
- this.H = SHA256_IV[7] | 0;
1707
- }
1708
- get() {
1709
- const { A, B, C, D, E, F, G, H } = this;
1710
- return [A, B, C, D, E, F, G, H];
1711
- }
1712
- set(A, B, C, D, E, F, G, H) {
1713
- this.A = A | 0;
1714
- this.B = B | 0;
1715
- this.C = C | 0;
1716
- this.D = D | 0;
1717
- this.E = E | 0;
1718
- this.F = F | 0;
1719
- this.G = G | 0;
1720
- this.H = H | 0;
1721
- }
1722
- process(view, offset) {
1723
- for (let i = 0;i < 16; i++, offset += 4)
1724
- SHA256_W[i] = view.getUint32(offset, false);
1725
- for (let i = 16;i < 64; i++) {
1726
- const W15 = SHA256_W[i - 15];
1727
- const W2 = SHA256_W[i - 2];
1728
- const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
1729
- const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
1730
- SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
1731
- }
1732
- let { A, B, C, D, E, F, G, H } = this;
1733
- for (let i = 0;i < 64; i++) {
1734
- const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
1735
- const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
1736
- const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
1737
- const T2 = sigma0 + Maj(A, B, C) | 0;
1738
- H = G;
1739
- G = F;
1740
- F = E;
1741
- E = D + T1 | 0;
1742
- D = C;
1743
- C = B;
1744
- B = A;
1745
- A = T1 + T2 | 0;
1746
- }
1747
- A = A + this.A | 0;
1748
- B = B + this.B | 0;
1749
- C = C + this.C | 0;
1750
- D = D + this.D | 0;
1751
- E = E + this.E | 0;
1752
- F = F + this.F | 0;
1753
- G = G + this.G | 0;
1754
- H = H + this.H | 0;
1755
- this.set(A, B, C, D, E, F, G, H);
1756
- }
1757
- roundClean() {
1758
- SHA256_W.fill(0);
1759
- }
1760
- destroy() {
1761
- this.set(0, 0, 0, 0, 0, 0, 0, 0);
1762
- this.buffer.fill(0);
1763
- }
1764
- };
1765
- sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256);
1766
- });
1767
-
1768
- // node_modules/viem/_esm/errors/chain.js
1769
- var InvalidChainIdError;
1770
- var init_chain = __esm(() => {
1771
- init_base();
1772
- InvalidChainIdError = class InvalidChainIdError extends BaseError {
1773
- constructor({ chainId }) {
1774
- super(typeof chainId === "number" ? `Chain ID "${chainId}" is invalid.` : "Chain ID is invalid.", { name: "InvalidChainIdError" });
1775
- }
1776
- };
1777
- });
1778
-
1779
837
  // ../node_modules/effect/dist/esm/Function.js
1780
838
  var isFunction = (input) => typeof input === "function";
1781
839
  var dual = function(arity, body) {
@@ -1896,7 +954,7 @@ var array = (item) => make((self, that) => {
1896
954
  });
1897
955
 
1898
956
  // ../node_modules/effect/dist/esm/internal/version.js
1899
- var moduleVersion = "3.14.10";
957
+ var moduleVersion = "3.14.5";
1900
958
  var getCurrentVersion = () => moduleVersion;
1901
959
 
1902
960
  // ../node_modules/effect/dist/esm/GlobalValue.js
@@ -2094,8 +1152,7 @@ var tracingFunction = (name) => {
2094
1152
  };
2095
1153
  };
2096
1154
  var internalCall = /* @__PURE__ */ tracingFunction("effect_internal_function");
2097
- var genConstructor = function* () {
2098
- }.constructor;
1155
+ var genConstructor = function* () {}.constructor;
2099
1156
 
2100
1157
  // ../node_modules/effect/dist/esm/Hash.js
2101
1158
  var randomHashCache = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/Hash/randomHashCache"), () => new WeakMap);
@@ -2442,8 +1499,7 @@ var StructuralCommitPrototype = {
2442
1499
  ...StructuralPrototype
2443
1500
  };
2444
1501
  var Base = /* @__PURE__ */ function() {
2445
- function Base2() {
2446
- }
1502
+ function Base2() {}
2447
1503
  Base2.prototype = CommitPrototype;
2448
1504
  return Base2;
2449
1505
  }();
@@ -5946,8 +5002,7 @@ var Reference = () => (id, options) => {
5946
5002
  Error.stackTraceLimit = 2;
5947
5003
  const creationError = new Error;
5948
5004
  Error.stackTraceLimit = limit;
5949
- function ReferenceClass() {
5950
- }
5005
+ function ReferenceClass() {}
5951
5006
  Object.setPrototypeOf(ReferenceClass, ReferenceProto);
5952
5007
  ReferenceClass.key = id;
5953
5008
  ReferenceClass.defaultValue = options.defaultValue;
@@ -8887,8 +7942,7 @@ var prettyErrorMessage = (u) => {
8887
7942
  if (hasProperty(u, "toString") && isFunction2(u["toString"]) && u["toString"] !== Object.prototype.toString && u["toString"] !== globalThis.Array.prototype.toString) {
8888
7943
  return u["toString"]();
8889
7944
  }
8890
- } catch {
8891
- }
7945
+ } catch {}
8892
7946
  return stringifyCircular(u);
8893
7947
  };
8894
7948
  var locationRegex = /\((.*)\)/g;
@@ -9462,8 +8516,7 @@ var zip2 = /* @__PURE__ */ dual(2, (self, that) => flatMap6(self, (a) => map9(th
9462
8516
  var zipLeft = /* @__PURE__ */ dual(2, (self, that) => flatMap6(self, (a) => as(that, a)));
9463
8517
  var zipRight = /* @__PURE__ */ dual(2, (self, that) => flatMap6(self, () => that));
9464
8518
  var never = /* @__PURE__ */ asyncInterrupt(() => {
9465
- const interval = setInterval(() => {
9466
- }, 2 ** 31 - 1);
8519
+ const interval = setInterval(() => {}, 2 ** 31 - 1);
9467
8520
  return sync(() => clearInterval(interval));
9468
8521
  });
9469
8522
  var interruptFiber = (self) => flatMap6(fiberId, (fiberId2) => pipe(self, interruptAsFiber(fiberId2)));
@@ -12319,7 +11372,7 @@ var summary3 = (key) => {
12319
11372
  if (item != null) {
12320
11373
  const [t, v] = item;
12321
11374
  const age = millis(now - t);
12322
- if (greaterThanOrEqualTo3(age, zero2) && lessThanOrEqualTo3(age, maxAge)) {
11375
+ if (greaterThanOrEqualTo3(age, zero2) && age <= maxAge) {
12323
11376
  builder.push(v);
12324
11377
  }
12325
11378
  }
@@ -13283,16 +12336,11 @@ class Const {
13283
12336
  get value() {
13284
12337
  return this.effect;
13285
12338
  }
13286
- onStart(_context, _effect, _parent, _fiber) {
13287
- }
13288
- onEnd(_value, _fiber) {
13289
- }
13290
- onEffect(_fiber, _effect) {
13291
- }
13292
- onSuspend(_fiber) {
13293
- }
13294
- onResume(_fiber) {
13295
- }
12339
+ onStart(_context, _effect, _parent, _fiber) {}
12340
+ onEnd(_value, _fiber) {}
12341
+ onEffect(_fiber, _effect) {}
12342
+ onSuspend(_fiber) {}
12343
+ onResume(_fiber) {}
13296
12344
  map(f) {
13297
12345
  return new ProxySupervisor(this, pipe(this.value, map9(f)));
13298
12346
  }
@@ -13766,8 +12814,7 @@ class FiberRuntime extends Class {
13766
12814
  return whileLoop({
13767
12815
  while: () => !isDone3,
13768
12816
  body,
13769
- step: () => {
13770
- }
12817
+ step: () => {}
13771
12818
  });
13772
12819
  }
13773
12820
  return null;
@@ -23297,431 +22344,7 @@ class TrieIterator {
23297
22344
  }
23298
22345
  }
23299
22346
  var isTrie = (u) => hasProperty(u, TrieTypeId);
23300
- // src/binary.ts
23301
- var exports_binary = {};
23302
- __export(exports_binary, {
23303
- padLeft: () => padLeft,
23304
- normaliseToHex: () => normaliseToHex,
23305
- mustBeHex: () => mustBeHex,
23306
- bytesToHex: () => bytesToHex3,
23307
- bytesToBigInt: () => bytesToBigInt,
23308
- bytesFromHexString: () => bytesFromHexString,
23309
- bytes32ToBigint: () => bytes32ToBigint,
23310
- bufferToBigInt: () => bufferToBigInt,
23311
- bigintToBytes32: () => bigintToBytes32,
23312
- asBytes32: () => asBytes32,
23313
- HexString: () => HexString,
23314
- Bytes32: () => Bytes32
23315
- });
23316
-
23317
- // node_modules/viem/_esm/utils/encoding/toRlp.js
23318
- init_base();
23319
- init_cursor2();
23320
- init_toBytes();
23321
- init_toHex();
23322
- function toRlp(bytes, to = "hex") {
23323
- const encodable = getEncodable(bytes);
23324
- const cursor = createCursor(new Uint8Array(encodable.length));
23325
- encodable.encode(cursor);
23326
- if (to === "hex")
23327
- return bytesToHex2(cursor.bytes);
23328
- return cursor.bytes;
23329
- }
23330
- function getEncodable(bytes) {
23331
- if (Array.isArray(bytes))
23332
- return getEncodableList(bytes.map((x) => getEncodable(x)));
23333
- return getEncodableBytes(bytes);
23334
- }
23335
- function getEncodableList(list) {
23336
- const bodyLength = list.reduce((acc, x) => acc + x.length, 0);
23337
- const sizeOfBodyLength = getSizeOfLength(bodyLength);
23338
- const length4 = (() => {
23339
- if (bodyLength <= 55)
23340
- return 1 + bodyLength;
23341
- return 1 + sizeOfBodyLength + bodyLength;
23342
- })();
23343
- return {
23344
- length: length4,
23345
- encode(cursor) {
23346
- if (bodyLength <= 55) {
23347
- cursor.pushByte(192 + bodyLength);
23348
- } else {
23349
- cursor.pushByte(192 + 55 + sizeOfBodyLength);
23350
- if (sizeOfBodyLength === 1)
23351
- cursor.pushUint8(bodyLength);
23352
- else if (sizeOfBodyLength === 2)
23353
- cursor.pushUint16(bodyLength);
23354
- else if (sizeOfBodyLength === 3)
23355
- cursor.pushUint24(bodyLength);
23356
- else
23357
- cursor.pushUint32(bodyLength);
23358
- }
23359
- for (const { encode: encode6 } of list) {
23360
- encode6(cursor);
23361
- }
23362
- }
23363
- };
23364
- }
23365
- function getEncodableBytes(bytesOrHex) {
23366
- const bytes = typeof bytesOrHex === "string" ? hexToBytes(bytesOrHex) : bytesOrHex;
23367
- const sizeOfBytesLength = getSizeOfLength(bytes.length);
23368
- const length4 = (() => {
23369
- if (bytes.length === 1 && bytes[0] < 128)
23370
- return 1;
23371
- if (bytes.length <= 55)
23372
- return 1 + bytes.length;
23373
- return 1 + sizeOfBytesLength + bytes.length;
23374
- })();
23375
- return {
23376
- length: length4,
23377
- encode(cursor) {
23378
- if (bytes.length === 1 && bytes[0] < 128) {
23379
- cursor.pushBytes(bytes);
23380
- } else if (bytes.length <= 55) {
23381
- cursor.pushByte(128 + bytes.length);
23382
- cursor.pushBytes(bytes);
23383
- } else {
23384
- cursor.pushByte(128 + 55 + sizeOfBytesLength);
23385
- if (sizeOfBytesLength === 1)
23386
- cursor.pushUint8(bytes.length);
23387
- else if (sizeOfBytesLength === 2)
23388
- cursor.pushUint16(bytes.length);
23389
- else if (sizeOfBytesLength === 3)
23390
- cursor.pushUint24(bytes.length);
23391
- else
23392
- cursor.pushUint32(bytes.length);
23393
- cursor.pushBytes(bytes);
23394
- }
23395
- }
23396
- };
23397
- }
23398
- function getSizeOfLength(length4) {
23399
- if (length4 < 2 ** 8)
23400
- return 1;
23401
- if (length4 < 2 ** 16)
23402
- return 2;
23403
- if (length4 < 2 ** 24)
23404
- return 3;
23405
- if (length4 < 2 ** 32)
23406
- return 4;
23407
- throw new BaseError("Length is too large.");
23408
- }
23409
- // node_modules/viem/_esm/utils/formatters/transaction.js
23410
- init_fromHex();
23411
- var transactionType = {
23412
- "0x0": "legacy",
23413
- "0x1": "eip2930",
23414
- "0x2": "eip1559",
23415
- "0x3": "eip4844",
23416
- "0x4": "eip7702"
23417
- };
23418
- function formatTransaction(transaction) {
23419
- const transaction_ = {
23420
- ...transaction,
23421
- blockHash: transaction.blockHash ? transaction.blockHash : null,
23422
- blockNumber: transaction.blockNumber ? BigInt(transaction.blockNumber) : null,
23423
- chainId: transaction.chainId ? hexToNumber(transaction.chainId) : undefined,
23424
- gas: transaction.gas ? BigInt(transaction.gas) : undefined,
23425
- gasPrice: transaction.gasPrice ? BigInt(transaction.gasPrice) : undefined,
23426
- maxFeePerBlobGas: transaction.maxFeePerBlobGas ? BigInt(transaction.maxFeePerBlobGas) : undefined,
23427
- maxFeePerGas: transaction.maxFeePerGas ? BigInt(transaction.maxFeePerGas) : undefined,
23428
- maxPriorityFeePerGas: transaction.maxPriorityFeePerGas ? BigInt(transaction.maxPriorityFeePerGas) : undefined,
23429
- nonce: transaction.nonce ? hexToNumber(transaction.nonce) : undefined,
23430
- to: transaction.to ? transaction.to : null,
23431
- transactionIndex: transaction.transactionIndex ? Number(transaction.transactionIndex) : null,
23432
- type: transaction.type ? transactionType[transaction.type] : undefined,
23433
- typeHex: transaction.type ? transaction.type : undefined,
23434
- value: transaction.value ? BigInt(transaction.value) : undefined,
23435
- v: transaction.v ? BigInt(transaction.v) : undefined
23436
- };
23437
- if (transaction.authorizationList)
23438
- transaction_.authorizationList = formatAuthorizationList(transaction.authorizationList);
23439
- transaction_.yParity = (() => {
23440
- if (transaction.yParity)
23441
- return Number(transaction.yParity);
23442
- if (typeof transaction_.v === "bigint") {
23443
- if (transaction_.v === 0n || transaction_.v === 27n)
23444
- return 0;
23445
- if (transaction_.v === 1n || transaction_.v === 28n)
23446
- return 1;
23447
- if (transaction_.v >= 35n)
23448
- return transaction_.v % 2n === 0n ? 1 : 0;
23449
- }
23450
- return;
23451
- })();
23452
- if (transaction_.type === "legacy") {
23453
- delete transaction_.accessList;
23454
- delete transaction_.maxFeePerBlobGas;
23455
- delete transaction_.maxFeePerGas;
23456
- delete transaction_.maxPriorityFeePerGas;
23457
- delete transaction_.yParity;
23458
- }
23459
- if (transaction_.type === "eip2930") {
23460
- delete transaction_.maxFeePerBlobGas;
23461
- delete transaction_.maxFeePerGas;
23462
- delete transaction_.maxPriorityFeePerGas;
23463
- }
23464
- if (transaction_.type === "eip1559") {
23465
- delete transaction_.maxFeePerBlobGas;
23466
- }
23467
- return transaction_;
23468
- }
23469
- var defineTransaction = /* @__PURE__ */ defineFormatter("transaction", formatTransaction);
23470
- function formatAuthorizationList(authorizationList) {
23471
- return authorizationList.map((authorization) => ({
23472
- contractAddress: authorization.address,
23473
- chainId: Number(authorization.chainId),
23474
- nonce: Number(authorization.nonce),
23475
- r: authorization.r,
23476
- s: authorization.s,
23477
- yParity: Number(authorization.yParity)
23478
- }));
23479
- }
23480
-
23481
- // node_modules/viem/_esm/utils/formatters/block.js
23482
- function formatBlock(block) {
23483
- const transactions = (block.transactions ?? []).map((transaction) => {
23484
- if (typeof transaction === "string")
23485
- return transaction;
23486
- return formatTransaction(transaction);
23487
- });
23488
- return {
23489
- ...block,
23490
- baseFeePerGas: block.baseFeePerGas ? BigInt(block.baseFeePerGas) : null,
23491
- blobGasUsed: block.blobGasUsed ? BigInt(block.blobGasUsed) : undefined,
23492
- difficulty: block.difficulty ? BigInt(block.difficulty) : undefined,
23493
- excessBlobGas: block.excessBlobGas ? BigInt(block.excessBlobGas) : undefined,
23494
- gasLimit: block.gasLimit ? BigInt(block.gasLimit) : undefined,
23495
- gasUsed: block.gasUsed ? BigInt(block.gasUsed) : undefined,
23496
- hash: block.hash ? block.hash : null,
23497
- logsBloom: block.logsBloom ? block.logsBloom : null,
23498
- nonce: block.nonce ? block.nonce : null,
23499
- number: block.number ? BigInt(block.number) : null,
23500
- size: block.size ? BigInt(block.size) : undefined,
23501
- timestamp: block.timestamp ? BigInt(block.timestamp) : undefined,
23502
- transactions,
23503
- totalDifficulty: block.totalDifficulty ? BigInt(block.totalDifficulty) : null
23504
- };
23505
- }
23506
- var defineBlock = /* @__PURE__ */ defineFormatter("block", formatBlock);
23507
-
23508
- // node_modules/viem/_esm/utils/blob/blobsToCommitments.js
23509
- init_toBytes();
23510
- init_toHex();
23511
- function blobsToCommitments(parameters) {
23512
- const { kzg } = parameters;
23513
- const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
23514
- const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
23515
- const commitments = [];
23516
- for (const blob of blobs)
23517
- commitments.push(Uint8Array.from(kzg.blobToKzgCommitment(blob)));
23518
- return to === "bytes" ? commitments : commitments.map((x) => bytesToHex2(x));
23519
- }
23520
-
23521
- // node_modules/viem/_esm/utils/blob/blobsToProofs.js
23522
- init_toBytes();
23523
- init_toHex();
23524
- function blobsToProofs(parameters) {
23525
- const { kzg } = parameters;
23526
- const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
23527
- const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
23528
- const commitments = typeof parameters.commitments[0] === "string" ? parameters.commitments.map((x) => hexToBytes(x)) : parameters.commitments;
23529
- const proofs = [];
23530
- for (let i = 0;i < blobs.length; i++) {
23531
- const blob = blobs[i];
23532
- const commitment = commitments[i];
23533
- proofs.push(Uint8Array.from(kzg.computeBlobKzgProof(blob, commitment)));
23534
- }
23535
- return to === "bytes" ? proofs : proofs.map((x) => bytesToHex2(x));
23536
- }
23537
-
23538
- // node_modules/viem/_esm/utils/blob/commitmentToVersionedHash.js
23539
- init_toHex();
23540
-
23541
- // node_modules/viem/_esm/utils/hash/sha256.js
23542
- init_sha256();
23543
- init_toBytes();
23544
- init_toHex();
23545
- function sha2562(value6, to_) {
23546
- const to = to_ || "hex";
23547
- const bytes = sha256(isHex(value6, { strict: false }) ? toBytes(value6) : value6);
23548
- if (to === "bytes")
23549
- return bytes;
23550
- return toHex(bytes);
23551
- }
23552
-
23553
- // node_modules/viem/_esm/utils/blob/commitmentToVersionedHash.js
23554
- function commitmentToVersionedHash(parameters) {
23555
- const { commitment, version: version2 = 1 } = parameters;
23556
- const to = parameters.to ?? (typeof commitment === "string" ? "hex" : "bytes");
23557
- const versionedHash = sha2562(commitment, "bytes");
23558
- versionedHash.set([version2], 0);
23559
- return to === "bytes" ? versionedHash : bytesToHex2(versionedHash);
23560
- }
23561
-
23562
- // node_modules/viem/_esm/utils/blob/commitmentsToVersionedHashes.js
23563
- function commitmentsToVersionedHashes(parameters) {
23564
- const { commitments, version: version2 } = parameters;
23565
- const to = parameters.to ?? (typeof commitments[0] === "string" ? "hex" : "bytes");
23566
- const hashes = [];
23567
- for (const commitment of commitments) {
23568
- hashes.push(commitmentToVersionedHash({
23569
- commitment,
23570
- to,
23571
- version: version2
23572
- }));
23573
- }
23574
- return hashes;
23575
- }
23576
-
23577
- // node_modules/viem/_esm/constants/blob.js
23578
- var blobsPerTransaction = 6;
23579
- var bytesPerFieldElement = 32;
23580
- var fieldElementsPerBlob = 4096;
23581
- var bytesPerBlob = bytesPerFieldElement * fieldElementsPerBlob;
23582
- var maxBytesPerTransaction = bytesPerBlob * blobsPerTransaction - 1 - 1 * fieldElementsPerBlob * blobsPerTransaction;
23583
-
23584
- // node_modules/viem/_esm/constants/kzg.js
23585
- var versionedHashVersionKzg = 1;
23586
-
23587
- // node_modules/viem/_esm/errors/blob.js
23588
- init_base();
23589
-
23590
- class BlobSizeTooLargeError extends BaseError {
23591
- constructor({ maxSize, size: size22 }) {
23592
- super("Blob size is too large.", {
23593
- metaMessages: [`Max: ${maxSize} bytes`, `Given: ${size22} bytes`],
23594
- name: "BlobSizeTooLargeError"
23595
- });
23596
- }
23597
- }
23598
-
23599
- class EmptyBlobError extends BaseError {
23600
- constructor() {
23601
- super("Blob data must not be empty.", { name: "EmptyBlobError" });
23602
- }
23603
- }
23604
-
23605
- class InvalidVersionedHashSizeError extends BaseError {
23606
- constructor({ hash: hash2, size: size22 }) {
23607
- super(`Versioned hash "${hash2}" size is invalid.`, {
23608
- metaMessages: ["Expected: 32", `Received: ${size22}`],
23609
- name: "InvalidVersionedHashSizeError"
23610
- });
23611
- }
23612
- }
23613
-
23614
- class InvalidVersionedHashVersionError extends BaseError {
23615
- constructor({ hash: hash2, version: version2 }) {
23616
- super(`Versioned hash "${hash2}" version is invalid.`, {
23617
- metaMessages: [
23618
- `Expected: ${versionedHashVersionKzg}`,
23619
- `Received: ${version2}`
23620
- ],
23621
- name: "InvalidVersionedHashVersionError"
23622
- });
23623
- }
23624
- }
23625
-
23626
- // node_modules/viem/_esm/utils/blob/toBlobs.js
23627
- init_cursor2();
23628
- init_size();
23629
- init_toBytes();
23630
- init_toHex();
23631
- function toBlobs(parameters) {
23632
- const to = parameters.to ?? (typeof parameters.data === "string" ? "hex" : "bytes");
23633
- const data = typeof parameters.data === "string" ? hexToBytes(parameters.data) : parameters.data;
23634
- const size_ = size21(data);
23635
- if (!size_)
23636
- throw new EmptyBlobError;
23637
- if (size_ > maxBytesPerTransaction)
23638
- throw new BlobSizeTooLargeError({
23639
- maxSize: maxBytesPerTransaction,
23640
- size: size_
23641
- });
23642
- const blobs = [];
23643
- let active2 = true;
23644
- let position = 0;
23645
- while (active2) {
23646
- const blob = createCursor(new Uint8Array(bytesPerBlob));
23647
- let size22 = 0;
23648
- while (size22 < fieldElementsPerBlob) {
23649
- const bytes = data.slice(position, position + (bytesPerFieldElement - 1));
23650
- blob.pushByte(0);
23651
- blob.pushBytes(bytes);
23652
- if (bytes.length < 31) {
23653
- blob.pushByte(128);
23654
- active2 = false;
23655
- break;
23656
- }
23657
- size22++;
23658
- position += 31;
23659
- }
23660
- blobs.push(blob);
23661
- }
23662
- return to === "bytes" ? blobs.map((x) => x.bytes) : blobs.map((x) => bytesToHex2(x.bytes));
23663
- }
23664
-
23665
- // node_modules/viem/_esm/utils/blob/toBlobSidecars.js
23666
- function toBlobSidecars(parameters) {
23667
- const { data, kzg, to } = parameters;
23668
- const blobs = parameters.blobs ?? toBlobs({ data, to });
23669
- const commitments = parameters.commitments ?? blobsToCommitments({ blobs, kzg, to });
23670
- const proofs = parameters.proofs ?? blobsToProofs({ blobs, commitments, kzg, to });
23671
- const sidecars = [];
23672
- for (let i = 0;i < blobs.length; i++)
23673
- sidecars.push({
23674
- blob: blobs[i],
23675
- commitment: commitments[i],
23676
- proof: proofs[i]
23677
- });
23678
- return sidecars;
23679
- }
23680
-
23681
- // node_modules/viem/_esm/utils/transaction/getTransactionType.js
23682
- init_transaction();
23683
- function getTransactionType(transaction) {
23684
- if (transaction.type)
23685
- return transaction.type;
23686
- if (typeof transaction.authorizationList !== "undefined")
23687
- return "eip7702";
23688
- if (typeof transaction.blobs !== "undefined" || typeof transaction.blobVersionedHashes !== "undefined" || typeof transaction.maxFeePerBlobGas !== "undefined" || typeof transaction.sidecars !== "undefined")
23689
- return "eip4844";
23690
- if (typeof transaction.maxFeePerGas !== "undefined" || typeof transaction.maxPriorityFeePerGas !== "undefined") {
23691
- return "eip1559";
23692
- }
23693
- if (typeof transaction.gasPrice !== "undefined") {
23694
- if (typeof transaction.accessList !== "undefined")
23695
- return "eip2930";
23696
- return "legacy";
23697
- }
23698
- throw new InvalidSerializableTransactionError({ transaction });
23699
- }
23700
-
23701
- // node_modules/viem/_esm/utils/formatters/log.js
23702
- function formatLog(log3, { args: args2, eventName } = {}) {
23703
- return {
23704
- ...log3,
23705
- blockHash: log3.blockHash ? log3.blockHash : null,
23706
- blockNumber: log3.blockNumber ? BigInt(log3.blockNumber) : null,
23707
- logIndex: log3.logIndex ? Number(log3.logIndex) : null,
23708
- transactionHash: log3.transactionHash ? log3.transactionHash : null,
23709
- transactionIndex: log3.transactionIndex ? Number(log3.transactionIndex) : null,
23710
- ...eventName ? { args: args2, eventName } : {}
23711
- };
23712
- }
23713
-
23714
- // node_modules/viem/_esm/utils/chain/defineChain.js
23715
- function defineChain(chain) {
23716
- return {
23717
- formatters: undefined,
23718
- fees: undefined,
23719
- serializers: undefined,
23720
- ...chain
23721
- };
23722
- }
23723
-
23724
- // node_modules/viem/_esm/utils/abi/encodePacked.js
22347
+ // ../node_modules/viem/_esm/utils/abi/encodePacked.js
23725
22348
  init_abi();
23726
22349
  init_address();
23727
22350
  init_isAddress();
@@ -23790,358 +22413,10 @@ function encode6(type2, value6, isArray2 = false) {
23790
22413
  throw new UnsupportedPackedAbiType(type2);
23791
22414
  }
23792
22415
 
23793
- // node_modules/viem/_esm/utils/formatters/transactionReceipt.js
23794
- init_fromHex();
23795
- var receiptStatuses = {
23796
- "0x0": "reverted",
23797
- "0x1": "success"
23798
- };
23799
- function formatTransactionReceipt(transactionReceipt) {
23800
- const receipt = {
23801
- ...transactionReceipt,
23802
- blockNumber: transactionReceipt.blockNumber ? BigInt(transactionReceipt.blockNumber) : null,
23803
- contractAddress: transactionReceipt.contractAddress ? transactionReceipt.contractAddress : null,
23804
- cumulativeGasUsed: transactionReceipt.cumulativeGasUsed ? BigInt(transactionReceipt.cumulativeGasUsed) : null,
23805
- effectiveGasPrice: transactionReceipt.effectiveGasPrice ? BigInt(transactionReceipt.effectiveGasPrice) : null,
23806
- gasUsed: transactionReceipt.gasUsed ? BigInt(transactionReceipt.gasUsed) : null,
23807
- logs: transactionReceipt.logs ? transactionReceipt.logs.map((log3) => formatLog(log3)) : null,
23808
- to: transactionReceipt.to ? transactionReceipt.to : null,
23809
- transactionIndex: transactionReceipt.transactionIndex ? hexToNumber(transactionReceipt.transactionIndex) : null,
23810
- status: transactionReceipt.status ? receiptStatuses[transactionReceipt.status] : null,
23811
- type: transactionReceipt.type ? transactionType[transactionReceipt.type] || transactionReceipt.type : null
23812
- };
23813
- if (transactionReceipt.blobGasPrice)
23814
- receipt.blobGasPrice = BigInt(transactionReceipt.blobGasPrice);
23815
- if (transactionReceipt.blobGasUsed)
23816
- receipt.blobGasUsed = BigInt(transactionReceipt.blobGasUsed);
23817
- return receipt;
23818
- }
23819
- var defineTransactionReceipt = /* @__PURE__ */ defineFormatter("transactionReceipt", formatTransactionReceipt);
23820
-
23821
- // node_modules/viem/_esm/utils/transaction/assertTransaction.js
23822
- init_number();
23823
- init_address();
23824
- init_base();
23825
- init_chain();
23826
- init_node();
23827
- init_isAddress();
23828
- init_size();
23829
- init_slice();
23830
- init_fromHex();
23831
- function assertTransactionEIP7702(transaction) {
23832
- const { authorizationList } = transaction;
23833
- if (authorizationList) {
23834
- for (const authorization of authorizationList) {
23835
- const { contractAddress, chainId } = authorization;
23836
- if (!isAddress(contractAddress))
23837
- throw new InvalidAddressError({ address: contractAddress });
23838
- if (chainId < 0)
23839
- throw new InvalidChainIdError({ chainId });
23840
- }
23841
- }
23842
- assertTransactionEIP1559(transaction);
23843
- }
23844
- function assertTransactionEIP4844(transaction) {
23845
- const { blobVersionedHashes } = transaction;
23846
- if (blobVersionedHashes) {
23847
- if (blobVersionedHashes.length === 0)
23848
- throw new EmptyBlobError;
23849
- for (const hash2 of blobVersionedHashes) {
23850
- const size_ = size21(hash2);
23851
- const version2 = hexToNumber(slice(hash2, 0, 1));
23852
- if (size_ !== 32)
23853
- throw new InvalidVersionedHashSizeError({ hash: hash2, size: size_ });
23854
- if (version2 !== versionedHashVersionKzg)
23855
- throw new InvalidVersionedHashVersionError({
23856
- hash: hash2,
23857
- version: version2
23858
- });
23859
- }
23860
- }
23861
- assertTransactionEIP1559(transaction);
23862
- }
23863
- function assertTransactionEIP1559(transaction) {
23864
- const { chainId, maxPriorityFeePerGas, maxFeePerGas, to } = transaction;
23865
- if (chainId <= 0)
23866
- throw new InvalidChainIdError({ chainId });
23867
- if (to && !isAddress(to))
23868
- throw new InvalidAddressError({ address: to });
23869
- if (maxFeePerGas && maxFeePerGas > maxUint256)
23870
- throw new FeeCapTooHighError({ maxFeePerGas });
23871
- if (maxPriorityFeePerGas && maxFeePerGas && maxPriorityFeePerGas > maxFeePerGas)
23872
- throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
23873
- }
23874
- function assertTransactionEIP2930(transaction) {
23875
- const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = transaction;
23876
- if (chainId <= 0)
23877
- throw new InvalidChainIdError({ chainId });
23878
- if (to && !isAddress(to))
23879
- throw new InvalidAddressError({ address: to });
23880
- if (maxPriorityFeePerGas || maxFeePerGas)
23881
- throw new BaseError("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid EIP-2930 Transaction attribute.");
23882
- if (gasPrice && gasPrice > maxUint256)
23883
- throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
23884
- }
23885
- function assertTransactionLegacy(transaction) {
23886
- const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = transaction;
23887
- if (to && !isAddress(to))
23888
- throw new InvalidAddressError({ address: to });
23889
- if (typeof chainId !== "undefined" && chainId <= 0)
23890
- throw new InvalidChainIdError({ chainId });
23891
- if (maxPriorityFeePerGas || maxFeePerGas)
23892
- throw new BaseError("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid Legacy Transaction attribute.");
23893
- if (gasPrice && gasPrice > maxUint256)
23894
- throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
23895
- }
23896
-
23897
- // node_modules/viem/_esm/utils/transaction/serializeTransaction.js
23898
- init_transaction();
23899
- init_toHex();
23900
-
23901
- // node_modules/viem/_esm/experimental/eip7702/utils/serializeAuthorizationList.js
23902
- init_toHex();
23903
- function serializeAuthorizationList(authorizationList) {
23904
- if (!authorizationList || authorizationList.length === 0)
23905
- return [];
23906
- const serializedAuthorizationList = [];
23907
- for (const authorization of authorizationList) {
23908
- const { contractAddress, chainId, nonce, ...signature } = authorization;
23909
- serializedAuthorizationList.push([
23910
- chainId ? toHex(chainId) : "0x",
23911
- contractAddress,
23912
- nonce ? toHex(nonce) : "0x",
23913
- ...toYParitySignatureArray({}, signature)
23914
- ]);
23915
- }
23916
- return serializedAuthorizationList;
23917
- }
23918
-
23919
- // node_modules/viem/_esm/utils/transaction/serializeAccessList.js
23920
- init_address();
23921
- init_transaction();
23922
- init_isAddress();
23923
- function serializeAccessList(accessList) {
23924
- if (!accessList || accessList.length === 0)
23925
- return [];
23926
- const serializedAccessList = [];
23927
- for (let i = 0;i < accessList.length; i++) {
23928
- const { address, storageKeys } = accessList[i];
23929
- for (let j = 0;j < storageKeys.length; j++) {
23930
- if (storageKeys[j].length - 2 !== 64) {
23931
- throw new InvalidStorageKeySizeError({ storageKey: storageKeys[j] });
23932
- }
23933
- }
23934
- if (!isAddress(address, { strict: false })) {
23935
- throw new InvalidAddressError({ address });
23936
- }
23937
- serializedAccessList.push([address, storageKeys]);
23938
- }
23939
- return serializedAccessList;
23940
- }
23941
-
23942
- // node_modules/viem/_esm/utils/transaction/serializeTransaction.js
23943
- function serializeTransaction(transaction, signature) {
23944
- const type2 = getTransactionType(transaction);
23945
- if (type2 === "eip1559")
23946
- return serializeTransactionEIP1559(transaction, signature);
23947
- if (type2 === "eip2930")
23948
- return serializeTransactionEIP2930(transaction, signature);
23949
- if (type2 === "eip4844")
23950
- return serializeTransactionEIP4844(transaction, signature);
23951
- if (type2 === "eip7702")
23952
- return serializeTransactionEIP7702(transaction, signature);
23953
- return serializeTransactionLegacy(transaction, signature);
23954
- }
23955
- function serializeTransactionEIP7702(transaction, signature) {
23956
- const { authorizationList, chainId, gas, nonce, to, value: value6, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
23957
- assertTransactionEIP7702(transaction);
23958
- const serializedAccessList = serializeAccessList(accessList);
23959
- const serializedAuthorizationList = serializeAuthorizationList(authorizationList);
23960
- return concatHex([
23961
- "0x04",
23962
- toRlp([
23963
- toHex(chainId),
23964
- nonce ? toHex(nonce) : "0x",
23965
- maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
23966
- maxFeePerGas ? toHex(maxFeePerGas) : "0x",
23967
- gas ? toHex(gas) : "0x",
23968
- to ?? "0x",
23969
- value6 ? toHex(value6) : "0x",
23970
- data ?? "0x",
23971
- serializedAccessList,
23972
- serializedAuthorizationList,
23973
- ...toYParitySignatureArray(transaction, signature)
23974
- ])
23975
- ]);
23976
- }
23977
- function serializeTransactionEIP4844(transaction, signature) {
23978
- const { chainId, gas, nonce, to, value: value6, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
23979
- assertTransactionEIP4844(transaction);
23980
- let blobVersionedHashes = transaction.blobVersionedHashes;
23981
- let sidecars = transaction.sidecars;
23982
- if (transaction.blobs && (typeof blobVersionedHashes === "undefined" || typeof sidecars === "undefined")) {
23983
- const blobs2 = typeof transaction.blobs[0] === "string" ? transaction.blobs : transaction.blobs.map((x) => bytesToHex2(x));
23984
- const kzg = transaction.kzg;
23985
- const commitments2 = blobsToCommitments({
23986
- blobs: blobs2,
23987
- kzg
23988
- });
23989
- if (typeof blobVersionedHashes === "undefined")
23990
- blobVersionedHashes = commitmentsToVersionedHashes({
23991
- commitments: commitments2
23992
- });
23993
- if (typeof sidecars === "undefined") {
23994
- const proofs2 = blobsToProofs({ blobs: blobs2, commitments: commitments2, kzg });
23995
- sidecars = toBlobSidecars({ blobs: blobs2, commitments: commitments2, proofs: proofs2 });
23996
- }
23997
- }
23998
- const serializedAccessList = serializeAccessList(accessList);
23999
- const serializedTransaction = [
24000
- toHex(chainId),
24001
- nonce ? toHex(nonce) : "0x",
24002
- maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
24003
- maxFeePerGas ? toHex(maxFeePerGas) : "0x",
24004
- gas ? toHex(gas) : "0x",
24005
- to ?? "0x",
24006
- value6 ? toHex(value6) : "0x",
24007
- data ?? "0x",
24008
- serializedAccessList,
24009
- maxFeePerBlobGas ? toHex(maxFeePerBlobGas) : "0x",
24010
- blobVersionedHashes ?? [],
24011
- ...toYParitySignatureArray(transaction, signature)
24012
- ];
24013
- const blobs = [];
24014
- const commitments = [];
24015
- const proofs = [];
24016
- if (sidecars)
24017
- for (let i = 0;i < sidecars.length; i++) {
24018
- const { blob, commitment, proof } = sidecars[i];
24019
- blobs.push(blob);
24020
- commitments.push(commitment);
24021
- proofs.push(proof);
24022
- }
24023
- return concatHex([
24024
- "0x03",
24025
- sidecars ? toRlp([serializedTransaction, blobs, commitments, proofs]) : toRlp(serializedTransaction)
24026
- ]);
24027
- }
24028
- function serializeTransactionEIP1559(transaction, signature) {
24029
- const { chainId, gas, nonce, to, value: value6, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
24030
- assertTransactionEIP1559(transaction);
24031
- const serializedAccessList = serializeAccessList(accessList);
24032
- const serializedTransaction = [
24033
- toHex(chainId),
24034
- nonce ? toHex(nonce) : "0x",
24035
- maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
24036
- maxFeePerGas ? toHex(maxFeePerGas) : "0x",
24037
- gas ? toHex(gas) : "0x",
24038
- to ?? "0x",
24039
- value6 ? toHex(value6) : "0x",
24040
- data ?? "0x",
24041
- serializedAccessList,
24042
- ...toYParitySignatureArray(transaction, signature)
24043
- ];
24044
- return concatHex([
24045
- "0x02",
24046
- toRlp(serializedTransaction)
24047
- ]);
24048
- }
24049
- function serializeTransactionEIP2930(transaction, signature) {
24050
- const { chainId, gas, data, nonce, to, value: value6, accessList, gasPrice } = transaction;
24051
- assertTransactionEIP2930(transaction);
24052
- const serializedAccessList = serializeAccessList(accessList);
24053
- const serializedTransaction = [
24054
- toHex(chainId),
24055
- nonce ? toHex(nonce) : "0x",
24056
- gasPrice ? toHex(gasPrice) : "0x",
24057
- gas ? toHex(gas) : "0x",
24058
- to ?? "0x",
24059
- value6 ? toHex(value6) : "0x",
24060
- data ?? "0x",
24061
- serializedAccessList,
24062
- ...toYParitySignatureArray(transaction, signature)
24063
- ];
24064
- return concatHex([
24065
- "0x01",
24066
- toRlp(serializedTransaction)
24067
- ]);
24068
- }
24069
- function serializeTransactionLegacy(transaction, signature) {
24070
- const { chainId = 0, gas, data, nonce, to, value: value6, gasPrice } = transaction;
24071
- assertTransactionLegacy(transaction);
24072
- let serializedTransaction = [
24073
- nonce ? toHex(nonce) : "0x",
24074
- gasPrice ? toHex(gasPrice) : "0x",
24075
- gas ? toHex(gas) : "0x",
24076
- to ?? "0x",
24077
- value6 ? toHex(value6) : "0x",
24078
- data ?? "0x"
24079
- ];
24080
- if (signature) {
24081
- const v = (() => {
24082
- if (signature.v >= 35n) {
24083
- const inferredChainId = (signature.v - 35n) / 2n;
24084
- if (inferredChainId > 0)
24085
- return signature.v;
24086
- return 27n + (signature.v === 35n ? 0n : 1n);
24087
- }
24088
- if (chainId > 0)
24089
- return BigInt(chainId * 2) + BigInt(35n + signature.v - 27n);
24090
- const v2 = 27n + (signature.v === 27n ? 0n : 1n);
24091
- if (signature.v !== v2)
24092
- throw new InvalidLegacyVError({ v: signature.v });
24093
- return v2;
24094
- })();
24095
- const r = trim(signature.r);
24096
- const s = trim(signature.s);
24097
- serializedTransaction = [
24098
- ...serializedTransaction,
24099
- toHex(v),
24100
- r === "0x00" ? "0x" : r,
24101
- s === "0x00" ? "0x" : s
24102
- ];
24103
- } else if (chainId > 0) {
24104
- serializedTransaction = [
24105
- ...serializedTransaction,
24106
- toHex(chainId),
24107
- "0x",
24108
- "0x"
24109
- ];
24110
- }
24111
- return toRlp(serializedTransaction);
24112
- }
24113
- function toYParitySignatureArray(transaction, signature_) {
24114
- const signature = signature_ ?? transaction;
24115
- const { v, yParity } = signature;
24116
- if (typeof signature.r === "undefined")
24117
- return [];
24118
- if (typeof signature.s === "undefined")
24119
- return [];
24120
- if (typeof v === "undefined" && typeof yParity === "undefined")
24121
- return [];
24122
- const r = trim(signature.r);
24123
- const s = trim(signature.s);
24124
- const yParity_ = (() => {
24125
- if (typeof yParity === "number")
24126
- return yParity ? toHex(1) : "0x";
24127
- if (v === 0n)
24128
- return "0x";
24129
- if (v === 1n)
24130
- return toHex(1);
24131
- return v === 27n ? "0x" : toHex(1);
24132
- })();
24133
- return [yParity_, r === "0x00" ? "0x" : r, s === "0x00" ? "0x" : s];
24134
- }
24135
-
24136
- // node_modules/viem/_esm/index.js
22416
+ // ../node_modules/viem/_esm/index.js
24137
22417
  init_toBytes();
24138
22418
  init_toHex();
24139
22419
  // src/schema.ts
24140
- var exports_schema = {};
24141
- __export(exports_schema, {
24142
- parseJson: () => parseJson2,
24143
- parse: () => parse3
24144
- });
24145
22420
  function parse3(schema, obj, options) {
24146
22421
  return exports_Schema.decodeUnknownSync(schema)(obj, options);
24147
22422
  }
@@ -24201,251 +22476,11 @@ function asBytes32(x) {
24201
22476
  return parse3(Bytes32, x);
24202
22477
  }
24203
22478
 
24204
- // node_modules/viem/_esm/op-stack/contracts.js
24205
- var contracts = {
24206
- gasPriceOracle: { address: "0x420000000000000000000000000000000000000F" },
24207
- l1Block: { address: "0x4200000000000000000000000000000000000015" },
24208
- l2CrossDomainMessenger: {
24209
- address: "0x4200000000000000000000000000000000000007"
24210
- },
24211
- l2Erc721Bridge: { address: "0x4200000000000000000000000000000000000014" },
24212
- l2StandardBridge: { address: "0x4200000000000000000000000000000000000010" },
24213
- l2ToL1MessagePasser: {
24214
- address: "0x4200000000000000000000000000000000000016"
24215
- }
24216
- };
24217
-
24218
- // node_modules/viem/_esm/op-stack/formatters.js
24219
- init_fromHex();
24220
- var formatters = {
24221
- block: /* @__PURE__ */ defineBlock({
24222
- format(args2) {
24223
- const transactions = args2.transactions?.map((transaction) => {
24224
- if (typeof transaction === "string")
24225
- return transaction;
24226
- const formatted = formatTransaction(transaction);
24227
- if (formatted.typeHex === "0x7e") {
24228
- formatted.isSystemTx = transaction.isSystemTx;
24229
- formatted.mint = transaction.mint ? hexToBigInt(transaction.mint) : undefined;
24230
- formatted.sourceHash = transaction.sourceHash;
24231
- formatted.type = "deposit";
24232
- }
24233
- return formatted;
24234
- });
24235
- return {
24236
- transactions,
24237
- stateRoot: args2.stateRoot
24238
- };
24239
- }
24240
- }),
24241
- transaction: /* @__PURE__ */ defineTransaction({
24242
- format(args2) {
24243
- const transaction = {};
24244
- if (args2.type === "0x7e") {
24245
- transaction.isSystemTx = args2.isSystemTx;
24246
- transaction.mint = args2.mint ? hexToBigInt(args2.mint) : undefined;
24247
- transaction.sourceHash = args2.sourceHash;
24248
- transaction.type = "deposit";
24249
- }
24250
- return transaction;
24251
- }
24252
- }),
24253
- transactionReceipt: /* @__PURE__ */ defineTransactionReceipt({
24254
- format(args2) {
24255
- return {
24256
- l1GasPrice: args2.l1GasPrice ? hexToBigInt(args2.l1GasPrice) : null,
24257
- l1GasUsed: args2.l1GasUsed ? hexToBigInt(args2.l1GasUsed) : null,
24258
- l1Fee: args2.l1Fee ? hexToBigInt(args2.l1Fee) : null,
24259
- l1FeeScalar: args2.l1FeeScalar ? Number(args2.l1FeeScalar) : null
24260
- };
24261
- }
24262
- })
24263
- };
24264
-
24265
- // node_modules/viem/_esm/op-stack/serializers.js
24266
- init_address();
24267
- init_isAddress();
24268
- init_toHex();
24269
- function serializeTransaction2(transaction, signature) {
24270
- if (isDeposit(transaction))
24271
- return serializeTransactionDeposit(transaction);
24272
- return serializeTransaction(transaction, signature);
24273
- }
24274
- var serializers = {
24275
- transaction: serializeTransaction2
24276
- };
24277
- function serializeTransactionDeposit(transaction) {
24278
- assertTransactionDeposit(transaction);
24279
- const { sourceHash, data, from, gas, isSystemTx, mint, to, value: value6 } = transaction;
24280
- const serializedTransaction = [
24281
- sourceHash,
24282
- from,
24283
- to ?? "0x",
24284
- mint ? toHex(mint) : "0x",
24285
- value6 ? toHex(value6) : "0x",
24286
- gas ? toHex(gas) : "0x",
24287
- isSystemTx ? "0x1" : "0x",
24288
- data ?? "0x"
24289
- ];
24290
- return concatHex([
24291
- "0x7e",
24292
- toRlp(serializedTransaction)
24293
- ]);
24294
- }
24295
- function isDeposit(transaction) {
24296
- if (transaction.type === "deposit")
24297
- return true;
24298
- if (typeof transaction.sourceHash !== "undefined")
24299
- return true;
24300
- return false;
24301
- }
24302
- function assertTransactionDeposit(transaction) {
24303
- const { from, to } = transaction;
24304
- if (from && !isAddress(from))
24305
- throw new InvalidAddressError({ address: from });
24306
- if (to && !isAddress(to))
24307
- throw new InvalidAddressError({ address: to });
24308
- }
24309
-
24310
- // node_modules/viem/_esm/op-stack/chainConfig.js
24311
- var chainConfig = {
24312
- contracts,
24313
- formatters,
24314
- serializers
24315
- };
24316
-
24317
- // node_modules/viem/_esm/chains/definitions/anvil.js
24318
- var anvil = /* @__PURE__ */ defineChain({
24319
- id: 31337,
24320
- name: "Anvil",
24321
- nativeCurrency: {
24322
- decimals: 18,
24323
- name: "Ether",
24324
- symbol: "ETH"
24325
- },
24326
- rpcUrls: {
24327
- default: {
24328
- http: ["http://127.0.0.1:8545"],
24329
- webSocket: ["ws://127.0.0.1:8545"]
24330
- }
24331
- }
24332
- });
24333
- // node_modules/viem/_esm/chains/definitions/baseSepolia.js
24334
- var sourceId = 11155111;
24335
- var baseSepolia = /* @__PURE__ */ defineChain({
24336
- ...chainConfig,
24337
- id: 84532,
24338
- network: "base-sepolia",
24339
- name: "Base Sepolia",
24340
- nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
24341
- rpcUrls: {
24342
- default: {
24343
- http: ["https://sepolia.base.org"]
24344
- }
24345
- },
24346
- blockExplorers: {
24347
- default: {
24348
- name: "Basescan",
24349
- url: "https://sepolia.basescan.org",
24350
- apiUrl: "https://api-sepolia.basescan.org/api"
24351
- }
24352
- },
24353
- contracts: {
24354
- ...chainConfig.contracts,
24355
- disputeGameFactory: {
24356
- [sourceId]: {
24357
- address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1"
24358
- }
24359
- },
24360
- l2OutputOracle: {
24361
- [sourceId]: {
24362
- address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254"
24363
- }
24364
- },
24365
- portal: {
24366
- [sourceId]: {
24367
- address: "0x49f53e41452c74589e85ca1677426ba426459e85",
24368
- blockCreated: 4446677
24369
- }
24370
- },
24371
- l1StandardBridge: {
24372
- [sourceId]: {
24373
- address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120",
24374
- blockCreated: 4446677
24375
- }
24376
- },
24377
- multicall3: {
24378
- address: "0xca11bde05977b3631167028862be2a173976ca11",
24379
- blockCreated: 1059647
24380
- }
24381
- },
24382
- testnet: true,
24383
- sourceId
24384
- });
24385
- // node_modules/viem/_esm/chains/definitions/monadTestnet.js
24386
- var monadTestnet = /* @__PURE__ */ defineChain({
24387
- id: 10143,
24388
- name: "Monad Testnet",
24389
- nativeCurrency: {
24390
- name: "Testnet MON Token",
24391
- symbol: "MON",
24392
- decimals: 18
24393
- },
24394
- rpcUrls: {
24395
- default: {
24396
- http: ["https://testnet-rpc.monad.xyz"]
24397
- }
24398
- },
24399
- blockExplorers: {
24400
- default: {
24401
- name: "Monad Testnet explorer",
24402
- url: "https://testnet.monadexplorer.com"
24403
- }
24404
- },
24405
- contracts: {
24406
- multicall3: {
24407
- address: "0xcA11bde05977b3631167028862bE2a173976CA11",
24408
- blockCreated: 251449
24409
- }
24410
- },
24411
- testnet: true
24412
- });
24413
- // node_modules/viem/_esm/chains/definitions/sepolia.js
24414
- var sepolia = /* @__PURE__ */ defineChain({
24415
- id: 11155111,
24416
- name: "Sepolia",
24417
- nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
24418
- rpcUrls: {
24419
- default: {
24420
- http: ["https://sepolia.drpc.org"]
24421
- }
24422
- },
24423
- blockExplorers: {
24424
- default: {
24425
- name: "Etherscan",
24426
- url: "https://sepolia.etherscan.io",
24427
- apiUrl: "https://api-sepolia.etherscan.io/api"
24428
- }
24429
- },
24430
- contracts: {
24431
- multicall3: {
24432
- address: "0xca11bde05977b3631167028862be2a173976ca11",
24433
- blockCreated: 751532
24434
- },
24435
- ensRegistry: { address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e" },
24436
- ensUniversalResolver: {
24437
- address: "0xc8Af999e38273D658BE1b921b88A9Ddf005769cC",
24438
- blockCreated: 5317080
24439
- }
24440
- },
24441
- testnet: true
24442
- });
24443
22479
  // src/chain.ts
24444
22480
  var supportedChains = {
24445
- baseSepolia: baseSepolia.id,
24446
- sepolia: sepolia.id,
24447
- monadTestnet: monadTestnet.id,
24448
- anvil: anvil.id
22481
+ baseSepolia: 84532,
22482
+ sepolia: 11155111,
22483
+ monadTestnet: 10143
24449
22484
  };
24450
22485
  var fheSupportedChains = { baseSepolia: 84532, sepolia: 11155111 };
24451
22486
  function getSupportedChain(chainish) {
@@ -24460,262 +22495,147 @@ function getSupportedChain(chainish) {
24460
22495
  // src/generated/lightning.ts
24461
22496
  var lightningDeployments = [
24462
22497
  {
24463
- name: "incoLightning_0_1_25__986372984",
24464
- executorAddress: "0xc3c81F7Bf86Af7ed3a5f5Bb1924A063a1c126cDd",
24465
- deployer: "0x8202D2D747784Cb7D48868E44C42C4bf162a70BC",
24466
- pepper: "devnet",
24467
- version: {
24468
- major: 0,
24469
- minor: 1,
24470
- patch: 25,
24471
- shortSalt: "986372984"
24472
- },
24473
- salt: "0x8202d2d747784cb7d48868e44c42c4bf162a70bc0049a1295d7ede1f6ae76978",
24474
- decryptSigner: "0x2581773F31B13CeEd15413975089768EEA74dCE2",
24475
- eciesPublicKey: "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000babe",
24476
- chainId: "31337",
24477
- blockNumber: "5",
24478
- chainName: "Foundry",
24479
- active: true,
24480
- deployDate: "2025-04-21T20:48:53.167Z",
24481
- commit: "v3-24-g20f55870-dirty",
24482
- sessionVerifierAddress: "0x359D300756aBf9dF80A4865399D5B3Ed29c7AE8B",
24483
- addTwoAddress: "0x723c2be5E61e7bBec4684DEfEaE63656ad3eaa10"
24484
- },
24485
- {
24486
- name: "incoLightning_0_1_25__986372984",
24487
- executorAddress: "0xc3c81F7Bf86Af7ed3a5f5Bb1924A063a1c126cDd",
22498
+ name: "incoLightning_0_1_26__18043964",
22499
+ executorAddress: "0x69Ef6a59f9eE2d6f3b49eA3F79bcF1553512DF0e",
24488
22500
  deployer: "0x8202D2D747784Cb7D48868E44C42C4bf162a70BC",
24489
- pepper: "devnet",
22501
+ pepper: "testnet",
24490
22502
  version: {
24491
22503
  major: 0,
24492
22504
  minor: 1,
24493
- patch: 25,
24494
- shortSalt: "986372984"
22505
+ patch: 26,
22506
+ shortSalt: "18043964"
24495
22507
  },
24496
- salt: "0x8202d2d747784cb7d48868e44c42c4bf162a70bc0049a1295d7ede1f6ae76978",
22508
+ salt: "0x8202d2d747784cb7d48868e44c42c4bf162a70bc00858064cb0f58c7ef7a843c",
24497
22509
  decryptSigner: "0x000000000000000000000000000000000000baBe",
24498
22510
  eciesPublicKey: "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000babe",
24499
22511
  chainId: "7311099111",
24500
22512
  blockNumber: "1",
24501
22513
  chainName: "Inco Release Chain",
24502
22514
  active: true,
24503
- deployDate: "2025-04-21T20:48:48.403Z",
24504
- commit: "v3-24-g20f55870-dirty",
24505
- sessionVerifierAddress: "0x359D300756aBf9dF80A4865399D5B3Ed29c7AE8B",
22515
+ deployDate: "2025-04-22T12:14:50.447Z",
22516
+ commit: "v3-26-g623cec72-dirty",
22517
+ sessionVerifierAddress: "0x0F508B0Fb940595046AB0eceB7A4C8b3e20Cb674",
24506
22518
  addTwoAddress: "0x70fC34B18B12E945cb2204FA77E5f8e1581890C3"
24507
22519
  },
24508
22520
  {
24509
- name: "incoLightning_0_1_25__986372984",
24510
- executorAddress: "0xc3c81F7Bf86Af7ed3a5f5Bb1924A063a1c126cDd",
22521
+ name: "incoLightning_0_1_26__18043964",
22522
+ executorAddress: "0x69Ef6a59f9eE2d6f3b49eA3F79bcF1553512DF0e",
24511
22523
  deployer: "0x8202D2D747784Cb7D48868E44C42C4bf162a70BC",
24512
- pepper: "devnet",
22524
+ pepper: "testnet",
24513
22525
  version: {
24514
22526
  major: 0,
24515
22527
  minor: 1,
24516
- patch: 25,
24517
- shortSalt: "986372984"
22528
+ patch: 26,
22529
+ shortSalt: "18043964"
24518
22530
  },
24519
- salt: "0x8202d2d747784cb7d48868e44c42c4bf162a70bc0049a1295d7ede1f6ae76978",
22531
+ salt: "0x8202d2d747784cb7d48868e44c42c4bf162a70bc00858064cb0f58c7ef7a843c",
24520
22532
  decryptSigner: "0xA8822DE8910f66D3d03F1eAfe2C0141dBc327Ee0",
24521
22533
  eciesPublicKey: "0x048a582d29083c2f3fefe024bf4dd9ab913ab8973716977da5f01106e0b84095b1e647a9e377175fcb66bda05087c93b05e1fd53a704d0914bb23a0b2a69e9f235",
24522
22534
  chainId: "10143",
24523
- blockNumber: "13334835",
22535
+ blockNumber: "13439069",
24524
22536
  chainName: "Monad Testnet",
24525
22537
  active: true,
24526
- deployDate: "2025-04-21T20:48:40.573Z",
24527
- commit: "v3-24-g20f55870-dirty",
24528
- sessionVerifierAddress: "0x359D300756aBf9dF80A4865399D5B3Ed29c7AE8B",
24529
- addTwoAddress: "0x4728b934D6ee821449d65b5aBBa9e41d274ef1B9"
22538
+ deployDate: "2025-04-22T12:14:42.391Z",
22539
+ commit: "v3-26-g623cec72-dirty",
22540
+ sessionVerifierAddress: "0x0F508B0Fb940595046AB0eceB7A4C8b3e20Cb674",
22541
+ addTwoAddress: "0x4A49112FB866F6d5D05845D264b430cD3bbAb9f6"
24530
22542
  },
24531
22543
  {
24532
- name: "incoLightning_0_1_25__986372984",
24533
- executorAddress: "0xc3c81F7Bf86Af7ed3a5f5Bb1924A063a1c126cDd",
22544
+ name: "incoLightning_0_1_26__18043964",
22545
+ executorAddress: "0x69Ef6a59f9eE2d6f3b49eA3F79bcF1553512DF0e",
24534
22546
  deployer: "0x8202D2D747784Cb7D48868E44C42C4bf162a70BC",
24535
- pepper: "devnet",
22547
+ pepper: "testnet",
24536
22548
  version: {
24537
22549
  major: 0,
24538
22550
  minor: 1,
24539
- patch: 25,
24540
- shortSalt: "986372984"
22551
+ patch: 26,
22552
+ shortSalt: "18043964"
24541
22553
  },
24542
- salt: "0x8202d2d747784cb7d48868e44c42c4bf162a70bc0049a1295d7ede1f6ae76978",
22554
+ salt: "0x8202d2d747784cb7d48868e44c42c4bf162a70bc00858064cb0f58c7ef7a843c",
24543
22555
  decryptSigner: "0xA8822DE8910f66D3d03F1eAfe2C0141dBc327Ee0",
24544
22556
  eciesPublicKey: "0x048a582d29083c2f3fefe024bf4dd9ab913ab8973716977da5f01106e0b84095b1e647a9e377175fcb66bda05087c93b05e1fd53a704d0914bb23a0b2a69e9f235",
24545
22557
  chainId: "84532",
24546
- blockNumber: "24750079",
22558
+ blockNumber: "24777885",
24547
22559
  chainName: "Base Sepolia",
24548
22560
  active: true,
24549
- deployDate: "2025-04-21T20:47:33.893Z",
24550
- commit: "v3-24-g20f55870-dirty",
24551
- sessionVerifierAddress: "0x359D300756aBf9dF80A4865399D5B3Ed29c7AE8B",
24552
- addTwoAddress: "0x934338c79f7c5aC024D82a7FeDCeab3655B1f462"
24553
- },
24554
- {
24555
- name: "incoLightning_0_1_24__266705097",
24556
- executorAddress: "0x533Ee5a3cC09DD08Ac1a53F24642fECb88EaFBca",
24557
- deployer: "0x8202D2D747784Cb7D48868E44C42C4bf162a70BC",
24558
- pepper: "devnet",
24559
- version: {
24560
- major: 0,
24561
- minor: 1,
24562
- patch: 24,
24563
- shortSalt: "266705097"
24564
- },
24565
- salt: "0x8202d2d747784cb7d48868e44c42c4bf162a70bc00d3722970b402050333d4c9",
24566
- decryptSigner: "0x5437Fc296B2aC57dD321196A58F4A8Db8bF2a335",
24567
- eciesPublicKey: "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000babe",
24568
- chainId: "31337",
24569
- blockNumber: "5",
24570
- chainName: "Foundry",
24571
- active: true,
24572
- deployDate: "2025-04-21T20:43:27.984Z",
24573
- commit: "v3-24-g20f55870-dirty",
24574
- sessionVerifierAddress: "0xC81bfB1fF4FC6bE913d97928Fa776F80F637c54c",
24575
- addTwoAddress: "0x723c2be5E61e7bBec4684DEfEaE63656ad3eaa10"
22561
+ deployDate: "2025-04-22T12:14:25.354Z",
22562
+ commit: "v3-26-g623cec72-dirty",
22563
+ sessionVerifierAddress: "0x0F508B0Fb940595046AB0eceB7A4C8b3e20Cb674",
22564
+ addTwoAddress: "0x2b5E34844997681168049783D30CD84B5962cb50"
24576
22565
  },
24577
22566
  {
24578
- name: "incoLightning_0_1_24__266705097",
24579
- executorAddress: "0x533Ee5a3cC09DD08Ac1a53F24642fECb88EaFBca",
22567
+ name: "incoLightning_0_1_26__444235330",
22568
+ executorAddress: "0xdc8eD938ff2eB900bD5f86A88555a9f1956994fC",
24580
22569
  deployer: "0x8202D2D747784Cb7D48868E44C42C4bf162a70BC",
24581
22570
  pepper: "devnet",
24582
22571
  version: {
24583
22572
  major: 0,
24584
22573
  minor: 1,
24585
- patch: 24,
24586
- shortSalt: "266705097"
22574
+ patch: 26,
22575
+ shortSalt: "444235330"
24587
22576
  },
24588
- salt: "0x8202d2d747784cb7d48868e44c42c4bf162a70bc00d3722970b402050333d4c9",
22577
+ salt: "0x8202d2d747784cb7d48868e44c42c4bf162a70bc001bab4c5927c52fbea0d042",
24589
22578
  decryptSigner: "0x000000000000000000000000000000000000baBe",
24590
22579
  eciesPublicKey: "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000babe",
24591
22580
  chainId: "7311099111",
24592
22581
  blockNumber: "1",
24593
22582
  chainName: "Inco Release Chain",
24594
22583
  active: true,
24595
- deployDate: "2025-04-21T20:43:21.788Z",
24596
- commit: "v3-24-g20f55870-dirty",
24597
- sessionVerifierAddress: "0xC81bfB1fF4FC6bE913d97928Fa776F80F637c54c",
22584
+ deployDate: "2025-04-22T09:11:15.398Z",
22585
+ commit: "v3-24-gc9716e6c-dirty",
22586
+ sessionVerifierAddress: "0x3D4eB5f90E6d996c2b45b0BEb4110b5be98e243F",
24598
22587
  addTwoAddress: "0x70fC34B18B12E945cb2204FA77E5f8e1581890C3"
24599
22588
  },
24600
22589
  {
24601
- name: "incoLightning_0_1_23__830342853",
24602
- executorAddress: "0xF167b01eeE3eB16809D115a3476073121ACbA67C",
24603
- deployer: "0x8202D2D747784Cb7D48868E44C42C4bf162a70BC",
24604
- pepper: "",
24605
- version: {
24606
- major: 0,
24607
- minor: 1,
24608
- patch: 23,
24609
- shortSalt: "830342853"
24610
- },
24611
- salt: "0x8202d2d747784cb7d48868e44c42c4bf162a70bc00ae982ce1d0aa3cd80660c5",
24612
- decryptSigner: "0x000000000000000000000000000000000000baBe",
24613
- eciesPublicKey: "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000babe",
24614
- chainId: "31337",
24615
- blockNumber: "0",
24616
- chainName: "Foundry",
24617
- active: true,
24618
- deployDate: "2025-04-21T15:51:33.222Z",
24619
- commit: "v3-23-g2694ffde-dirty",
24620
- sessionVerifierAddress: "0xe9d19e6680F15498B5963E7808048D644db2575b",
24621
- addTwoAddress: "0x723c2be5E61e7bBec4684DEfEaE63656ad3eaa10"
24622
- },
24623
- {
24624
- name: "incoLightning_0_1_23__830342853",
24625
- executorAddress: "0xF167b01eeE3eB16809D115a3476073121ACbA67C",
24626
- deployer: "0x8202D2D747784Cb7D48868E44C42C4bf162a70BC",
24627
- pepper: "",
24628
- version: {
24629
- major: 0,
24630
- minor: 1,
24631
- patch: 23,
24632
- shortSalt: "830342853"
24633
- },
24634
- salt: "0x8202d2d747784cb7d48868e44c42c4bf162a70bc00ae982ce1d0aa3cd80660c5",
24635
- decryptSigner: "0x000000000000000000000000000000000000baBe",
24636
- eciesPublicKey: "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000babe",
24637
- chainId: "7311099111",
24638
- blockNumber: "1",
24639
- chainName: "Inco Release Chain",
24640
- active: true,
24641
- deployDate: "2025-04-21T15:51:26.472Z",
24642
- commit: "v3-23-g2694ffde-dirty",
24643
- sessionVerifierAddress: "0xe9d19e6680F15498B5963E7808048D644db2575b",
24644
- addTwoAddress: "0x70fC34B18B12E945cb2204FA77E5f8e1581890C3"
24645
- },
24646
- {
24647
- name: "incoLightning_0_1_23__547622051",
24648
- executorAddress: "0x022c0878EE7D09D385b0B97e6A6539FF2CaF31e6",
22590
+ name: "incoLightning_0_1_26__444235330",
22591
+ executorAddress: "0xdc8eD938ff2eB900bD5f86A88555a9f1956994fC",
24649
22592
  deployer: "0x8202D2D747784Cb7D48868E44C42C4bf162a70BC",
24650
22593
  pepper: "devnet",
24651
22594
  version: {
24652
22595
  major: 0,
24653
22596
  minor: 1,
24654
- patch: 23,
24655
- shortSalt: "547622051"
22597
+ patch: 26,
22598
+ shortSalt: "444235330"
24656
22599
  },
24657
- salt: "0x8202d2d747784cb7d48868e44c42c4bf162a70bc00a51354000c92f7911c34a3",
24658
- decryptSigner: "0x000000000000000000000000000000000000baBe",
24659
- eciesPublicKey: "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000babe",
24660
- chainId: "7311099111",
24661
- blockNumber: "1",
24662
- chainName: "Inco Release Chain",
22600
+ salt: "0x8202d2d747784cb7d48868e44c42c4bf162a70bc001bab4c5927c52fbea0d042",
22601
+ decryptSigner: "0xA8822DE8910f66D3d03F1eAfe2C0141dBc327Ee0",
22602
+ eciesPublicKey: "0x048a582d29083c2f3fefe024bf4dd9ab913ab8973716977da5f01106e0b84095b1e647a9e377175fcb66bda05087c93b05e1fd53a704d0914bb23a0b2a69e9f235",
22603
+ chainId: "10143",
22604
+ blockNumber: "13418528",
22605
+ chainName: "Monad Testnet",
24663
22606
  active: true,
24664
- deployDate: "2025-04-21T20:42:37.381Z",
24665
- commit: "v3-24-g20f55870-dirty",
24666
- sessionVerifierAddress: "0xC81bfB1fF4FC6bE913d97928Fa776F80F637c54c",
24667
- addTwoAddress: "0x70fC34B18B12E945cb2204FA77E5f8e1581890C3"
22607
+ deployDate: "2025-04-22T09:11:06.223Z",
22608
+ commit: "v3-24-gc9716e6c-dirty",
22609
+ sessionVerifierAddress: "0x3D4eB5f90E6d996c2b45b0BEb4110b5be98e243F",
22610
+ addTwoAddress: "0xfeE9C1E41b2268a4ad8EaDA35f510b8d89Cd041c"
24668
22611
  },
24669
22612
  {
24670
- name: "incoLightning_0_1_23__547622051",
24671
- executorAddress: "0x022c0878EE7D09D385b0B97e6A6539FF2CaF31e6",
22613
+ name: "incoLightning_0_1_26__444235330",
22614
+ executorAddress: "0xdc8eD938ff2eB900bD5f86A88555a9f1956994fC",
24672
22615
  deployer: "0x8202D2D747784Cb7D48868E44C42C4bf162a70BC",
24673
22616
  pepper: "devnet",
24674
22617
  version: {
24675
22618
  major: 0,
24676
22619
  minor: 1,
24677
- patch: 23,
24678
- shortSalt: "547622051"
22620
+ patch: 26,
22621
+ shortSalt: "444235330"
24679
22622
  },
24680
- salt: "0x8202d2d747784cb7d48868e44c42c4bf162a70bc00a51354000c92f7911c34a3",
24681
- decryptSigner: "0x000000000000000000000000000000000000baBe",
24682
- eciesPublicKey: "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000babe",
22623
+ salt: "0x8202d2d747784cb7d48868e44c42c4bf162a70bc001bab4c5927c52fbea0d042",
22624
+ decryptSigner: "0xA8822DE8910f66D3d03F1eAfe2C0141dBc327Ee0",
22625
+ eciesPublicKey: "0x048a582d29083c2f3fefe024bf4dd9ab913ab8973716977da5f01106e0b84095b1e647a9e377175fcb66bda05087c93b05e1fd53a704d0914bb23a0b2a69e9f235",
24683
22626
  chainId: "84532",
24684
- blockNumber: "24746162",
22627
+ blockNumber: "24772369",
24685
22628
  chainName: "Base Sepolia",
24686
22629
  active: true,
24687
- deployDate: "2025-04-21T18:36:58.672Z",
24688
- commit: "v3-24-g87309821-dirty",
24689
- sessionVerifierAddress: "0xC81bfB1fF4FC6bE913d97928Fa776F80F637c54c",
24690
- addTwoAddress: "0x5Bf736A106E32198566BE75D1f80e9a2E28698b1"
24691
- },
24692
- {
24693
- name: "incoLightning_0_1_23__547622051",
24694
- executorAddress: "0x022c0878EE7D09D385b0B97e6A6539FF2CaF31e6",
24695
- deployer: "0x8202D2D747784Cb7D48868E44C42C4bf162a70BC",
24696
- pepper: "devnet",
24697
- version: {
24698
- major: 0,
24699
- minor: 1,
24700
- patch: 23,
24701
- shortSalt: "547622051"
24702
- },
24703
- salt: "0x8202d2d747784cb7d48868e44c42c4bf162a70bc00a51354000c92f7911c34a3",
24704
- decryptSigner: "0xbff4525eeb0C96f67f2AeB8a1eF3cF53f7996742",
24705
- eciesPublicKey: "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000babe",
24706
- chainId: "31337",
24707
- blockNumber: "5",
24708
- chainName: "Foundry",
24709
- active: true,
24710
- deployDate: "2025-04-21T18:36:33.385Z",
24711
- commit: "v3-24-g87309821-dirty",
24712
- sessionVerifierAddress: "0xC81bfB1fF4FC6bE913d97928Fa776F80F637c54c",
24713
- addTwoAddress: "0x723c2be5E61e7bBec4684DEfEaE63656ad3eaa10"
22630
+ deployDate: "2025-04-22T09:10:33.275Z",
22631
+ commit: "v3-24-gc9716e6c-dirty",
22632
+ sessionVerifierAddress: "0x3D4eB5f90E6d996c2b45b0BEb4110b5be98e243F",
22633
+ addTwoAddress: "0xeEa387f7c866A81c2AF532D9ed48c60F179C9827"
24714
22634
  }
24715
22635
  ];
24716
22636
 
24717
22637
  // src/lite/deployments.ts
24718
- function getActiveIncoLiteDeployment(chain) {
22638
+ function getActiveLightningDeployment(chain) {
24719
22639
  const supportedChain = getSupportedChain(chain);
24720
22640
  const deployments = lightningDeployments.filter((d) => d.chainId === String(supportedChain.id));
24721
22641
  if (!deployments?.length) {
@@ -24723,7 +22643,7 @@ function getActiveIncoLiteDeployment(chain) {
24723
22643
  }
24724
22644
  return deployments[0];
24725
22645
  }
24726
- function getIncoLiteDeployments(chainId) {
22646
+ function getLightningDeployments(chainId) {
24727
22647
  const supportedChain = getSupportedChain(chainId);
24728
22648
  const deployments = lightningDeployments.filter((d) => d.chainId === String(supportedChain.id));
24729
22649
  return deployments ?? [];
@@ -24777,7 +22697,7 @@ function createEIP712Payload({
24777
22697
  }
24778
22698
  }
24779
22699
  if (!domainVersion) {
24780
- const incoLite = getActiveIncoLiteDeployment(chainId);
22700
+ const incoLite = getActiveLightningDeployment(chainId);
24781
22701
  domainVersion = `${incoLite.version.major}_${incoLite.version.minor}_${incoLite.version.patch}`;
24782
22702
  }
24783
22703
  const msgParams = {