params_gen.go

//go:build ignore

package main

import (
	"encoding/hex"
	"encoding/json"
	"fmt"
	"net/http"
	"os"
	"slices"
	"strings"
	"text/template"

	"github.com/lmittmann/go-solc/internal/version"
)

var (
	solcBaseURL = "https://binaries.soliditylang.org/"

	tmpl = template.Must(template.New("").Funcs(template.FuncMap{
		"replaceAll": strings.ReplaceAll,
		"last":       func(s []*build) int { return len(s) - 1 },
	}).Parse(tmplStr))
)

func main() {
	targets := []*target{
		{
			BaseURL:    solcBaseURL + "linux-amd64/",
			Fn:         "params_linux_amd64.go",
			MinVersion: "0.4.10",
		},
		{
			BaseURL:    solcBaseURL + "macosx-amd64/",
			Fn:         "params_darwin_amd64.go",
			MinVersion: "0.4.10",
		},
		{
			BaseURL:    solcBaseURL + "macosx-amd64/",
			Fn:         "params_darwin_arm64.go",
			MinVersion: "0.4.10",
		},
	}

	errCh := make(chan error)
	for _, target := range targets {
		target := target

		go func() { errCh <- gen(target) }()
	}

	for i := 0; i < len(targets); i++ {
		if err := <-errCh; err != nil {
			fmt.Println(err)
		}
	}
}

func gen(target *target) error {
	// fetch and decode list.json
	resp, err := http.Get(target.BaseURL + "list.json")
	if err != nil {
		return err
	}
	defer resp.Body.Close()

	var list struct {
		Builds []*build `json:"builds"`
	}
	if err := json.NewDecoder(resp.Body).Decode(&list); err != nil {
		return err
	}

	// open file
	f, err := os.Create(target.Fn)
	if err != nil {
		return err
	}
	defer f.Close()

	// execute template
	model := &model{
		Target: target,
		Builds: slices.DeleteFunc(list.Builds, func(build *build) bool {
			fmt.Println(build.Version, target.MinVersion)
			return version.Compare(build.Version, target.MinVersion) < 0 || strings.Contains(build.LongVersion, "-pre")
		}),
	}
	if err := tmpl.Execute(f, model); err != nil {
		return err
	}
	return nil
}

type target struct {
	BaseURL    string
	Fn         string
	MinVersion string
}

type build struct {
	Path        string  `json:"path"`
	Version     string  `json:"version"`
	LongVersion string  `json:"longVersion"`
	Sha256      bytes32 `json:"sha256"`
}

// bytes32 is a byte array that is unmarshaled from a hexstring.
type bytes32 [32]byte

func (b *bytes32) UnmarshalText(text []byte) error {
	if len(text) != 66 {
		return fmt.Errorf("invalid hex string")
	}
	_, err := hex.Decode(b[:], text[2:])
	return err
}

type model struct {
	Target *target  `json:"target"`
	Builds []*build `json:"builds"`
}

const tmplStr = `// Code generated by "go generate"; DO NOT EDIT.

package solc

func init() {
	solcBaseURL = "{{ .Target.BaseURL }}"

	solcVersions = map[Version]solcVersion{
	{{- range .Builds }}
		{{ $version := (printf "Version%s:" (replaceAll .Version "." "_")) -}}
		{{ printf "%-14s" $version }} {Sha256: [32]byte{
		{{- range $i, $elem := .Sha256 -}}
			{{- if $i }}, {{ end -}}
			{{- printf "%#02v" $elem -}}
		{{- end -}}
		}, Path: "{{ .Path }}"},
	{{- end }}
	}

	Versions = []Version{
	{{- range .Builds }}
		{{ printf "Version%s," (replaceAll .Version "." "_") }}
	{{- end }}
	}
}

const (
{{- range .Builds }}
	{{ $version := (printf "%s" .Version) -}}
	{{ printf "Version%-6s Version = %q" (replaceAll .Version "." "_") .Version }}
{{- end }}

	// Latest version of solc.
	VersionLatest = Version{{ replaceAll (index .Builds (last .Builds)).Version "." "_" }}
)
`