Barebones documentation for math types

src/lib/_decimals.js

@@ -0,0 +1,18 @@
+function prepareName(isSigned, bits) {
+  let name = "Decimal";
+  if (bits != "128") {
+    name += bits;
+  }
+
+  if (isSigned) {
+    name = `Signed${name}`;
+  }
+
+  return name;
+}
+
+function prepareLink(isSigned, bits) {
+  return `https://docs.rs/cosmwasm-std/latest/cosmwasm_std/struct.${prepareName(isSigned, bits)}.html`;
+}
+
+export { prepareName, prepareLink };

src/pages/core/standard-library/math.mdx

@@ -1,7 +1,11 @@
 ---
-tags: ["core"]
+tags: ["core", "math"]
 ---
 
 import { Callout } from "nextra/components";
 
 # Math
+
+CosmWasm offers mathematical primitives for, you guessed it, mathematical
+operations. In contrast to the Rust standard library, which is limited to 128
+bit integers, we offer integers that exceed that precision.

src/pages/core/standard-library/math/_meta.json

@@ -0,0 +1,4 @@
+{
+  "decimals": "Decimals",
+  "integers": "Integers"
+}

src/pages/core/standard-library/math/decimals.mdx

@@ -0,0 +1,67 @@
+---
+tags: ["core", "math"]
+---
+
+import { Callout } from "nextra/components";
+
+# Decimals
+
+CosmWasm offers decimal types for handling fractional numbers.
+
+In contrast to floating point numbers, these datatypes do not suffer from the
+same precision issues. This means that these decimal types are safe for use in
+financial calculations.
+
+Instead of storing numbers in the floating point format, which gives it a
+_floating_ amount of decimal places, these decimal types have a fixed precision
+of 18 decimal places.
+
+<Callout>
+    Note that, due to how the decimal types are structured, the value ranges can seem a little weird.
+
+    For example, 1.0 is represented by `Decimal(1_000_000_000_000_000_000)` and the maximal value of the 128 bit variant is `340282366920938463463.374607431768211455` (which is `(2^128 - 1) / 10^18`)
+
+    In practice, you don't really have to think about it, but it's something you should be aware of.
+
+</Callout>
+
+Decimal types come in the following variants:
+
+import { prepareName, prepareLink } from "@/lib/_decimals";
+
+{ // Beware: Overengineering ahead!
+
+    <table>
+        <thead>
+            <tr>
+                <th></th>
+                <th>Unsigned</th>
+                <th>Signed</th>
+            </tr>
+        </thead>
+        <tbody>
+            {
+
+                [ '128', '256' ]
+                    .map(item => (
+                        <tr key={item}>
+                            <td>{item} bit</td>
+                            <td>
+                                <a href={prepareLink(false, item)}>
+                                    <code>{prepareName(false, item)}</code>
+                                </a>
+                            </td>
+                            <td>
+                                <a href={prepareLink(true, item)}>
+                                    <code>{prepareName(true, item)}</code>
+                                </a>
+                            </td>
+                        </tr>
+                    ))
+            }
+        </tbody>
+    </table>
+
+}
+
+Choose one of the types according to your needs and off you go!

src/pages/core/standard-library/math/integers.mdx

@@ -0,0 +1,65 @@
+---
+tags: ["core", "math"]
+---
+
+import { Callout } from "nextra/components";
+
+# Integers
+
+CosmWasm offers integer types starting at 64 bit precision, all the way up to
+512 bits.
+
+Reasoning behind wrapping the primitive 64 bit type is the interaction with, for
+example, JavaScript (same goes for parsers like `jq` or any parser that parses
+numbers into double precision floats). A `u64` would normally serialize into a
+regular integer field in JSON. The issue here is that, due to representing
+integers in form of double precision floats, JavaScript can only handle up to
+~53 bit numbers without potentially losing information.
+
+<Callout>
+  There is nothing wrong with using the primitive 64- and 128-bit types in your
+  contract for calculations. The issues mentioned here can only happen when you
+  de-/serialize these values.
+</Callout>
+
+Our wrapper fixes this by serializing numbers as strings, letting JavaScript
+clients deserialize these numbers into their respective BigInteger types.
+
+The other integer types, which reach even higher amounts of precision, are
+serialized in the same way.
+
+Integers come in the following variants:
+
+{ // Beware: Overengineering ahead!
+
+    <table>
+        <thead>
+            <tr>
+                <th></th>
+                <th>Unsigned</th>
+                <th>Signed</th>
+            </tr>
+        </thead>
+        <tbody>
+            {
+                [ '64', '128', '256', '512' ]
+                    .map(item => (
+                        <tr key={item}>
+                            <td>{item} bit</td>
+                            <td>
+                                <a href={`https://docs.rs/cosmwasm-std/latest/cosmwasm_std/struct.Uint${item}.html`}>
+                                    <code>Uint{item}</code>
+                                </a>
+                            </td>
+                            <td>
+                                <a href={`https://docs.rs/cosmwasm-std/latest/cosmwasm_std/struct.Int${item}.html`}>
+                                    <code>Int{item}</code>
+                                </a>
+                            </td>
+                        </tr>
+                    ))
+            }
+        </tbody>
+    </table>
+
+}