From 5bf1d579f942c03a7ad69c8f24e74ddde7136322 Mon Sep 17 00:00:00 2001 From: RafilxTenfen Date: Fri, 26 Jul 2024 11:14:42 -0300 Subject: [PATCH] chore: add initial files --- README.md | 3 + go.work | 3 + go.work.sum | 34 ++ parameters/go.mod | 20 + parameters/go.sum | 109 ++++++ parameters/parser/ParamsParser.go | 370 +++++++++++++++++++ parameters/parser/ParamsParser_test.go | 487 +++++++++++++++++++++++++ 7 files changed, 1026 insertions(+) create mode 100644 README.md create mode 100644 go.work create mode 100644 go.work.sum create mode 100644 parameters/go.mod create mode 100644 parameters/go.sum create mode 100644 parameters/parser/ParamsParser.go create mode 100644 parameters/parser/ParamsParser_test.go diff --git a/README.md b/README.md new file mode 100644 index 00000000..31340e79 --- /dev/null +++ b/README.md @@ -0,0 +1,3 @@ +# Networks + +This repository contains information about networks launched by Babylon Labs. diff --git a/go.work b/go.work new file mode 100644 index 00000000..b62f93e7 --- /dev/null +++ b/go.work @@ -0,0 +1,3 @@ +go 1.22.3 + +use ./parameters diff --git a/go.work.sum b/go.work.sum new file mode 100644 index 00000000..711013c9 --- /dev/null +++ b/go.work.sum @@ -0,0 +1,34 @@ +github.com/aead/siphash v1.0.1 h1:FwHfE/T45KPKYuuSAKyyvE+oPWcaQ+CUmFW0bPlM+kg= +github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f h1:bAs4lUbRJpnnkd9VhRV3jjAVU7DJVjMaK+IsvSeZvFo= +github.com/btcsuite/btcutil v0.0.0-20190425235716-9e5f4b9a998d h1:yJzD/yFppdVCf6ApMkVy8cUxV0XrxdP9rVf6D87/Mng= +github.com/btcsuite/go-socks v0.0.0-20170105172521-4720035b7bfd h1:R/opQEbFEy9JGkIguV40SvRY1uliPX8ifOvi6ICsFCw= +github.com/btcsuite/goleveldb v1.0.0 h1:Tvd0BfvqX9o823q1j2UZ/epQo09eJh6dTcRp79ilIN4= +github.com/btcsuite/snappy-go v1.0.0 h1:ZxaA6lo2EpxGddsA8JwWOcxlzRybb444sgmeJQMJGQE= +github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792 h1:R8vQdOQdZ9Y3SkEwmHoWBmX1DNXhXZqlTpq6s4tyJGc= +github.com/btcsuite/winsvc v1.0.0 h1:J9B4L7e3oqhXOcm+2IuNApwzQec85lE+QaikUcCs+dk= +github.com/decred/dcrd/crypto/blake256 v1.0.0 h1:/8DMNYp9SGi5f0w7uCm6d6M4OU2rGFK09Y2A4Xv7EE0= +github.com/decred/dcrd/lru v1.0.0 h1:Kbsb1SFDsIlaupWPwsPp+dkxiBY1frcS07PCPgotKz8= +github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4= +github.com/golang/protobuf v1.4.2 h1:+Z5KGCizgyZCbGh1KZqA0fcLLkwbsjIzS4aV2v7wJX0= +github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM= +github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4= +github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc= +github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI= +github.com/jessevdk/go-flags v1.4.0 h1:4IU2WS7AumrZ/40jfhf4QVDMsQwqA7VEHozFRrGARJA= +github.com/jrick/logrotate v1.0.0 h1:lQ1bL/n9mBNeIXoTUoYRlK4dHuNJVofX9oWqBtPnSzI= +github.com/kkdai/bstream v0.0.0-20161212061736-f391b8402d23 h1:FOOIBWrEkLgmlgGfMuZT83xIwfPDxEI2OHu6xUmJMFE= +github.com/nxadm/tail v1.4.4 h1:DQuhQpB1tVlglWS2hLQ5OV6B5r8aGxSrPc5Qo6uTN78= +github.com/onsi/ginkgo v1.14.0 h1:2mOpI4JVVPBN+WQRa0WKH2eXR+Ey+uK4n7Zj0aYpIQA= +github.com/onsi/gomega v1.10.1 h1:o0+MgICZLuZ7xjH7Vx6zS/zcu93/BEp1VwkIW1mEXCE= +github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4= +github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY= +golang.org/x/net v0.0.0-20200813134508-3edf25e44fcc h1:zK/HqS5bZxDptfPJNq8v7vJfXtkU7r9TLIoSr1bXaP4= +golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f h1:wMNYb4v58l5UBM7MYRLPG6ZhfOqbKu7X5eyFl8ZhKvA= +golang.org/x/text v0.3.3 h1:cokOdA+Jmi5PJGXLlLllQSgYigAEfHXJAERHVMaCc2k= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e h1:FDhOuMEY4JVRztM/gsbk+IKUQ8kj74bxZrgw87eMMVc= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE= +google.golang.org/protobuf v1.23.0 h1:4MY060fB1DLGMB/7MBTLnwQUY6+F09GEiz6SsrNqyzM= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= +gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4= +gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ= +gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU= diff --git a/parameters/go.mod b/parameters/go.mod new file mode 100644 index 00000000..6783947a --- /dev/null +++ b/parameters/go.mod @@ -0,0 +1,20 @@ +module github.com/babylonlabs-io/networks/parameters + +go 1.22.3 + +require ( + github.com/btcsuite/btcd/btcec/v2 v2.1.3 + github.com/btcsuite/btcd/btcutil v1.1.5 + github.com/stretchr/testify v1.7.0 +) + +require ( + github.com/btcsuite/btcd v0.24.0 // indirect + github.com/btcsuite/btcd/chaincfg/chainhash v1.1.0 // indirect + github.com/davecgh/go-spew v1.1.1 // indirect + github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect + golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9 // indirect + golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed // indirect + gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c // indirect +) diff --git a/parameters/go.sum b/parameters/go.sum new file mode 100644 index 00000000..fe604e98 --- /dev/null +++ b/parameters/go.sum @@ -0,0 +1,109 @@ +github.com/aead/siphash v1.0.1/go.mod h1:Nywa3cDsYNNK3gaciGTWPwHt0wlpNV15vwmswBAUSII= +github.com/btcsuite/btcd v0.20.1-beta/go.mod h1:wVuoA8VJLEcwgqHBwHmzLRazpKxTv13Px/pDuV7OomQ= +github.com/btcsuite/btcd v0.22.0-beta.0.20220111032746-97732e52810c/go.mod h1:tjmYdS6MLJ5/s0Fj4DbLgSbDHbEqLJrtnHecBFkdz5M= +github.com/btcsuite/btcd v0.23.5-0.20231215221805-96c9fd8078fd/go.mod h1:nm3Bko6zh6bWP60UxwoT5LzdGJsQJaPo6HjduXq9p6A= +github.com/btcsuite/btcd v0.24.0 h1:gL3uHE/IaFj6fcZSu03SvqPMSx7s/dPzfpG/atRwWdo= +github.com/btcsuite/btcd v0.24.0/go.mod h1:K4IDc1593s8jKXIF7yS7yCTSxrknB9z0STzc2j6XgE4= +github.com/btcsuite/btcd/btcec/v2 v2.1.0/go.mod h1:2VzYrv4Gm4apmbVVsSq5bqf1Ec8v56E48Vt0Y/umPgA= +github.com/btcsuite/btcd/btcec/v2 v2.1.3 h1:xM/n3yIhHAhHy04z4i43C8p4ehixJZMsnrVJkgl+MTE= +github.com/btcsuite/btcd/btcec/v2 v2.1.3/go.mod h1:ctjw4H1kknNJmRN4iP1R7bTQ+v3GJkZBd6mui8ZsAZE= +github.com/btcsuite/btcd/btcutil v1.0.0/go.mod h1:Uoxwv0pqYWhD//tfTiipkxNfdhG9UrLwaeswfjfdF0A= +github.com/btcsuite/btcd/btcutil v1.1.0/go.mod h1:5OapHB7A2hBBWLm48mmw4MOHNJCcUBTwmWH/0Jn8VHE= +github.com/btcsuite/btcd/btcutil v1.1.5 h1:+wER79R5670vs/ZusMTF1yTcRYE5GUsFbdjdisflzM8= +github.com/btcsuite/btcd/btcutil v1.1.5/go.mod h1:PSZZ4UitpLBWzxGd5VGOrLnmOjtPP/a6HaFo12zMs00= +github.com/btcsuite/btcd/chaincfg/chainhash v1.0.0/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc= +github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc= +github.com/btcsuite/btcd/chaincfg/chainhash v1.1.0 h1:59Kx4K6lzOW5w6nFlA0v5+lk/6sjybR934QNHSJZPTQ= +github.com/btcsuite/btcd/chaincfg/chainhash v1.1.0/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc= +github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f/go.mod h1:TdznJufoqS23FtqVCzL0ZqgP5MqXbb4fg/WgDys70nA= +github.com/btcsuite/btcutil v0.0.0-20190425235716-9e5f4b9a998d/go.mod h1:+5NJ2+qvTyV9exUAL/rxXi3DcLg2Ts+ymUAY5y4NvMg= +github.com/btcsuite/go-socks v0.0.0-20170105172521-4720035b7bfd/go.mod h1:HHNXQzUsZCxOoE+CPiyCTO6x34Zs86zZUiwtpXoGdtg= +github.com/btcsuite/goleveldb v0.0.0-20160330041536-7834afc9e8cd/go.mod h1:F+uVaaLLH7j4eDXPRvw78tMflu7Ie2bzYOH4Y8rRKBY= +github.com/btcsuite/goleveldb v1.0.0/go.mod h1:QiK9vBlgftBg6rWQIj6wFzbPfRjiykIEhBH4obrXJ/I= +github.com/btcsuite/snappy-go v0.0.0-20151229074030-0bdef8d06723/go.mod h1:8woku9dyThutzjeg+3xrA5iCpBRH8XEEg3lh6TiUghc= +github.com/btcsuite/snappy-go v1.0.0/go.mod h1:8woku9dyThutzjeg+3xrA5iCpBRH8XEEg3lh6TiUghc= +github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792/go.mod h1:ghJtEyQwv5/p4Mg4C0fgbePVuGr935/5ddU9Z3TmDRY= +github.com/btcsuite/winsvc v1.0.0/go.mod h1:jsenWakMcC0zFBFurPLEAyrnc/teJEM1O46fmI40EZs= +github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/decred/dcrd/crypto/blake256 v1.0.0/go.mod h1:sQl2p6Y26YV+ZOcSTP6thNdn47hh8kt6rqSlvmrXFAc= +github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 h1:YLtO71vCjJRCBcrPMtQ9nqBsqpA1m5sE92cU+pd5Mcc= +github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1/go.mod h1:hyedUtir6IdtD/7lIxGeCxkaw7y45JueMRL4DIyJDKs= +github.com/decred/dcrd/lru v1.0.0/go.mod h1:mxKOwFd7lFjN2GZYsiz/ecgqR6kkYAl+0pz0tEMk218= +github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= +github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= +github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8= +github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA= +github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs= +github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w= +github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0= +github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= +github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= +github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= +github.com/jessevdk/go-flags v0.0.0-20141203071132-1679536dcc89/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI= +github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI= +github.com/jrick/logrotate v1.0.0/go.mod h1:LNinyqDIJnpAur+b8yyulnQw/wDuN1+BYKlTRt3OuAQ= +github.com/kkdai/bstream v0.0.0-20161212061736-f391b8402d23/go.mod h1:J+Gs4SYgM6CZQHDETBtE9HaSEkGmuNXF86RwHhHUvq4= +github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A= +github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= +github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= +github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk= +github.com/onsi/ginkgo v1.14.0/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY= +github.com/onsi/gomega v1.4.1/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA= +github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= +github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY= +github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc= +golang.org/x/crypto v0.0.0-20170930174604-9419663f5a44/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9 h1:psW17arqaxU48Z5kZ0CQnkZWQJsqcURM6tKiBApRjXI= +golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/net v0.0.0-20180719180050-a680a1efc54d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200813134508-3edf25e44fcc/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed h1:J22ig1FUekjjkmZUM7pTKixYm8DvrYsvrBZdunYeIuQ= +golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= +google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= +google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= +google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE= +google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo= +google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= +gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= +gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/parameters/parser/ParamsParser.go b/parameters/parser/ParamsParser.go new file mode 100644 index 00000000..78269ea3 --- /dev/null +++ b/parameters/parser/ParamsParser.go @@ -0,0 +1,370 @@ +package parser + +import ( + "encoding/hex" + "encoding/json" + "fmt" + "math" + "os" + + "github.com/btcsuite/btcd/btcec/v2" + "github.com/btcsuite/btcd/btcutil" +) + +const ( + // tag length constant in bytes. We define it here as it won't change, but + // this allows us to not bring whole Babylon node as dependency. + TagLen = 4 + + // minimum unbonding output value to avoid the unbonding output value being + // less than Bitcoin dust + MinUnbondingOutputValue = btcutil.Amount(1000) +) + +func checkPositive(value uint64) error { + if value == 0 { + return fmt.Errorf("value must be positive") + } + return nil +} + +func parseTimeLockValue(timelock uint64) (uint16, error) { + if timelock > math.MaxUint16 { + return 0, fmt.Errorf("timelock value %d is too large. Max: %d", timelock, math.MaxUint16) + } + + if err := checkPositive(timelock); err != nil { + return 0, fmt.Errorf("invalid timelock value: %w", err) + } + + return uint16(timelock), nil +} + +func parseConfirmationDepthValue(confirmationDepth uint64) (uint16, error) { + if confirmationDepth > math.MaxUint16 { + return 0, fmt.Errorf("timelock value %d is too large. Max: %d", confirmationDepth, math.MaxUint16) + } + + if confirmationDepth <= 1 { + return 0, fmt.Errorf("confirmation depth value should be at least 2, got %d", confirmationDepth) + } + + return uint16(confirmationDepth), nil +} + +func parseBtcValue(value uint64) (btcutil.Amount, error) { + if value > math.MaxInt64 { + return 0, fmt.Errorf("value %d is too large. Max: %d", value, math.MaxInt64) + } + + if err := checkPositive(value); err != nil { + return 0, fmt.Errorf("invalid btc value: %w", err) + } + // return amount in satoshis + return btcutil.Amount(value), nil +} + +func parseUint32(value uint64) (uint32, error) { + if value > math.MaxUint32 { + return 0, fmt.Errorf("value %d is too large. Max: %d", value, math.MaxUint32) + } + + if err := checkPositive(value); err != nil { + return 0, fmt.Errorf("invalid value: %w", err) + } + + return uint32(value), nil +} + +// parseCovenantPubKeyFromHex parses public key string to btc public key +// the input should be 33 bytes +func parseCovenantPubKeyFromHex(pkStr string) (*btcec.PublicKey, error) { + pkBytes, err := hex.DecodeString(pkStr) + if err != nil { + return nil, err + } + + pk, err := btcec.ParsePubKey(pkBytes) + if err != nil { + return nil, err + } + + return pk, nil +} + +// either staking cap and cap height should be positive if cap height is positive +func parseCap(stakingCap, capHeight uint64) (btcutil.Amount, uint64, error) { + if stakingCap != 0 && capHeight != 0 { + return 0, 0, fmt.Errorf("only either of staking cap and cap height can be set") + } + + if stakingCap == 0 && capHeight == 0 { + return 0, 0, fmt.Errorf("either of staking cap and cap height must be set") + } + + if stakingCap != 0 { + parsedStakingCap, err := parseBtcValue(stakingCap) + return parsedStakingCap, 0, err + } + + return 0, capHeight, nil +} + +type GlobalParams struct { + Versions []*VersionedGlobalParams `json:"versions"` +} + +type VersionedGlobalParams struct { + Version uint64 `json:"version"` + ActivationHeight uint64 `json:"activation_height"` + StakingCap uint64 `json:"staking_cap,omitempty"` + CapHeight uint64 `json:"cap_height,omitempty"` + Tag string `json:"tag"` + CovenantPks []string `json:"covenant_pks"` + CovenantQuorum uint64 `json:"covenant_quorum"` + UnbondingTime uint64 `json:"unbonding_time"` + UnbondingFee uint64 `json:"unbonding_fee"` + MaxStakingAmount uint64 `json:"max_staking_amount"` + MinStakingAmount uint64 `json:"min_staking_amount"` + MaxStakingTime uint64 `json:"max_staking_time"` + MinStakingTime uint64 `json:"min_staking_time"` + ConfirmationDepth uint64 `json:"confirmation_depth"` +} + +type ParsedGlobalParams struct { + Versions []*ParsedVersionedGlobalParams +} + +type ParsedVersionedGlobalParams struct { + Version uint64 + ActivationHeight uint64 + StakingCap btcutil.Amount + CapHeight uint64 + Tag []byte + CovenantPks []*btcec.PublicKey + CovenantQuorum uint32 + UnbondingTime uint16 + UnbondingFee btcutil.Amount + MaxStakingAmount btcutil.Amount + MinStakingAmount btcutil.Amount + MaxStakingTime uint16 + MinStakingTime uint16 + ConfirmationDepth uint16 +} + +func ParseGlobalParams(p *GlobalParams) (*ParsedGlobalParams, error) { + if len(p.Versions) == 0 { + return nil, fmt.Errorf("global params must have at least one version") + } + var parsedVersions []*ParsedVersionedGlobalParams + + for i, v := range p.Versions { + vCopy := v + cv, err := parseVersionedGlobalParams(vCopy) + + if err != nil { + return nil, fmt.Errorf("invalid params with version %d: %w", vCopy.Version, err) + } + + // Check latest version + if len(parsedVersions) > 0 { + pv := parsedVersions[len(parsedVersions)-1] + + lastStakingCap := FindLastStakingCap(p.Versions[:i]) + + if cv.Version != pv.Version+1 { + return nil, fmt.Errorf("invalid params with version %d. versions should be monotonically increasing by 1", cv.Version) + } + if cv.StakingCap != 0 && cv.StakingCap < btcutil.Amount(lastStakingCap) { + return nil, fmt.Errorf("invalid params with version %d. staking cap cannot be decreased in later versions, last non-zero staking cap: %d, got: %d", + cv.Version, lastStakingCap, cv.StakingCap) + } + if cv.ActivationHeight <= pv.ActivationHeight { + return nil, fmt.Errorf("invalid params with version %d. activation height cannot be overlapping between earlier and later versions", cv.Version) + } + } + + parsedVersions = append(parsedVersions, cv) + } + + return &ParsedGlobalParams{ + Versions: parsedVersions, + }, nil +} + +func parseVersionedGlobalParams(p *VersionedGlobalParams) (*ParsedVersionedGlobalParams, error) { + tag, err := hex.DecodeString(p.Tag) + + if err != nil { + return nil, fmt.Errorf("invalid tag: %w", err) + } + + if len(tag) != TagLen { + return nil, fmt.Errorf("invalid tag length, expected %d, got %d", TagLen, len(tag)) + } + + if len(p.CovenantPks) == 0 { + return nil, fmt.Errorf("empty covenant public keys") + } + if p.CovenantQuorum > uint64(len(p.CovenantPks)) { + return nil, fmt.Errorf("covenant quorum %d cannot be more than the amount of covenants %d", p.CovenantQuorum, len(p.CovenantPks)) + } + + quorum, err := parseUint32(p.CovenantQuorum) + if err != nil { + return nil, fmt.Errorf("invalid covenant quorum: %w", err) + } + + var covenantKeys []*btcec.PublicKey + for _, covPk := range p.CovenantPks { + pk, err := parseCovenantPubKeyFromHex(covPk) + if err != nil { + return nil, fmt.Errorf("invalid covenant public key %s: %w", covPk, err) + } + + covenantKeys = append(covenantKeys, pk) + } + + maxStakingAmount, err := parseBtcValue(p.MaxStakingAmount) + + if err != nil { + return nil, fmt.Errorf("invalid max_staking_amount: %w", err) + } + + minStakingAmount, err := parseBtcValue(p.MinStakingAmount) + + if err != nil { + return nil, fmt.Errorf("invalid min_staking_amount: %w", err) + } + + // NOTE: Allow config when max-staking-amount is equal tomin-staking-amount, as then + // we can configure a fixed staking amount + if maxStakingAmount < minStakingAmount { + return nil, fmt.Errorf("max-staking-amount %d must be larger than or equal to min-staking-amount %d", maxStakingAmount, minStakingAmount) + } + + ubTime, err := parseTimeLockValue(p.UnbondingTime) + if err != nil { + return nil, fmt.Errorf("invalid unbonding_time: %w", err) + } + + ubFee, err := parseBtcValue(p.UnbondingFee) + if err != nil { + return nil, fmt.Errorf("invalid unbonding_fee: %w", err) + } + + if minStakingAmount < ubFee+MinUnbondingOutputValue { + return nil, fmt.Errorf("min_staking_amount %d should not be less than unbonding fee %d plus %d", + minStakingAmount, ubFee, MinUnbondingOutputValue) + } + + maxStakingTime, err := parseTimeLockValue(p.MaxStakingTime) + if err != nil { + return nil, fmt.Errorf("invalid max_staking_time: %w", err) + } + + minStakingTime, err := parseTimeLockValue(p.MinStakingTime) + if err != nil { + return nil, fmt.Errorf("invalid min_staking_time: %w", err) + } + + // NOTE: Allow config when max-staking-time is equal to min-staking-time, as then + // we can configure a fixed staking time. + if maxStakingTime < minStakingTime { + return nil, fmt.Errorf("max-staking-time %d must be larger than or equal to min-staking-time %d", maxStakingTime, minStakingTime) + } + + confirmationDepth, err := parseConfirmationDepthValue(p.ConfirmationDepth) + if err != nil { + return nil, fmt.Errorf("invalid confirmation_depth: %w", err) + } + + if err := checkPositive(p.ActivationHeight); err != nil { + return nil, fmt.Errorf("activation_height: %w", err) + } + + stakingCap, capHeight, err := parseCap(p.StakingCap, p.CapHeight) + if err != nil { + return nil, fmt.Errorf("invalid cap: %w", err) + } + + if stakingCap != 0 && stakingCap < maxStakingAmount { + return nil, fmt.Errorf("invalid staking_cap, should be larger than max_staking_amount: %d, got: %d", + maxStakingAmount, stakingCap) + } + + return &ParsedVersionedGlobalParams{ + Version: p.Version, + ActivationHeight: p.ActivationHeight, + StakingCap: stakingCap, + CapHeight: capHeight, + Tag: tag, + CovenantPks: covenantKeys, + CovenantQuorum: quorum, + UnbondingTime: ubTime, + UnbondingFee: ubFee, + MaxStakingAmount: maxStakingAmount, + MinStakingAmount: minStakingAmount, + MaxStakingTime: maxStakingTime, + MinStakingTime: minStakingTime, + ConfirmationDepth: confirmationDepth, + }, nil +} + +// GetVersionedGlobalParamsByHeight return the parsed versioned global params which +// are applicable at the given BTC btcHeight. If there in no versioned global params +// applicable at the given btcHeight, it will return nil. +func (g *ParsedGlobalParams) GetVersionedGlobalParamsByHeight(btcHeight uint64) *ParsedVersionedGlobalParams { + // Iterate the list in reverse (i.e. decreasing ActivationHeight) + // and identify the first element that has an activation height below + // the specified BTC height. + for i := len(g.Versions) - 1; i >= 0; i-- { + paramsVersion := g.Versions[i] + if paramsVersion.ActivationHeight <= btcHeight { + return paramsVersion + } + } + return nil +} + +// FindLastStakingCap finds the last staking cap that is not zero +// it returns zero if not non-zero value is found +func FindLastStakingCap(prevVersions []*VersionedGlobalParams) uint64 { + numPrevVersions := len(prevVersions) + if len(prevVersions) == 0 { + return 0 + } + + for i := numPrevVersions - 1; i >= 0; i-- { + if prevVersions[i].StakingCap > 0 { + return prevVersions[i].StakingCap + } + } + + return 0 +} + +func NewParsedGlobalParamsFromFile(filePath string) (*ParsedGlobalParams, error) { + data, err := os.ReadFile(filePath) + if err != nil { + return nil, err + } + + return NewParsedGlobalParamsFromBytes(data) +} + +func NewParsedGlobalParamsFromBytes(data []byte) (*ParsedGlobalParams, error) { + var globalParams GlobalParams + err := json.Unmarshal(data, &globalParams) + if err != nil { + return nil, err + } + + parsedGlobalParams, err := ParseGlobalParams(&globalParams) + + if err != nil { + return nil, err + } + + return parsedGlobalParams, nil +} diff --git a/parameters/parser/ParamsParser_test.go b/parameters/parser/ParamsParser_test.go new file mode 100644 index 00000000..83ce6bb9 --- /dev/null +++ b/parameters/parser/ParamsParser_test.go @@ -0,0 +1,487 @@ +package parser_test + +import ( + "encoding/hex" + "encoding/json" + "fmt" + "math" + "math/rand" + "os" + "strings" + "testing" + "time" + + "github.com/btcsuite/btcd/btcec/v2" + "github.com/btcsuite/btcd/btcutil" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + "github.com/babylonlabs-io/networks/parameters/parser" +) + +func addRandomSeedsToFuzzer(f *testing.F, num uint) { + // Seed based on the current time + r := rand.New(rand.NewSource(time.Now().Unix())) + var idx uint + for idx = 0; idx < num; idx++ { + f.Add(r.Int63()) + } +} + +var ( + initialCapMin, _ = btcutil.NewAmount(100) + tag = hex.EncodeToString([]byte{0x01, 0x02, 0x03, 0x04}) +) + +func generateInitParams(t *testing.T, r *rand.Rand) *parser.VersionedGlobalParams { + var pks []string + + quorum := r.Intn(10) + 1 + + for i := 0; i < quorum+1; i++ { + privkey, err := btcec.NewPrivateKey() + require.NoError(t, err) + pks = append(pks, hex.EncodeToString(privkey.PubKey().SerializeCompressed())) + } + + gp := parser.VersionedGlobalParams{ + Version: 0, + ActivationHeight: 1, + StakingCap: uint64(r.Int63n(int64(initialCapMin)) + int64(initialCapMin)), + CapHeight: 0, + Tag: tag, + CovenantPks: pks, + CovenantQuorum: uint64(quorum), + UnbondingTime: uint64(r.Int63n(100) + 100), + UnbondingFee: uint64(r.Int63n(100000) + 100000), + MaxStakingAmount: uint64(r.Int63n(100000000) + 100000000), + MinStakingAmount: uint64(r.Int63n(1000000) + 1000000), + MaxStakingTime: math.MaxUint16, + MinStakingTime: uint64(r.Int63n(10000) + 10000), + ConfirmationDepth: uint64(r.Int63n(10) + 2), + } + + return &gp +} + +func genValidGlobalParam( + t *testing.T, + r *rand.Rand, + num uint32, +) *parser.GlobalParams { + require.True(t, num > 0) + + initParams := generateInitParams(t, r) + + if num == 1 { + return &parser.GlobalParams{ + Versions: []*parser.VersionedGlobalParams{initParams}, + } + } + + var versions []*parser.VersionedGlobalParams + versions = append(versions, initParams) + + for i := 1; i < int(num); i++ { + prev := versions[i-1] + next := generateInitParams(t, r) + next.ActivationHeight = prev.ActivationHeight + uint64(r.Int63n(100)+100) + next.Version = prev.Version + 1 + // 1/3 chance to have a time-based cap + if r.Intn(3) == 0 { + next.CapHeight = next.ActivationHeight + uint64(r.Int63n(100)+100) + next.StakingCap = 0 + } else { + lastStakingCap := parser.FindLastStakingCap(versions[:i]) + next.StakingCap = lastStakingCap + uint64(r.Int63n(1000000000)+1) + } + + versions = append(versions, next) + } + + return &parser.GlobalParams{ + Versions: versions, + } +} + +// PROPERTY: Every valid global params should be parsed successfully +func FuzzParseValidParams(f *testing.F) { + addRandomSeedsToFuzzer(f, 10) + f.Fuzz(func(t *testing.T, seed int64) { + r := rand.New(rand.NewSource(seed)) + numVersions := uint32(r.Int63n(50) + 10) + globalParams := genValidGlobalParam(t, r, numVersions) + parsedParams, err := parser.ParseGlobalParams(globalParams) + require.NoError(t, err) + require.NotNil(t, parsedParams) + require.Len(t, parsedParams.Versions, int(numVersions)) + for i, p := range parsedParams.Versions { + require.Equal(t, globalParams.Versions[i].Version, p.Version) + require.Equal(t, globalParams.Versions[i].ActivationHeight, p.ActivationHeight) + require.Equal(t, globalParams.Versions[i].StakingCap, uint64(p.StakingCap)) + require.Equal(t, globalParams.Versions[i].CapHeight, p.CapHeight) + require.Equal(t, globalParams.Versions[i].Tag, hex.EncodeToString(p.Tag)) + require.Equal(t, globalParams.Versions[i].CovenantQuorum, uint64(p.CovenantQuorum)) + require.Equal(t, globalParams.Versions[i].UnbondingTime, uint64(p.UnbondingTime)) + require.Equal(t, globalParams.Versions[i].UnbondingFee, uint64(p.UnbondingFee)) + require.Equal(t, globalParams.Versions[i].MaxStakingAmount, uint64(p.MaxStakingAmount)) + require.Equal(t, globalParams.Versions[i].MinStakingAmount, uint64(p.MinStakingAmount)) + require.Equal(t, globalParams.Versions[i].MaxStakingTime, uint64(p.MaxStakingTime)) + require.Equal(t, globalParams.Versions[i].MinStakingTime, uint64(p.MinStakingTime)) + require.Equal(t, globalParams.Versions[i].ConfirmationDepth, uint64(p.ConfirmationDepth)) + } + }) +} + +func FuzzRetrievingParametersByHeight(f *testing.F) { + addRandomSeedsToFuzzer(f, 10) + f.Fuzz(func(t *testing.T, seed int64) { + r := rand.New(rand.NewSource(seed)) + numVersions := uint32(r.Int63n(50) + 10) + globalParams := genValidGlobalParam(t, r, numVersions) + parsedParams, err := parser.ParseGlobalParams(globalParams) + require.NoError(t, err) + numOfParams := len(parsedParams.Versions) + randParameterIndex := r.Intn(numOfParams) + randVersionedParams := parsedParams.Versions[randParameterIndex] + + // If we are querying exactly by one of the activation height, we should always + // retrieve original parameters + + params := parsedParams.GetVersionedGlobalParamsByHeight(randVersionedParams.ActivationHeight) + require.NotNil(t, params) + + require.Equal(t, randVersionedParams.StakingCap, params.StakingCap) + require.Equal(t, randVersionedParams.CapHeight, params.CapHeight) + require.Equal(t, randVersionedParams.Version, params.Version) + require.Equal(t, randVersionedParams.ActivationHeight, params.ActivationHeight) + require.Equal(t, randVersionedParams.CovenantQuorum, params.CovenantQuorum) + require.Equal(t, randVersionedParams.CovenantPks, params.CovenantPks) + require.Equal(t, randVersionedParams.Tag, params.Tag) + require.Equal(t, randVersionedParams.UnbondingTime, params.UnbondingTime) + require.Equal(t, randVersionedParams.UnbondingFee, params.UnbondingFee) + require.Equal(t, randVersionedParams.MaxStakingAmount, params.MaxStakingAmount) + require.Equal(t, randVersionedParams.MinStakingAmount, params.MinStakingAmount) + require.Equal(t, randVersionedParams.MaxStakingTime, params.MaxStakingTime) + require.Equal(t, randVersionedParams.MinStakingTime, params.MinStakingTime) + require.Equal(t, randVersionedParams.ConfirmationDepth, params.ConfirmationDepth) + + if randParameterIndex > 0 { + // If we are querying by a height that is one before the activations height + // of the randomly chosen parameter, we should retrieve previous parameters version + params := parsedParams.GetVersionedGlobalParamsByHeight(randVersionedParams.ActivationHeight - 1) + require.NotNil(t, params) + paramsBeforeRand := parsedParams.Versions[randParameterIndex-1] + require.Equal(t, paramsBeforeRand.StakingCap, params.StakingCap) + require.Equal(t, paramsBeforeRand.CapHeight, params.CapHeight) + require.Equal(t, paramsBeforeRand.Version, params.Version) + require.Equal(t, paramsBeforeRand.ActivationHeight, params.ActivationHeight) + require.Equal(t, paramsBeforeRand.CovenantQuorum, params.CovenantQuorum) + require.Equal(t, paramsBeforeRand.CovenantPks, params.CovenantPks) + require.Equal(t, paramsBeforeRand.Tag, params.Tag) + require.Equal(t, paramsBeforeRand.UnbondingTime, params.UnbondingTime) + require.Equal(t, paramsBeforeRand.UnbondingFee, params.UnbondingFee) + require.Equal(t, paramsBeforeRand.MaxStakingAmount, params.MaxStakingAmount) + require.Equal(t, paramsBeforeRand.MinStakingAmount, params.MinStakingAmount) + require.Equal(t, paramsBeforeRand.MaxStakingTime, params.MaxStakingTime) + require.Equal(t, paramsBeforeRand.MinStakingTime, params.MinStakingTime) + require.Equal(t, paramsBeforeRand.ConfirmationDepth, params.ConfirmationDepth) + } + }) +} + +func TestReadBbnTest4Params(t *testing.T) { + // Test checking whether the global params which is used on testnet currently + // is parsed correctly + globalParams, err := parser.NewParsedGlobalParamsFromFile("../../bbn-test-4/parameters/global-params.json") + require.NoError(t, err) + require.NotNil(t, globalParams) +} + +var defaultParam = parser.VersionedGlobalParams{ + Version: 0, + ActivationHeight: 100, + StakingCap: 400000, + Tag: "01020304", + CovenantPks: []string{ + "03ffeaec52a9b407b355ef6967a7ffc15fd6c3fe07de2844d61550475e7a5233e5", + "03a5c60c2188e833d39d0fa798ab3f69aa12ed3dd2f3bad659effa252782de3c31", + "0359d3532148a597a2d05c0395bf5f7176044b1cd312f37701a9b4d0aad70bc5a4", + "0357349e985e742d5131e1e2b227b5170f6350ac2e2feb72254fcc25b3cee21a18", + "03c8ccb03c379e452f10c81232b41a1ca8b63d0baf8387e57d302c987e5abb8527", + }, + CovenantQuorum: 3, + UnbondingTime: 1000, + UnbondingFee: 1000, + MaxStakingAmount: 300000, + MinStakingAmount: 3000, + MaxStakingTime: 10000, + MinStakingTime: 100, + ConfirmationDepth: 10, +} + +func TestFailGlobalParamsValidation(t *testing.T) { + var clonedParams parser.GlobalParams + defaultGlobalParams := parser.GlobalParams{ + Versions: []*parser.VersionedGlobalParams{&defaultParam}, + } + // Empty versions + jsonData := []byte(`{ + "versions": [ + ] + }`) + fileName := createJsonFile(t, jsonData) + // Call NewGlobalParams with the path to the temporary file + _, err := parser.NewParsedGlobalParamsFromFile(fileName) + assert.Equal(t, "global params must have at least one version", err.Error()) + + // invalid tag length + deepCopy(&defaultGlobalParams, &clonedParams) + clonedParams.Versions[0].Tag = "010203" + + invalidTagJsonData, err := json.Marshal(clonedParams) + assert.NoError(t, err, "marshalling invalid tag data should not fail") + fileName = createJsonFile(t, invalidTagJsonData) + _, err = parser.NewParsedGlobalParamsFromFile(fileName) + assert.Equal(t, "invalid params with version 0: invalid tag length, expected 4, got 3", err.Error()) + + // test covenant pks sizes + var invalidCovenantPksParam parser.GlobalParams + deepCopy(&defaultGlobalParams, &invalidCovenantPksParam) + invalidCovenantPksParam.Versions[0].CovenantPks = []string{} + + invalidJson, err := json.Marshal(invalidCovenantPksParam) + assert.NoError(t, err, "marshalling invalid covenant pks data should not fail") + + fileName = createJsonFile(t, invalidJson) + _, err = parser.NewParsedGlobalParamsFromFile(fileName) + assert.Equal(t, "invalid params with version 0: empty covenant public keys", err.Error()) + + // test covenant quorum + deepCopy(&defaultGlobalParams, &clonedParams) + clonedParams.Versions[0].CovenantQuorum = 6 + + invalidJson, err = json.Marshal(clonedParams) + assert.NoError(t, err, "marshalling invalid covenant pks data should not fail") + + fileName = createJsonFile(t, invalidJson) + _, err = parser.NewParsedGlobalParamsFromFile(fileName) + assert.Equal(t, "invalid params with version 0: covenant quorum 6 cannot be more than the amount of covenants 5", err.Error()) + + // test invalid convenant pks + deepCopy(&defaultGlobalParams, &clonedParams) + clonedParams.Versions[0].CovenantPks = []string{ + "04ffeaec52a9b407b355ef6967a7ffc15fd6c3fe07de2844d61550475e7a5233e5", + "03a5c60c2188e833d39d0fa798ab3f69aa12ed3dd2f3bad659effa252782de3c31", + "0359d3532148a597a2d05c0395bf5f7176044b1cd312f37701a9b4d0aad70bc5a4", + "0357349e985e742d5131e1e2b227b5170f6350ac2e2feb72254fcc25b3cee21a18", + "03c8ccb03c379e452f10c81232b41a1ca8b63d0baf8387e57d302c987e5abb8527", + "03c8ccb03c379e452f10c81232b41a1ca8b63d0baf8387e57d302c987e5abb8527", + } + + jsonData, err = json.Marshal(clonedParams) + assert.NoError(t, err, "marshalling invalid covenant pks data should not fail") + + fileName = createJsonFile(t, jsonData) + _, err = parser.NewParsedGlobalParamsFromFile(fileName) + assert.Contains(t, err.Error(), "invalid covenant public key") + + // test invalid min and max staking amount + deepCopy(&defaultGlobalParams, &clonedParams) + clonedParams.Versions[0].MaxStakingAmount = 300 + clonedParams.Versions[0].MinStakingAmount = 400 + + jsonData, err = json.Marshal(clonedParams) + assert.NoError(t, err, "marshalling invalid staking amount data should not fail") + + fileName = createJsonFile(t, jsonData) + _, err = parser.NewParsedGlobalParamsFromFile(fileName) + assert.Equal(t, "invalid params with version 0: max-staking-amount 300 must be larger than or equal to min-staking-amount 400", err.Error()) + + // test activation height + deepCopy(&defaultGlobalParams, &clonedParams) + clonedParams.Versions[0].ActivationHeight = 0 + + jsonData, err = json.Marshal(clonedParams) + assert.NoError(t, err) + + fileName = createJsonFile(t, jsonData) + _, err = parser.NewParsedGlobalParamsFromFile(fileName) + assert.Equal(t, "invalid params with version 0: activation_height: value must be positive", err.Error()) + + // test staking cap + deepCopy(&defaultGlobalParams, &clonedParams) + clonedParams.Versions[0].StakingCap = 0 + + jsonData, err = json.Marshal(clonedParams) + assert.NoError(t, err) + + fileName = createJsonFile(t, jsonData) + _, err = parser.NewParsedGlobalParamsFromFile(fileName) + assert.Equal(t, "invalid params with version 0: invalid cap: either of staking cap and cap height must be set", err.Error()) + + // test confirmation depth + deepCopy(&defaultGlobalParams, &clonedParams) + clonedParams.Versions[0].ConfirmationDepth = 0 + + jsonData, err = json.Marshal(clonedParams) + assert.NoError(t, err) + + fileName = createJsonFile(t, jsonData) + _, err = parser.NewParsedGlobalParamsFromFile(fileName) + assert.Equal(t, "invalid params with version 0: invalid confirmation_depth: confirmation depth value should be at least 2, got 0", err.Error()) +} + +func TestGlobalParamsSortedByActivationHeight(t *testing.T) { + r := rand.New(rand.NewSource(time.Now().Unix())) + params := generateGlobalParams(r, 10) + // We pick a random one and set its activation height to be less than its previous one + params[5].ActivationHeight = params[4].ActivationHeight - 1 + + globalParams := parser.GlobalParams{ + Versions: params, + } + + jsonData, err := json.Marshal(globalParams) + assert.NoError(t, err) + fileName := createJsonFile(t, jsonData) + _, err = parser.NewParsedGlobalParamsFromFile(fileName) + assert.Equal(t, "invalid params with version 5. activation height cannot be overlapping between earlier and later versions", err.Error()) +} + +func TestGlobalParamsWithIncrementalVersions(t *testing.T) { + r := rand.New(rand.NewSource(time.Now().Unix())) + params := generateGlobalParams(r, 10) + // We pick a random one and set its activation height to be less than its previous one + params[5].Version = params[4].Version - 1 + + globalParams := parser.GlobalParams{ + Versions: params, + } + + jsonData, err := json.Marshal(globalParams) + assert.NoError(t, err) + + fileName := createJsonFile(t, jsonData) + _, err = parser.NewParsedGlobalParamsFromFile(fileName) + + assert.Equal(t, "invalid params with version 3. versions should be monotonically increasing by 1", err.Error()) +} + +func TestGlobalParamsWithIncrementalStakingCap(t *testing.T) { + r := rand.New(rand.NewSource(time.Now().Unix())) + params := generateGlobalParams(r, 10) + // We pick a random one and set its activation height to be less than its previous one + params[5].StakingCap = params[4].StakingCap - 1 + + globalParams := parser.GlobalParams{ + Versions: params, + } + + jsonData, err := json.Marshal(globalParams) + assert.NoError(t, err) + + fileName := createJsonFile(t, jsonData) + _, err = parser.NewParsedGlobalParamsFromFile(fileName) + assert.True(t, strings.Contains(err.Error(), "invalid params with version 5. staking cap cannot be decreased in later versions")) +} + +func TestGlobalParamsWithSmallStakingCap(t *testing.T) { + r := rand.New(rand.NewSource(time.Now().Unix())) + params := generateGlobalParams(r, 10) + // We pick a random one and set its activation height to be less than its previous one + params[5].StakingCap = params[5].MaxStakingAmount - 1 + + globalParams := parser.GlobalParams{ + Versions: params, + } + + jsonData, err := json.Marshal(globalParams) + assert.NoError(t, err) + + fileName := createJsonFile(t, jsonData) + _, err = parser.NewParsedGlobalParamsFromFile(fileName) + assert.Equal(t, fmt.Sprintf("invalid params with version 5: invalid staking_cap, should be larger than max_staking_amount: %d, got: %d", + params[5].MaxStakingAmount, params[5].StakingCap), err.Error()) +} + +func TestGlobalParamsWithCapBothSet(t *testing.T) { + r := rand.New(rand.NewSource(time.Now().Unix())) + params := generateGlobalParams(r, 10) + // We pick a random one and set its cap height to be the activation height + params[5].CapHeight = params[5].ActivationHeight + + globalParams := parser.GlobalParams{ + Versions: params, + } + + jsonData, err := json.Marshal(globalParams) + assert.NoError(t, err) + + fileName := createJsonFile(t, jsonData) + _, err = parser.NewParsedGlobalParamsFromFile(fileName) + assert.Equal(t, "invalid params with version 5: invalid cap: only either of staking cap and cap height can be set", err.Error()) +} + +func TestGlobalParamsWithUnbondingFee(t *testing.T) { + r := rand.New(rand.NewSource(time.Now().Unix())) + params := generateGlobalParams(r, 10) + // We pick a random one and set its min_staking_amount less than unbonding_fee + params[5].MinStakingAmount = uint64(r.Int63n(int64(params[5].UnbondingFee) + int64(parser.MinUnbondingOutputValue))) + + globalParams := parser.GlobalParams{ + Versions: params, + } + + jsonData, err := json.Marshal(globalParams) + assert.NoError(t, err) + + fileName := createJsonFile(t, jsonData) + _, err = parser.NewParsedGlobalParamsFromFile(fileName) + assert.Equal(t, fmt.Sprintf("invalid params with version 5: min_staking_amount %d should not be less than unbonding fee %d plus %d", + params[5].MinStakingAmount, params[5].UnbondingFee, parser.MinUnbondingOutputValue), err.Error()) +} + +func generateGlobalParams(r *rand.Rand, numOfParams int) []*parser.VersionedGlobalParams { + var params []*parser.VersionedGlobalParams + + lastParam := defaultParam + for i := 0; i < numOfParams; i++ { + var param parser.VersionedGlobalParams + deepCopy(&defaultParam, ¶m) + param.ActivationHeight = lastParam.ActivationHeight + uint64(r.Intn(100)) + param.Version = uint64(i) + param.StakingCap = lastParam.StakingCap + uint64(r.Intn(100)) + params = append(params, ¶m) + lastParam = param + } + + return params +} + +func deepCopy(src, dst interface{}) error { + // Marshal the source object to JSON. + data, err := json.Marshal(src) + if err != nil { + return err + } + + // Unmarshal the JSON data into the destination object. + if err := json.Unmarshal(data, dst); err != nil { + return err + } + + return nil +} + +func createJsonFile(t *testing.T, jsonData []byte) string { + tempFile, err := os.CreateTemp("", "params-test-*") + require.NoError(t, err) + defer tempFile.Close() + _, err = tempFile.Write(jsonData) + require.NoError(t, err) + t.Cleanup(func() { + os.Remove(tempFile.Name()) + }) + return tempFile.Name() +}