From 1b6f42a1076b5ea3568b83c456f0d78af48629c3 Mon Sep 17 00:00:00 2001 From: Olaoluwa Osuntokun Date: Tue, 28 May 2024 10:46:15 +0900 Subject: [PATCH 1/4] build: bump version to v0.18.0-beta.rc4 --- build/version.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build/version.go b/build/version.go index d3beca8a0..aa9cc1d4d 100644 --- a/build/version.go +++ b/build/version.go @@ -47,7 +47,7 @@ const ( // AppPreRelease MUST only contain characters from semanticAlphabet per // the semantic versioning spec. - AppPreRelease = "beta.rc3" + AppPreRelease = "beta.rc4" ) func init() { From fce2ef15a5fcf6545c7ba6b1d88dba658fc4273d Mon Sep 17 00:00:00 2001 From: Keagan McClelland Date: Tue, 28 May 2024 17:29:36 -0700 Subject: [PATCH 2/4] scripts: add gpg key for proofofkeags [skip ci] --- scripts/keys/proofofkeags.asc | 14 ++++++++++++++ scripts/verify-install.sh | 1 + 2 files changed, 15 insertions(+) create mode 100644 scripts/keys/proofofkeags.asc diff --git a/scripts/keys/proofofkeags.asc b/scripts/keys/proofofkeags.asc new file mode 100644 index 000000000..23dee01d8 --- /dev/null +++ b/scripts/keys/proofofkeags.asc @@ -0,0 +1,14 @@ +-----BEGIN PGP PUBLIC KEY BLOCK----- + +mDMEZlZ1MRYJKwYBBAHaRw8BAQdAZsa54hBDrjAnuj56IGJYcIszHvasEPFVvcO9 +3WBUS3q0L0tlYWdhbiBNY0NsZWxsYW5kIDxrZWFnYW4ubWNjbGVsbGFuZEBnbWFp +bC5jb20+iJkEExYKAEEWIQRSlaR3/8gGTXBXsZH6fmXJUfEkOQUCZlZ1MQIbAwUJ +BaOagAULCQgHAgIiAgYVCgkICwIEFgIDAQIeBwIXgAAKCRD6fmXJUfEkOU1fAQDW +wdx8AF8QdITRvY299R6Y9348N4EIa9mq6bYeh+d0HwD7BPEkKquPNncuUmqJ8EAe +uGOQX0xs+0YyynMIHulnnQi4OARmVnUxEgorBgEEAZdVAQUBAQdAOvF6kho3KmjN +OQQX/bxng+Tgy4hz34BJojWJdSpn/gYDAQgHiH4EGBYKACYWIQRSlaR3/8gGTXBX +sZH6fmXJUfEkOQUCZlZ1MQIbDAUJBaOagAAKCRD6fmXJUfEkOaVeAP4rJD+kvC0D +jffwmx9w0L6Grb4KPX1FTm7UBq7JSZExHgEAn27BOcf4lDoRZRa27K6jjTNd96Nk +2MU5hr1pnbZNfQQ= +=3tMW +-----END PGP PUBLIC KEY BLOCK----- diff --git a/scripts/verify-install.sh b/scripts/verify-install.sh index 0df73d00a..bef2f0310 100755 --- a/scripts/verify-install.sh +++ b/scripts/verify-install.sh @@ -33,6 +33,7 @@ KEYS+=("4DC235556B18694E08518DBB671103D881A5F0E4 sputn1ck") KEYS+=("187F6ADD93AE3B0CF335AA6AB984570980684DCC ViktorTigerstrom") KEYS+=("E85497D2DBA0EB9ADB0024279BCD95C4FF296868 yyforyongyu") KEYS+=("32F7EA1E7A0339F7D37164B9F82D456EA023C9BF hieblmi") +KEYS+=("5295A477FFC8064D7057B191FA7E65C951F12439 proofofkeags") TEMP_DIR=$(mktemp -d /tmp/lnd-sig-verification-XXXXXX) From c95505db1ebd7e6fbcf2f35235a6afa19fa4333c Mon Sep 17 00:00:00 2001 From: Oliver Gugger Date: Wed, 29 May 2024 09:36:36 +0200 Subject: [PATCH 3/4] fn: add Result type In this commit, we add a new result type, which is just Either[A, error]. This is useful as we can always pass around/accept a single value. We add an Unpack() method which is the most idiomatic way of handling errors in Go, as we revert back to (A, error) when necessary. --- fn/result.go | 142 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 142 insertions(+) create mode 100644 fn/result.go diff --git a/fn/result.go b/fn/result.go new file mode 100644 index 000000000..11d2d82a4 --- /dev/null +++ b/fn/result.go @@ -0,0 +1,142 @@ +package fn + +import ( + "fmt" + "testing" +) + +// Result represents a value that can either be a success (T) or an error. +type Result[T any] struct { + Either[T, error] +} + +// Ok creates a new Result with a success value. +func Ok[T any](val T) Result[T] { + return Result[T]{Either: NewLeft[T, error](val)} +} + +// Err creates a new Result with an error. +func Err[T any](err error) Result[T] { + return Result[T]{Either: NewRight[T, error](err)} +} + +// Errf creates a new Result with a new formatted error string. +func Errf[T any](errString string, args ...any) Result[T] { + return Result[T]{ + Either: NewRight[T, error](fmt.Errorf(errString, args...)), + } +} + +// Unpack extracts the value or error from the Result. +func (r Result[T]) Unpack() (T, error) { + var zero T + return r.left.UnwrapOr(zero), r.right.UnwrapOr(nil) +} + +// IsOk returns true if the Result is a success value. +func (r Result[T]) IsOk() bool { + return r.IsLeft() +} + +// IsErr returns true if the Result is an error. +func (r Result[T]) IsErr() bool { + return r.IsRight() +} + +// Map applies a function to the success value if it exists. +func (r Result[T]) Map(f func(T) T) Result[T] { + if r.IsOk() { + return Ok(f(r.left.some)) + } + + return r +} + +// MapErr applies a function to the error value if it exists. +func (r Result[T]) MapErr(f func(error) error) Result[T] { + if r.IsErr() { + return Err[T](f(r.right.some)) + } + + return r +} + +// Option returns the success value as an Option. +func (r Result[T]) Option() Option[T] { + return r.left +} + +// WhenResult executes the given function if the Result is a success. +func (r Result[T]) WhenResult(f func(T)) { + r.left.WhenSome(func(t T) { + f(t) + }) +} + +// WhenErr executes the given function if the Result is an error. +func (r Result[T]) WhenErr(f func(error)) { + r.right.WhenSome(func(e error) { + f(e) + }) +} + +// UnwrapOr returns the success value or a default value if it's an error. +func (r Result[T]) UnwrapOr(defaultValue T) T { + return r.left.UnwrapOr(defaultValue) +} + +// UnwrapOrElse returns the success value or computes a value from a function +// if it's an error. +func (r Result[T]) UnwrapOrElse(f func() T) T { + return r.left.UnwrapOrFunc(f) +} + +// UnwrapOrFail returns the success value or fails the test if it's an error. +func (r Result[T]) UnwrapOrFail(t *testing.T) T { + t.Helper() + + return r.left.UnwrapOrFail(t) +} + +// FlatMap applies a function that returns a Result to the success value if it +// exists. +func (r Result[T]) FlatMap(f func(T) Result[T]) Result[T] { + if r.IsOk() { + return f(r.left.some) + } + return r +} + +// AndThen is an alias for FlatMap. This along with OrElse can be used to +// Railway Oriented Programming (ROP) by chaining successive computational +// operations from a single result type. +func (r Result[T]) AndThen(f func(T) Result[T]) Result[T] { + return r.FlatMap(f) +} + +// OrElse returns the original Result if it is a success, otherwise it returns +// the provided alternative Result. This along with AndThen can be used to +// Railway Oriented Programming (ROP). +func (r Result[T]) OrElse(f func() Result[T]) Result[T] { + if r.IsOk() { + return r + } + + return f() +} + +// FlatMap applies a function that returns a Result[B] to the success value if +// it exists. +func FlatMap[A, B any](r Result[A], f func(A) Result[B]) Result[B] { + if r.IsOk() { + return f(r.left.some) + } + + return Err[B](r.right.some) +} + +// AndThen is an alias for FlatMap. This along with OrElse can be used to +// Railway Oriented Programming (ROP). +func AndThen[A, B any](r Result[A], f func(A) Result[B]) Result[B] { + return FlatMap(r, f) +} From 1a8d19660772d34597a84ae1110c28f482a01bc9 Mon Sep 17 00:00:00 2001 From: Olaoluwa Osuntokun Date: Thu, 30 May 2024 17:49:06 +0900 Subject: [PATCH 4/4] build: bump version to v0.18.0 beta --- build/version.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build/version.go b/build/version.go index aa9cc1d4d..46c0a4c15 100644 --- a/build/version.go +++ b/build/version.go @@ -47,7 +47,7 @@ const ( // AppPreRelease MUST only contain characters from semanticAlphabet per // the semantic versioning spec. - AppPreRelease = "beta.rc4" + AppPreRelease = "beta" ) func init() {