feat(verify): scalar arguments for -call invocations

verify/buffers.go

@@ -148,3 +148,73 @@ func fillBuffer(buf []byte, pattern string) {
 		}
 	}
 }
+
+// ApplyScalarArgs writes user-supplied scalar argument values into an ABI0
+// argument block after BuildArgs.  Each name=value pair addresses the layout
+// entry of that parameter name; only word-sized scalar parameters (int,
+// int64, uint64, and their named spellings) accept values, so a typo'd name
+// or a slice parameter fails loudly instead of silently corrupting the call.
+func ApplyScalarArgs(args []byte, layout []ArgOffset, scalars map[string]uint64) error {
+	if len(scalars) == 0 {
+		return nil
+	}
+	byName := make(map[string]ArgOffset, len(layout))
+	for _, l := range layout {
+		byName[l.Name] = l
+	}
+	for name, val := range scalars {
+		l, ok := byName[name]
+		if !ok {
+			return fmt.Errorf("scalar arg %q: no such parameter", name)
+		}
+		if l.IsPtr || l.Size != 8 {
+			return fmt.Errorf("scalar arg %q: parameter has type %s; only word-sized scalars accept values", name, l.Typ)
+		}
+		if l.Offset+8 > len(args) {
+			return fmt.Errorf("scalar arg %q: offset %d outside the %d-byte arg block", name, l.Offset, len(args))
+		}
+		binary.LittleEndian.PutUint64(args[l.Offset:], val)
+	}
+	return nil
+}
+
+// ParseScalarArgs parses a "name=value[,name=value...]" spec into a map.
+// Values are decimal or 0x-prefixed hex.
+func ParseScalarArgs(spec string) (map[string]uint64, error) {
+	out := map[string]uint64{}
+	if strings.TrimSpace(spec) == "" {
+		return out, nil
+	}
+	for _, part := range strings.Split(spec, ",") {
+		part = strings.TrimSpace(part)
+		if part == "" {
+			continue
+		}
+		name, val, err := splitScalar(part)
+		if err != nil {
+			return nil, err
+		}
+		out[name] = val
+	}
+	return out, nil
+}
+
+func splitScalar(part string) (string, uint64, error) {
+	eq := strings.Index(part, "=")
+	if eq <= 0 {
+		return "", 0, fmt.Errorf("scalar arg spec %q: want name=value", part)
+	}
+	name := strings.TrimSpace(part[:eq])
+	valStr := strings.TrimSpace(part[eq+1:])
+	var val uint64
+	var err error
+	if strings.HasPrefix(valStr, "0x") || strings.HasPrefix(valStr, "0X") {
+		_, err = fmt.Sscanf(valStr, "0x%x", &val)
+	} else {
+		_, err = fmt.Sscanf(valStr, "%d", &val)
+	}
+	if err != nil || name == "" {
+		return "", 0, fmt.Errorf("scalar arg spec %q: bad value", part)
+	}
+	return name, val, nil
+}