diff --git a/build/version.go b/build/version.go
index d3beca8a0..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.rc3"
+	AppPreRelease = "beta"
 )
 
 func init() {
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)
+}
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)