viem 0.3.24 → 0.3.26

package/src/utils/abi/decodeEventLog.ts

@@ -93,8 +93,8 @@ export function decodeEventLog<
   let args: any = isUnnamed ? [] : {}
 
   // Decode topics (indexed args).
+  const indexedInputs = inputs.filter((x) => 'indexed' in x && x.indexed)
   if (argTopics.length > 0) {
-    const indexedInputs = inputs.filter((x) => 'indexed' in x && x.indexed)
     for (let i = 0; i < indexedInputs.length; i++) {
       const param = indexedInputs[i]
       const topic = argTopics[i]
@@ -108,15 +108,15 @@ export function decodeEventLog<
   }
 
   // Decode data (non-indexed args).
+  const nonIndexedInputs = inputs.filter((x) => !('indexed' in x && x.indexed))
   if (data && data !== '0x') {
-    const params = inputs.filter((x) => !('indexed' in x && x.indexed))
     try {
-      const decodedData = decodeAbiParameters(params, data)
+      const decodedData = decodeAbiParameters(nonIndexedInputs, data)
       if (decodedData) {
         if (isUnnamed) args = [...args, ...decodedData]
         else {
-          for (let i = 0; i < params.length; i++) {
-            args[params[i].name!] = decodedData[i]
+          for (let i = 0; i < nonIndexedInputs.length; i++) {
+            args[nonIndexedInputs[i].name!] = decodedData[i]
           }
         }
       }

package/src/utils/data/slice.ts

@@ -19,15 +19,38 @@ export function slice<TValue extends ByteArray | Hex>(
   value: TValue,
   start?: number,
   end?: number,
+  { strict }: { strict?: boolean } = {},
 ): SliceReturnType<TValue> {
   if (isHex(value))
-    return sliceHex(value as Hex, start, end) as SliceReturnType<TValue>
-  return sliceBytes(value as ByteArray, start, end) as SliceReturnType<TValue>
+    return sliceHex(value as Hex, start, end, {
+      strict,
+    }) as SliceReturnType<TValue>
+  return sliceBytes(value as ByteArray, start, end, {
+    strict,
+  }) as SliceReturnType<TValue>
 }
 
 function assertStartOffset(value: Hex | ByteArray, start?: number) {
   if (typeof start === 'number' && start > 0 && start > size(value) - 1)
-    throw new SliceOffsetOutOfBoundsError({ offset: start, size: size(value) })
+    throw new SliceOffsetOutOfBoundsError({
+      offset: start,
+      position: 'start',
+      size: size(value),
+    })
+}
+
+function assertEndOffset(value: Hex | ByteArray, start?: number, end?: number) {
+  if (
+    typeof start === 'number' &&
+    typeof end === 'number' &&
+    size(value) !== end - start
+  ) {
+    throw new SliceOffsetOutOfBoundsError({
+      offset: end,
+      position: 'end',
+      size: size(value),
+    })
+  }
 }
 
 /**
@@ -38,12 +61,15 @@ function assertStartOffset(value: Hex | ByteArray, start?: number) {
  * @param end The end offset (in bytes).
  */
 export function sliceBytes(
-  value: ByteArray,
+  value_: ByteArray,
   start?: number,
   end?: number,
+  { strict }: { strict?: boolean } = {},
 ): ByteArray {
-  assertStartOffset(value, start)
-  return value.slice(start, end)
+  assertStartOffset(value_, start)
+  const value = value_.slice(start, end)
+  if (strict) assertEndOffset(value, start, end)
+  return value
 }
 
 /**
@@ -53,10 +79,16 @@ export function sliceBytes(
  * @param start The start offset (in bytes).
  * @param end The end offset (in bytes).
  */
-export function sliceHex(value_: Hex, start?: number, end?: number): Hex {
+export function sliceHex(
+  value_: Hex,
+  start?: number,
+  end?: number,
+  { strict }: { strict?: boolean } = {},
+): Hex {
   assertStartOffset(value_, start)
-  const value = value_
+  const value = `0x${value_
     .replace('0x', '')
-    .slice((start ?? 0) * 2, (end ?? value_.length) * 2)
-  return `0x${value}`
+    .slice((start ?? 0) * 2, (end ?? value_.length) * 2)}` as const
+  if (strict) assertEndOffset(value, start, end)
+  return value
 }