## mote

*posted on 10 Oct 2020*

A `mote`

is a quantity of gold, used as a unit of value.
The amount of gold that one mote represents varies over time: it decays by 2% each year, compounded on a per-second basis.
The “initial” value was 1.0 grams of gold on the first second of the year 2000.

More precisely:

```
1 mote = (0.98 ^ ((t - t0) / y)) grams of gold
where
t0 = 946684800 (UTC timestamp of y2k)
y = 31557600 (seconds in one year)
t = current UTC timestamp
```

## glifics

*posted on 2 Feb 2020*

Mr Land’s essay TX2 hints at an approach towards a new gematria that leaves behind problems with the base-ten numerology.

...## possibly-unspent

*posted on 25 Jan 2020*

Let’s examine the modal logic of thin client proofs in Bitcoin and in Ethereum.

...## the shape of mana

*posted on 7 Jan 2020*

This post gives a visual description of the UTXO architecture described in post which introduced manaflow. An important characteristic of the extra functionality is that it does not change the asymptotic validation complexity of a UTXO system - it is the same as Bitcoin.

...## pollywogs live in treaps

*posted on 31 Dec 2019*

This post is part of a series on how to achieve sublinear-span chain validation for UTXO systems. It is a follow-up to the post on RTXI.

...## damage

*posted on 13 Dec 2019*

```
ipfs add damage
added QmXHcLHi37rUHJKFuLHdfhSKNDKDxJPp9BFiNEN86qUr6G damage
```

## shardlets

*posted on 9 Dec 2019*

A manaflow transaction is a shardlet.

A shardlet locks exactly the state it needs to continue execution, for exactly as long as it needs it. Shardlets can be validated concurrently and all of their resources are statically declared so they can be scheduled optimally. A beacon shard is an emergent phenomenon that comes from application logic.

...## minibang

*posted on 5 Dec 2019*

The primordial miniflow action is the unique well-formed action which consumes its own output and emits (0,0).

```
Block 0 has 1 action:
Action 0 has 1 input and creates 2 spendable outputs (out of 3 total outputs):
* Input 0 consumes output 0 of 0th action itself.
- Output 0 emits emits (0,0), which is the output consumed by input 0.
+ Output 1 emits (0,1)
+ Output 2 emits [1-2^256-1].
```

## double-life fee

*posted on 3 Dec 2019*

Double-life fee is a simple model for state rent.

If the chain started at time `t0`

, then an new object (a UTXO or whatever it may be) which is confirmed at time `t0 + t`

expires and can be garbage collected at time `t0 + 2*t`

.

When an object becomes eligible for garbage collection, that means it has existed for more than half the age of the chain.

...## pixelfight!

*posted on 1 Dec 2019*

Pixelfight is a multiplayer minigame and collaborative art piece.

- There are 16 colors
- There is a 1024x1024 pixel arena (1 megapixel)
- A pigment is a colored particle that interacts with a pixel
- 1 pigment costs 1 satoshi, paid to a special
`OP_TRUE OP_RETURN`

output

## CSW Oracles

*posted on 28 Nov 2019*

CSW is right that Bitcoin is designed for big blocks in data centers.

The real reason is that Bitcoin’s transactions are logically sequential but validate in logarithmic parallel time.

Soon we will learn team Ethereum was wrong for giving up on UTXO.

...## nullary diagrams

*posted on 27 Nov 2019*

Nullary expressions can be represented with two dimensional diagrams. The 2d syntax corresponding to a set of matching parenthesis is simply a circle containing the diagram of the sub-expression.

Below is a table with some example diagrams of basic nullary expressions.

...## manaflow

*posted on 26 Nov 2019*

Manaflow is a transaction architecture and processing engine that validates in logarithmic parallel time like Bitcoin while enabling user-defined, consensus-validated state transitions like Ethereum.

This applies to batches of transactions, an entire block, or even the entire chain.

...## RTXI is the dual of UTXO

*posted on 25 Nov 2019*

A UTXO system like Bitcoin has the property that transactions are logically sequential but can be validated in polylog-span. This is why Bitcoin is scalable.

To understand the log-time parallel algorithm, it helps to understand how to validate a chain in reverse.

RTXI means Required Transaction Input. The RTXI set is matched against UTXO from “incoming” transactions in reverse order.

...## glifbits

*posted on 24 Nov 2019*

(*This post is a retro-summary of 4 posts made from 2019-11-24 to 2020-02-01. You can see the precise history in this website’s repository. Latest revision: 2020-02-02*)

The glifs are a character set which have a handwritten form (meant for fast writing), a canonical pixel-character form (a sort of runic font), and a dedicated keyboard key (with corresponding ASCII character).

...## UTXO vs global state

*posted on 20 Nov 2019*

EVM and Bitcoin Script are equally expressive if speaking strictly of which pure functions they can compute. The important way in which the two programming environments are different is unrelated to turing completeness, which has outlived its allowance as a layman’s catch-all for “programmable”.

...## fixed-point hash

*posted on 19 Nov 2019*

Suppose these requirements are given for a cryptographic hash function:

```
1) x != y -> hash(x) != hash(y) (with high probability)
2) hash(x) != hash(y) -> x != y (with high probability)
3) It is intractable to discover x given only hash(x)
```

None of them prohibit the existince of a fixed point:

```
Not a rule: hash(x) != x
```

## base32cx

*posted on 13 Nov 2019*

`base32cx`

is a base-32 encoding with letter-case checksums inspired by Ethereum’s EIP55.

It is designed for encoding short byte string identifiers as human-skimmable strings, with use cases like file hashes or cryptocurrency addresses in mind.

The alphabet maximizes the number of alpha characters to increase the average number of checksum bits per string.

...## rarity

*posted on 13 Nov 2019*

The rarity of an event is the number of coin flips you need to make an all-heads result as rare as that event.

Rarity is just a new term for (binary) “self-information” or “surprisal”, which is the logarithm of the inverse of the probability of an event.

Rarity uses log2 instead of the natural log because it is intended to be accessible to programmers for back-of-envelope calculations.

...## dynamic pow

*posted on 12 Nov 2019*

Proof-of-work consensus works without a target inter-block time, difficulty, or even a timestamp.

This is called ‘continuous’ or ‘dynamic’ POW.

...## minch

*posted on 12 Nov 2019*

A minch, or metric inch, is 2.5 centimeters. That’s 127/125 minches per imperial inch.

An imperial foot is 12 inches. A metric foot is 12 minches. That’s 30 centimeters.

An imperial yard is 36 inches. A metric yard is 36 minches. That’s 90 centimeters.

...## UPDB

*posted on 11 Nov 2019*

UPDB is a universally unique authenticated key/value store.

UPDB aims to be a base PKI, object ID, and namespacing layer for the next wave of web protocols.

It can be used for:

- assigning numbers to things
- assigning things to symbols
- building signed directed graphs

## nullary

*posted on 11 Nov 2019*

Nullary is a base-less numeric encoding. Unlike unary, which requires `O(n)`

symbols to encode the number `n`

, nullary encoding still requires just `O(log(n))`

symbols.

Nullary is the foundation of real numerology.

...## backdate

*posted on 11 Nov 2019*

```
cat 2017-05-27--read-clip.txt | shasum -a 256
cat 2017-06-24--establishment.txt | shasum -a 256
cat 2019-03-17--write-clip.txt | shasum -a 256
cat 2019-09-29--2019-10-14--pleroma.txt | shasum -a 256
37877f08e9d237691b3e62c90064fe435944265045b09e00c24ca4dc00700cca -
798b0fa28dccc883f511d36c4d3eb9b98d7e7667348814f69d65a5591cff7881 -
bbb464a9804ce0caa2c344ec7c98c70c69722113cda2393779fbc7f0cc116673 -
0e5e88b1a56a6aabf935e88cffcd2a51104463df7f6c67ab80dce0a9e3b021fb -
```