import "filippo.io/age/internal/bech32"

// 在 age 中私钥的别称是 Identity
type X25519Identity struct {
	secretKey, ourPublicKey []byte
}

func (i *X25519Identity) String() string {
	s, _ := bech32.Encode("AGE-SECRET-KEY-", i.secretKey)
	return strings.ToUpper(s)
}

func (i *X25519Identity) Recipient() *X25519Recipient {
	r := &X25519Recipient{}
	r.theirPublicKey = i.ourPublicKey
	return r
}

// 在 age 中公钥的别称是 Recipient
type X25519Recipient struct {
	theirPublicKey []byte
}

func (r *X25519Recipient) String() string {
	s, _ := bech32.Encode("age", r.theirPublicKey)
	return s
}

// internal/age/x25519.go

// 己方密钥不参与加密流程
// 那么这里用作 ECDH 的 x25519 key 也需要是临时生成的

// 生成一对 x25519 临时私钥
ephemeral := make([]byte, curve25519.ScalarSize)
if _, err := rand.Read(ephemeral); err != nil {
	return nil, err
}

// 根据私钥计算临时公钥
ourPublicKey, err := curve25519.X25519(ephemeral, curve25519.Basepoint)
if err != nil {
	return nil, err
}

// 计算 ECDH 共享密钥
var r *X25519Recipient
sharedSecret, err := curve25519.X25519(ephemeral, r.theirPublicKey)
if err != nil {
	return nil, err
}

// internal/age/x25519.go

const x25519Label = "age-encryption.org/v1/X25519"

salt := make([]byte, 0, len(ourPublicKey)+len(r.theirPublicKey))
// 使用我方临时公钥和对方公钥作为 HKDF 盐
salt = append(salt, ourPublicKey...)
salt = append(salt, r.theirPublicKey...)
// 使用 ECDH 公钥密钥 secret 材料生成最终的 filekey 加密密钥 wrappingKey
h := hkdf.New(sha256.New, sharedSecret, salt, []byte(x25519Label))
wrappingKey := make([]byte, chacha20poly1305.KeySize)
if _, err := io.ReadFull(h, wrappingKey); err != nil {
	return nil, err
}

// internal/age/primitives.go
func aeadEncrypt(key, plaintext []byte) ([]byte, error) {
	aead, err := chacha20poly1305.New(key)
	if err != nil {
		return nil, err
	}
	// The nonce is fixed because this function is only used in places where the
	// spec guarantees each key is only used once (by deriving it from values
	// that include fresh randomness), allowing us to save the overhead.
	// For the code that encrypts the actual payload, look at the
	// filippo.io/age/internal/stream package.
	nonce := make([]byte, chacha20poly1305.NonceSize)
	return aead.Seal(nil, nonce, plaintext, nil), nil
}

func headerMAC(fileKey []byte, hdr *format.Header) ([]byte, error) {
	// 通过 filekey 计算 mac key
	h := hkdf.New(sha256.New, fileKey, nil, []byte("header"))
	hmacKey := make([]byte, 32)
	if _, err := io.ReadFull(h, hmacKey); err != nil {
		return nil, err
	}
	hh := hmac.New(sha256.New, hmacKey)
	// 下面这个过程是计算 header 的过程，内容参考上述 header 结构
	if err := hdr.MarshalWithoutMAC(hh); err != nil {
		return nil, err
	}
	return hh.Sum(nil), nil
}

func streamKey(fileKey, nonce []byte) []byte {
	h := hkdf.New(sha256.New, fileKey, nonce, []byte("payload"))
	streamKey := make([]byte, chacha20poly1305.KeySize)
	if _, err := io.ReadFull(h, streamKey); err != nil {
		panic("age: internal error: failed to read from HKDF: " + err.Error())
	}
	return streamKey
}

ReadFull(r Reader, buf []byte) (n int, err error)

package rand

import "io"

var Reader io.Reader

func Read(b []byte) (n int, err error) {
	return io.ReadFull(Reader, b)
}

func ReadFull(r Reader, buf []byte) (n int, err error) {
	return ReadAtLeast(r, buf, len(buf))
}

func ReadAtLeast(r Reader, buf []byte, min int) (n int, err error) {
	if len(buf) < min {
		return 0, ErrShortBuffer
	}
	for n < min && err == nil {
		var nn int
		nn, err = r.Read(buf[n:])
		n += nn
	}
	if n >= min {
		err = nil
	} else if n > 0 && err == EOF {
		err = ErrUnexpectedEOF
	}
	return
}

package main

import (
	"bytes"
	"fmt"
	"io"
)

func main() {
	// 无数据 0 EOF
	{
		src := bytes.NewReader(make([]byte, 0))
		dsc := make([]byte, 40)
		fmt.Println(io.ReadFull(src, dsc))
	}

	// 数据不够 32 unexpected EOF
	{
		src := bytes.NewReader(make([]byte, 32))
		dsc := make([]byte, 40)
		fmt.Println(io.ReadFull(src, dsc))
	}

	// 数据正好 32 <nil>
	{
		src := bytes.NewReader(make([]byte, 32))
		dsc := make([]byte, 32)
		fmt.Println(io.ReadFull(src, dsc))
	}

	// 数据更多 32 <nil>
	{
		src := bytes.NewReader(make([]byte, 40))
		dsc := make([]byte, 32)
		fmt.Println(io.ReadFull(src, dsc))
	}
}

a = append(a, b...)

b = make([]T, len(a))
copy(b, a)
// or
b = append([]T(nil), a...)
// or
b = append(a[:0:0], a...)  // See https://github.com/go101/go101/wiki

a = append(a[:i], a[j:]...)

a = append(a[:i], a[i+1:]...)
// or
a = a[:i+copy(a[i:], a[i+1:])]

a[i] = a[len(a)-1] 
a = a[:len(a)-1]

copy(a[i:], a[j:])
for k, n := len(a)-j+i, len(a); k < n; k++ {
	a[k] = nil // 或 T 的零值
}
a = a[:len(a)-j+i]

if i < len(a)-1 {
  copy(a[i:], a[i+1:])
}
a[len(a)-1] = nil // 或 T 的零值
a = a[:len(a)-1]

a[i] = a[len(a)-1]
a[len(a)-1] = nil
a = a[:len(a)-1]

a = append(a[:i], append(make([]T, j), a[i:]...)...)

a = append(a, make([]T, j)...)

n := 0
for _, x := range a {
	if keep(x) {
		a[n] = x
		n++
	}
}
a = a[:n]

b := a[:0]
for _, x := range a {
	if f(x) {
		b = append(b, x)
	}
}

for i := len(b); i < len(a); i++ {
	a[i] = nil // or the zero value of T
}

for i := len(a)/2-1; i >= 0; i-- {
	opp := len(a)-1-i
	a[i], a[opp] = a[opp], a[i]
}

for left, right := 0, len(a)-1; left < right; left, right = left+1, right-1 {
	a[left], a[right] = a[right], a[left]
}

for i := len(a) - 1; i > 0; i-- {
    j := rand.Intn(i + 1)
    a[i], a[j] = a[j], a[i]
}

actions := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
batchSize := 3
batches := make([][]int, 0, (len(actions) + batchSize - 1) / batchSize)

for batchSize < len(actions) {
    actions, batches = actions[batchSize:], append(batches, actions[0:batchSize:batchSize])
}
batches = append(batches, actions)

import "sort"

in := []int{3,2,1,4,3,2,1,4,1} // any item can be sorted
sort.Ints(in)
j := 0
for i := 1; i < len(in); i++ {
	if in[j] == in[i] {
		continue
	}
	j++
	// preserve the original data
	// in[i], in[j] = in[j], in[i]
	// only set what is required
	in[j] = in[i]
}
result := in[:j+1]
fmt.Println(result) // [1 2 3 4]

a := [1,2,3]
a = nil
fmt.Println(a, len(a), cap(a) // [] 0 0

a := [1,2,3]
a = a[:0]
fmt.Println(a, len(a), cap(a) // [] 0 3
fmt.Println(a[:1]) // [1]

package main

import (
	"fmt"
	"math/big"
)

func main() {
	var a = big.NewInt(100)
	var b = new(big.Int).Set(a)
	a.Add(a, big.NewInt(100))
	fmt.Println(a, b) // 200 100
}

package main

import (
	"fmt"
	"math/big"
)

func main() {
	var a = big.NewInt(1)
	var b = big.NewInt(-1)
	fmt.Println(a.Sign(), b.Sign())
}

var a = new(big.Int)
fmt.Println(a.BitLen()) // Output: 0

var a = big.NewInt(1)
fmt.Println(hex.EncodeToString(a.Bytes())) // Output: 01

package main

import (
	"encoding/hex"
	"fmt"
	"math/big"
)

func main() {
	a := big.NewInt(1)
	v := a.FillBytes(make([]byte, 32))
	fmt.Println(hex.EncodeToString(v))
        // Output:
        // 0000000000000000000000000000000000000000000000000000000000000001
}

package main

import (
	"encoding/json"
	"fmt"

	"github.com/islishude/bigint"
)

func main() {
	a := bigint.New(100)
	data, err := json.Marshal(a)
	if err != nil {
		panic(err)
	}
	fmt.Println(string(data)) // "100"
}

package main

import (
	"encoding/json"
	"fmt"

	"github.com/islishude/bigint"
)

func main() {
	type Object struct {
		Field bigint.Int
	}

	var d Object
	_ = json.Unmarshal([]byte(`{"Field": "0x3"}`), &d)
	fmt.Println(d.Field) // 3

	var e Object
	_ = json.Unmarshal([]byte(`{"Field": "0x"}`), &e)
	fmt.Println(e.Field) // <nil>
}

// sql.Scanner
var i Int
_ = db.QueryRow("SELECT i FROM example WHERE id=1;").Scan(&i)

// driver.Valuer
var i bigint.Int
_ = db.Exec("INSERT INTO example (i) VALUES (?);", i) // nullable
i = bigint.New(1024)
_ = db.Exec("INSERT INTO example (i) VALUES (?);", i)

package main

import (
	"strings"

	"github.com/ethereum/go-ethereum/accounts/abi"
	"github.com/ethereum/go-ethereum/common"
)

func main() {
	// abidata 为 Account 合约 ABI json
	parsed, err := abi.JSON(strings.NewReader(abidata))
	if err != nil {
		panic(err)
	}

	// Account 合约构造函数设置了 reciever 参数
	// 为了以后能生成这个地址，这个需要持久化保存
	const reciever = "0x9639C636F1ECDA62c6c3d6eb8c1C4A630E184ff7"
	param, err := parsed.Pack("", common.HexToAddress(reciever))
	if err != nil {
		panic(err)
	}

	// 计算 Account 合约初始化哈希
	// 360c3c0304ab4f09eee311be7433387a83c3d62c7150e7654dfa339f5294eb45
	inithash := Keccak256(MustHexDecode(bytecode), param)
}

// Wallet 合约地址
address := MustHexDecode("0x908e2d13714091fa97c7deb010080516817beaec")
salt := MustHexDecode("0x844e2b5a3210a359906614364618e2991ecd95223bdaf2733ade658613540a9d")
inithash := MustHexDecode("360c3c0304ab4f09eee311be7433387a83c3d62c7150e7654dfa339f5294eb45")
// keccak256( 0xff ++ address ++ salt ++ keccak256(init_code))[12:]
addr := "0x" + hex.EncodeToString(Keccak256([]byte{0xff}, address, salt, inithash)[12:])
// 0x73026082ffa5b73dcbaa95626441bd9f7d4b64fd
fmt.Println(addr)

package main

import (
	"encoding/hex"

	"golang.org/x/crypto/sha3"
)

func MustHexDecode(raw string) []byte {
        if raw == "0x" {
                return []byte{}
        }
	if len(raw) > 2 && raw[:2] == "0x" {
		raw = raw[2:]
	}
	data, err := hex.DecodeString(raw)
	if err != nil {
		panic(err)
	}
	return data
}

func Keccak256(data ...[]byte) []byte {
	d := sha3.NewLegacyKeccak256()
	for _, b := range data {
		_, _ = d.Write(b)
	}
	return d.Sum(nil)
}

package main

import (
	"bytes"
	"context"
	"fmt"
	"math/big"

	"github.com/ethereum/go-ethereum"
	"github.com/ethereum/go-ethereum/accounts/abi"
	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/common/hexutil"
	"github.com/ethereum/go-ethereum/ethclient"
)

func main() {
	rpcclient, _ := ethclient.Dial("http://127.0.0.1:8545")
	contract := common.HexToAddress("0x6cC7f0784587DE4c3Da4c74b01707a4d0A3B32a4")
	calldata := ethereum.CallMsg{
		From: common.HexToAddress("0xF59fB9ff455c68627bd852d6FEb87Ba73398B9Aa"), To: &contract,
		Gas: 300_000, GasPrice: big.NewInt(1), Data: hexutil.MustDecode("0xf8a8fd6d"),
	}

	result, _ := rpcclient.CallContract(context.Background(), calldata, nil)
	// Keccak256("Error(string)")[:4] == "0x08c379a0"
	if bytes.HasPrefix(result, []byte{0x08, 0xc3, 0x79, 0xa0}) {
		strtyp, _ := abi.NewType("string", "", nil)
		var errstr string
		_ = abi.Arguments{{Type: strtyp}}.Unpack(&errstr, result[4:])
		fmt.Println(errstr)
	}
}

data, _ := hex.DecodeString("...")
reason, _ := abi.UnpackRevert(data)