nutil

func AddrsToStrings ¶

func AddrsToStrings(addrs ...sdk.AccAddress) []string

func BankersRound ¶

func BankersRound(quo, rem, halfPrecision *big.Int) *big.Int

BankersRound: Banker's rounding is a method commonly used in banking and accounting to reduce roudning bias when processing large volumes of rounded numbers.

1. If the remainder < half precision, round down 2. If the remainder > half precision, round up 3. If remainder == half precision, round to the nearest even number

The name comes from the idea that it provides egalitarian rounding that doesn't consistently favor one party over another (e.g. always rounding up). With this method, rounding errors tend to cancel out rather than accumulating in one direction.

func BigIntPow10 ¶

func BigIntPow10(power int64) *big.Int

BigIntPow10 returns a big int that is a power of 10, e.g. BigIngPow10(3) returns 1000. This function is useful for creating large numbers outside the range of an int64 or 18 decimal precision.

func ChopPrecisionAndRound ¶

func ChopPrecisionAndRound(d *big.Int) *big.Int

ChopPrecisionAndRound: Remove a Precision amount of rightmost digits and perform bankers rounding on the remainder (gaussian rounding) on the digits which have been removed.

Mutates the input. Use the non-mutative version if that is undesired

func Clamp ¶

func Clamp(value sdkmath.LegacyDec, clampValue sdkmath.LegacyDec) sdkmath.LegacyDec

Clamp return the value if it is within the clampValue, otherwise return the clampValue. e.g. Clamp(1.5, 1) = 1, Clamp(-1.5, 1) = -1, Clamp(0.5, 1) = 0.5

func CombineErrors ¶

func CombineErrors(errs ...error) (outErr error)

Combines errors into single error. Error descriptions are ordered the same way they're passed to the function.

func CombineErrorsFromStrings ¶

func CombineErrorsFromStrings(strs ...string) (err error)

func CombineErrorsGeneric ¶

func CombineErrorsGeneric(errAnySlice any) (out error, ok bool)

func MustSqrtBigInt ¶

func MustSqrtBigInt(i *big.Int) *big.Int

MustSqrtBigInt returns the square root of the input.

• NOTE: MustSqrtBigInt panics if it is called on a negative number because it uses the `big.Int.Sqrt` from the "math/big" package.

func MustSqrtDec ¶

func MustSqrtDec(dec sdkmath.LegacyDec) sdkmath.LegacyDec

MustSqrtDec computes the square root of the input decimal using its underlying big.Int. The big.Int.Sqrt method is part of the standard library, thoroughly tested, works at seemingly unbound precision (e.g. for numbers as large as 10**99.

• NOTE, MustSqrtDec panics if it is called on a negative number, similar to the sdk.NewCoin and SqrtBigInt functions. A panic safe version of MustSqrtDec is available in the SqrtDec method.

func ParseNibiBalance ¶

func ParseNibiBalance(wei sdkmath.Int) (amtUnibi, amtWei sdkmath.Int)

ParseNibiBalance splits a NIBI amount in wei into unibi (bank units) and wei remainder. Used by keeper to normalize the dual-balance model at the 10^12 boundary.

• This is the inverse of GetWeiBalance aggregation: (unibi × 10^12) + wei.
• Example: ParseNibiBalance(2×10^12 + 3) → (2, 3)

### Returns:

• amtUnibi: bank balance in unibi (micro-NIBI; 10^{-6} NIBI)
• amtWei: remainder in wei, where 0 ≤ amtWei < 10^{12}

func ParseNibiBalanceFromParts ¶

func ParseNibiBalanceFromParts(unibi, wei sdkmath.Int) (amtUnibi, amtWei sdkmath.Int)

ParseNibiBalanceFromParts normalizes (unibi, wei) into canonical form. Computes total wei as (unibi × 10^{12}) + wei, then splits into normalized parts.

Returns:

• amtUnibi: normalized unibi (micro-NIBI; 10^-6 NIBI)
• amtWei: normalized remainder, where 0 ≤ amtWei < 10^{12}

Used by keeper to carry/borrow across the 10^{12} boundary, keeping bank and wei-store synchronized.

Example: ParseNibiBalanceFromParts(5, 2×10^{12} + 3) → (7, 3)

func ParsePagination ¶

func ParsePagination(
	pageReq *sdkquery.PageRequest,
) (newPageReq *sdkquery.PageRequest, page int, err error)

ParsePagination: Validates and cleans a PageRequest to make setting values less error-prone and use Nibiru-specific defaults.

1. This fn is intended to be used with sdkquery.Paginate, which paginates all of the results in a PrefixStore based on the provided PageRequest.
2. This fn is panic-safe, so it can be used freely throughout the base app.
3. A "page" value of -1 means that a key is given for the prefix store. This means that the PageRequest.Offset will be ignored.

func SqrtBigInt ¶

func SqrtBigInt(i *big.Int) (*big.Int, error)

SqrtBigInt is the panic-safe version of MustSqrtBigInt

func SqrtDec ¶

func SqrtDec(dec sdkmath.LegacyDec) (sdkmath.LegacyDec, error)

SqrtDec computes the square root of the input decimal using its underlying big.Int. SqrtDec is panic-safe and returns an error if the input decimal is negative.

The big.Int.Sqrt method is part of the standard library, thoroughly tested, works at seemingly unbound precision (e.g. for numbers as large as 10**99.

func StringsToAddrs ¶

func StringsToAddrs(strs ...string) []sdk.AccAddress

func ToError ¶

func ToError(v any) (out error, ok bool)

ToError converts a value to an error type if it: (1) is a string, (2) has a String() function (3) is already an error. (4) or is a slice of these cases I.e., the types supported are: string, []string, error, []error, fmt.Stringer, []fmt.Stringer

The type is inferred from try catch blocks at runtime.

func TryCatch ¶

func TryCatch(callback func()) func() error

TryCatch is an implementation of the try-catch block from languages like C++ and JS. given a 'callback' function, TryCatch defers and recovers from any panics or errors, allowing one to safely handle multiple panics in succession.

Typically, you'll write something like: `err := TryCatch(aRiskyFunction)()`

Usage example:

var calmPanic error = TryCatch(func() {
  panic("something crazy")
})()
fmt.Println(calmPanic.Error()) // prints "something crazy"

Note that TryCatch doesn't return an error. It returns a function that returns an error. Only when you call the output of TryCatch will it "feel" like a try-catch block from other languages.

This means that TryCatch can be used to restart go routines that panic as well.

func U256SafeFromBig ¶

func U256SafeFromBig(x *big.Int) (*uint256.Int, error)

U256SafeFromBig converts a big.Int to uint256.Int, returning an error if x < 0 or x.BitLen() > 256. Nil or zero is treated as zero.

func U256SafeFromSdkInt ¶

func U256SafeFromSdkInt(x sdkmath.Int) (*uint256.Int, error)

U256SafeFromSdkInt converts sdkmath.Int to *uint256.Int safely. Returns for non-positive value or overflow.

func UnsafeBytesToStr ¶

func UnsafeBytesToStr(b []byte) string

UnsafeBytesToStr is meant to make a zero allocation conversion from []byte -> string to speed up operations, it is not meant to be used generally, but for a specific pattern to delete keys from a map. This is from file "cosmos-sdk/internal/conv/string.go".

func UnsafeStrToBytes ¶

func UnsafeStrToBytes(s string) []byte

UnsafeStrToBytes uses unsafe to convert string into byte array. Returned bytes must not be altered after this function is called as it will cause a segmentation fault. This is from file "cosmos-sdk/internal/conv/string.go".

func WeiPerUnibiU256 ¶

func WeiPerUnibiU256() *uint256.Int

WeiPerUnibiU256 is a uint256.Int for 10^{12}. Each "unibi" (micronibi) is 10^{12} wei because 1 NIBI = 10^{18} wei.