Examples.ENock (Anoma v0.34.0)

Summary

Functions

The bex arm for taking bex:anoma from the resource-machine core environment.

The gate representing a by core creation with a specified set.

I represent the cmp gate call as a 2-argument gate.

The counter arm.

A cue arm for taking cue:anoma out of the resource-machine core environment.

The decrement arm in the tests core.

I represent the dif gate call as a 2-argument gate.

I represent a dif gate with a specified instantiated in core given as an extra argument.

I represent the dor gate call.

I am the full dor gate with specified sample and resource-machine context.

I represent the dul gate call as a 2-argument gate.

I represent a duni gate with a specified instantiated in core given as an extra argument.

I am the battery of the fib:tests gate of the anoma stadard library.

I represent the fra gate call as a 2-argument gate.

I represent the gor gate call.

I am the full gor gate with specified sample and resource-machine context.

I represent a got gate with a specified instantiated in core given as an extra argument.

I represent a has gate with a specified instantiated in core given as an extra argument.

The gate representing an in core creation with a specified set.

I represent an int gate with a specified instantiated in core given as an extra argument.

A cue arm for taking jam:anoma out of the resource-machine core environment.

I evaluate lsh at block size 0 and gate-input [2 6].

I evaluate lsh at block size 1 and gate-input [2 6].

I evaluate lsh at block size 1 and gate-input [2 6].

I am an lash arm in the block door.

I represent the lte gate call as a 2-argument gate.

The mat arm for taking mat:anoma from the resource-machine core environment.

I evaluate met at block size 0 and gate-input 28.

I evaluate met at block size 1 and gate-input 28.

I evaluate met at block size 2 and gate-input 28.

I am an lash arm in the block door.

The mix arm for taking mix:anoma from the resource-machine core environment.

I represent the mor gate call.

I am the full mor gate with specified sample and resource-machine context.

I represent a put gate with a specified instantiated in core given as an extra argument.

I represent the mug gate call.

I am the full mug gate with specified sample and resource-machine context.

I represent the new gate call as a 2-argument gate.

The gate representing an og core creation with a specified seed.

I represent the old gate call as a 2-argument gate.

I represent the pro gate call as a 2-argument gate.

I represent a put gate with a specified instantiated in core given as an extra argument.

I represent the rad gate call as a 2-argument gate.

I am function calling the rad gate of the og door with specified seed and range

I represent the rads gate call as a 2-argument gate.

I am function calling the rads gate of the og door with specified seed and range

I represent the raw gate call as a 2-argument gate.

I am function calling the raw gate of the og door with specified seed and bitwidth.

I represent the raws gate call as a 2-argument gate.

I am function calling the raws gate of the og door with specified seed and bitwidth.

I represent a raws gate with a specified instantiated og core given as an extra argument.

I represent the rem gate call as a 2-argument gate.

I evaluate rsh at block size 0 and gate-input [2 40].

I evaluate rsh at block size 1 and gate-input [2 40].

I evaluate rsh at block size 2 and gate-input [2 40].

I am an lash arm in the block door.

The shax arm for taking shax:anoma from the resource-machine core environment.

The sign arm for taking sign:anoma from the resource-machine core environment.

The sign-detatched arm for taking sign-detached:anoma from the resource-machine core environment.

I represent the mor gate call.

I represent a split gate call given an og core with seed.

I represent the sum gate call as a 2-argument gate.

I represent a tap:by call with a specified instantiated in core given as an extra argument.

I represent a tap:in call with a specified instantiated in core given as an extra argument.

I evaluate uend at block size 0 and gate-input [5 80].

I evaluate uend at block size 1 and gate-input [3 80] and [4 80].

I am an lash arm in the block door.

I represent a uni gate with a specified instantiated in core given as an extra argument.

The verify arm for taking verify:anoma from the resource-machine core environment.

The verify-detatched arm for taking verify-detached:anoma from the resource-machine core environment.

I represent a wyt gate with a specified instantiated in core given as an extra argument.

Functions

abs()

@spec abs() :: Noun.t()

abs_arm()

@spec abs_arm() :: Noun.t()

action_create_arm()

action_create_call(created, consumed, appdata)

action_create_test()

action_delta_arm()

action_delta_call(action)

action_delta_test()

bex()

@spec bex() :: Noun.t()

bex_arm()

@spec bex_arm() :: Noun.t()

The bex arm for taking bex:anoma from the resource-machine core environment.

Can be gotten by defining gate locally as:

=localbex => resource-machine |= a=@ (bex a)

and then grabbing the arm of localbex.

by_arm()

@spec by_arm() :: Noun.t()

The gate representing a by core creation with a specified set.

Can be gotten by defining

=l => resource-machine |= a=(set) ~(. by a)

and getting it's arm with [0 2]

by_call(set)

@spec by_call(Noun.t()) :: {:error, Nock.error()} | {:ok, Noun.t()}

call_split_test()

@spec call_split_test() :: any()

cmp()

@spec cmp() :: Noun.t()

cmp_arm()

@spec cmp_arm() :: Noun.t()

I represent the cmp gate call as a 2-argument gate.

Can be obtained by defining

=lcmp => resource-machine |= [a=@s b=@s] (cmp [a b])

and computing

.* lcmp [0 2]

commitment_arm()

commitment_test(n \\ :rand.uniform(10000))

counter_arm()

@spec counter_arm() :: Noun.t()

The counter arm.

Availiable through counter:logics core.

counter_logic()

@spec counter_logic() :: Noun.t()

cue()

@spec cue() :: Noun.t()

cue_arm()

@spec cue_arm() :: Noun.t()

A cue arm for taking cue:anoma out of the resource-machine core environment.

Can be gotten by defining gate locally as

=localcue => resource-machine |= a=@ (cue a)

and then grabbing the arm of localcue.

dec()

@spec dec() :: Noun.t()

dec_arm()

@spec dec_arm() :: Noun.t()

The decrement arm in the tests core.

Availiable through use-dec:tests core.

delta_add_arm()

delta_add_call(delta1, delta2)

delta_add_test()

delta_sub_arm()

delta_sub_call(delta1, delta2)

delta_sub_test()

dif()

@spec dif() :: Noun.t()

dif_arm()

@spec dif_arm() :: Noun.t()

I represent the dif gate call as a 2-argument gate.

Can be obtained by defining

=ldif => resource-machine |= [a=@ b=@] (dif [a b])

and computing

.* ldif [0 2]

dif_test()

dif_with_core()

@spec dif_with_core() :: Noun.t()

I represent a dif gate with a specified instantiated in core given as an extra argument.

Can be gotten by defining locally

=l => resource-machine |= [a=_in b=(set)] (dif:a b)

and grabbing the arm with [0 2]

dif_with_core_call(core, set)

@spec dif_with_core_call(Noun.t(), Noun.t()) ::
  {:error, Nock.error()} | {:ok, Noun.t()}

dor_arm()

@spec dor_arm() :: Noun.t()

I represent the dor gate call.

Can be obtained by defining

=ldor => resource-machine |= [a= b=] (dor a b)

and computing

.* ldor [0 2]

dor_call(a, b)

@spec dor_call(Noun.t(), Noun.t()) :: Noun.t()

I am the full dor gate with specified sample and resource-machine context.

dor_test()

@spec dor_test() :: bool()

dul()

@spec dul() :: Noun.t()

dul_arm()

@spec dul_arm() :: Noun.t()

I represent the dul gate call as a 2-argument gate.

Can be obtained by defining

=ldul => resource-machine |= [a=@s b=@] (dul [a b])

and computing

.* ldul [0 2]

duni_test()

duni_with_core()

@spec duni_with_core() :: Noun.t()

I represent a duni gate with a specified instantiated in core given as an extra argument.

Can be gotten by defining locally

=l => resource-machine |= [a=_in b=(set)] (duni:a b)

and grabbing the arm with [0 2]

duni_with_core_call(core, set)

@spec duni_with_core_call(Noun.t(), Noun.t()) ::
  {:error, Nock.error()} | {:ok, Noun.t()}

factorial()

@spec factorial() :: Noun.t()

factorial_arm()

@spec factorial_arm() :: Noun.t()

I am the battery of the fib:tests gate of the anoma stadard library.

You can dump me by calling

.* fib:tests [0 2]

fra()

@spec fra() :: Noun.t()

fra_arm()

@spec fra_arm() :: Noun.t()

I represent the fra gate call as a 2-argument gate.

Can be obtained by defining

=lfra => resource-machine |= [a=@s b=@s] (fra [a b])

and computing

.* lfra [0 2]

gor_arm()

@spec gor_arm() :: Noun.t()

I represent the gor gate call.

Can be obtained by defining

=lgor => resource-machine |= [a= b=] (gor a b)

and computing

.* lgor [0 2]

gor_call(a, b)

@spec gor_call(Noun.t(), Noun.t()) :: Noun.t()

I am the full gor gate with specified sample and resource-machine context.

gor_test()

@spec gor_test() :: bool()

got_test()

got_with_core()

@spec got_with_core() :: Noun.t()

I represent a got gate with a specified instantiated in core given as an extra argument.

Can be gotten by defining locally

=l => resource-machine |= [a=_by b=*] (got:a b)

and grabbing the arm with [0 2]

got_with_core_call(core, key)

@spec got_with_core_call(Noun.t(), Noun.t()) ::
  {:error, Nock.error()} | {:ok, Noun.t()}

has_test()

has_with_core()

@spec has_with_core() :: Noun.t()

I represent a has gate with a specified instantiated in core given as an extra argument.

Can be gotten by defining locally

=l => resource-machine |= [a=_in b=(set)] (has:a b)

and grabbing the arm with [0 2]

has_with_core_call(core, elem)

@spec has_with_core_call(Noun.t(), Noun.t()) ::
  {:error, Nock.error()} | {:ok, Noun.t()}

in_arm()

@spec in_arm() :: Noun.t()

The gate representing an in core creation with a specified set.

Can be gotten by defining

=l => resource-machine |= a=(set) ~(. in a)

and getting it's arm with [0 2]

in_call(set)

@spec in_call(Noun.t()) :: {:error, Nock.error()} | {:ok, Noun.t()}

inc(key \\ "key")

@spec inc(Noun.t()) :: Noun.t()

incorrectly_ending()

@spec incorrectly_ending() :: :error

incorrectly_nested_noun()

@spec incorrectly_nested_noun() :: :error

incorrectly_starting()

@spec incorrectly_starting() :: :error

increment_counter_val(val)

@spec increment_counter_val(Noun.t()) :: Noun.t()

indexed_noun()

@spec indexed_noun() :: Noun.t()

int_test()

int_with_core()

@spec int_with_core() :: Noun.t()

I represent an int gate with a specified instantiated in core given as an extra argument.

Can be gotten by defining locally

=l => resource-machine |= [a=_in b=(set)] (int:a b)

and grabbing the arm with [0 2]

int_with_core_call(core, set)

@spec int_with_core_call(Noun.t(), Noun.t()) ::
  {:error, Nock.error()} | {:ok, Noun.t()}

is_commitment_arm()

is_commitment_test()

is_nullifier_arm()

is_nullifier_test()

jam()

@spec jam() :: Noun.t()

jam_and_cue(jam_value, cue_value)

@spec jam_and_cue(any(), any()) :: any()

jam_arm()

@spec jam_arm() :: Noun.t()

A cue arm for taking jam:anoma out of the resource-machine core environment.

Can be gotten by defining gate locally as

=localjam => resource-machine |= a=@ (jam a)

and then grabbing the arm of localjam.

jamming_and_cueing()

@spec jamming_and_cueing() :: :ok

keccak_arm()

keccak_call(msg)

keccak_test(msg \\ :crypto.strong_rand_bytes(32))

kind_arm()

kind_call(resource)

kind_test()

lsh0()

@spec lsh0() :: Noun.t()

I evaluate lsh at block size 0 and gate-input [2 6].

lsh(0) evaluates the gate of the block door at block size 0, [6 1 2 6] replaces the sample with [2 6].

lsh1()

@spec lsh1() :: Noun.t()

I evaluate lsh at block size 1 and gate-input [2 6].

lsh(1) evaluates the gate of the block door at block size 1, [6 1 2 6] replaces the sample with [2 6].

lsh2()

@spec lsh2() :: Noun.t()

I evaluate lsh at block size 1 and gate-input [2 6].

lsh(2) evaluates the gate of the block door at block size 2, [6 1 2 6] replaces the sample with [2 6].

lsh(value)

@spec lsh(Noun.t()) :: Noun.t()

I am an lash arm in the block door.

My index inside the door can be seen by asking to dump the logic of =llsh => resource-machine |= a=@ lsh:block

lte()

@spec lte() :: Noun.t()

lte_arm()

@spec lte_arm() :: Noun.t()

I represent the lte gate call as a 2-argument gate.

Can be obtained by defining

=llte => resource-machine |= [a=@s b=@s] (lte [a b])

and computing

.* llte [0 2]

make_commitment_call(res)

make_delta_arm()

make_delta_call(actions)

make_delta_test()

make_is_commitment_call(atom)

make_is_nullifier_call(atom)

make_nullifier_call(res)

mat()

@spec mat() :: Noun.t()

mat_arm()

@spec mat_arm() :: Noun.t()

The mat arm for taking mat:anoma from the resource-machine core environment.

Can be gotten by defining gate locally as:

=localmat => resource-machine |= a (mat a)

and then grabbing the arm of locamix.

met0()

@spec met0() :: Noun.t()

I evaluate met at block size 0 and gate-input 28.

met(0) evaluates the gate of the block door at block size 0, [6 1 28] replaces the sample with 28.

met1()

@spec met1() :: Noun.t()

I evaluate met at block size 1 and gate-input 28.

met(1) evaluates the gate of the block door at block size 1, [6 1 28] replaces the sample with 28.

met2()

@spec met2() :: Noun.t()

I evaluate met at block size 2 and gate-input 28.

met(2) evaluates the gate of the block door at block size 2, [6 1 28] replaces the sample with 28.

met(value)

@spec met(Noun.t()) :: Noun.t()

I am an lash arm in the block door.

My index inside the door can be seen by asking to dump the logic of =lmet => resource-machine |= a=@ met:block

mix()

@spec mix() :: Noun.t()

mix_arm()

@spec mix_arm() :: Noun.t()

The mix arm for taking mix:anoma from the resource-machine core environment.

Can be gotten by defining gate locally as:

=localmix => resource-machine |= [a=@ b=@] (mix [a b])

and then grabbing the arm of locamix.

mor_arm()

@spec mor_arm() :: Noun.t()

I represent the mor gate call.

Can be obtained by defining

=lmor => resource-machine |= [a= b=] (mor a b)

and computing

.* lmor [0 2]

mor_call(a, b)

@spec mor_call(Noun.t(), Noun.t()) :: Noun.t()

I am the full mor gate with specified sample and resource-machine context.

mor_test()

@spec mor_test() :: bool()

mput_test()

mput_with_core()

@spec mput_with_core() :: Noun.t()

I represent a put gate with a specified instantiated in core given as an extra argument.

Can be gotten by defining locally

=l => resource-machine |= [a=_by b=(pair)] (put:a b)

and grabbing the arm with [0 2]

mput_with_core_call(core, key, val)

@spec mput_with_core_call(Noun.t(), Noun.t(), Noun.t()) ::
  {:error, Nock.error()} | {:ok, Noun.t()}

mug_arm()

@spec mug_arm() :: Noun.t()

I represent the mug gate call.

Can be obtained by defining

=lmug => resource-machine |= a=* (mug a)

and computing

.* lmug [0 2]

mug_call(noun)

@spec mug_call(Noun.t()) :: Noun.t()

I am the full mug gate with specified sample and resource-machine context.

mug_test()

@spec mug_test() :: bool()

nesting_noun()

@spec nesting_noun() :: Noun.t()

new()

@spec new() :: Noun.t()

new_arm()

@spec new_arm() :: Noun.t()

I represent the new gate call as a 2-argument gate.

Can be obtained by defining

=lnew => resource-machine |= [a=? b=@] (new [a b])

and computing

.* lnew [0 2]

nock_scry_crash()

@spec nock_scry_crash() :: Noun.t()

nullifier_arm()

nullifier_test(n \\ :rand.uniform(10000))

og_arm()

@spec og_arm() :: Noun.t()

The gate representing an og core creation with a specified seed.

Can be gotten by defining

=l => resource-machine |= [seed=@] ~(. og seed)

and getting it's arm with [0 2]

og_call(seed)

@spec og_call(non_neg_integer()) :: {:error, Nock.error()} | {:ok, Noun.t()}

old()

@spec old() :: Noun.t()

old_arm()

@spec old_arm() :: Noun.t()

I represent the old gate call as a 2-argument gate.

Can be obtained by defining

=lold => resource-machine |= [a=@s] (old a)

and computing

.* lold [0 2]

one_two()

@spec one_two() :: Noun.t()

pro()

@spec pro() :: Noun.t()

pro_arm()

@spec pro_arm() :: Noun.t()

I represent the pro gate call as a 2-argument gate.

Can be obtained by defining

=lpro => resource-machine |= [a=@s b=@s] (pro [a b])

and computing

.* lpro [0 2]

put_test()

put_with_core()

@spec put_with_core() :: Noun.t()

I represent a put gate with a specified instantiated in core given as an extra argument.

Can be gotten by defining locally

=l => resource-machine |= [a=_in b=*] (put:in b)

and grabbing the arm with [0 2]

put_with_core_call(core, elem)

@spec put_with_core_call(Noun.t(), Noun.t()) ::
  {:error, Nock.error()} | {:ok, Noun.t()}

rad_arm()

@spec rad_arm() :: Noun.t()

I represent the rad gate call as a 2-argument gate.

Can be gotten by defining

=lrad => resource-machine |= [a=@ b=@] (~(rad og a) b)

rad_call(seed, range)

@spec rad_call(any(), non_neg_integer()) :: {:ok, Noun.t()}

I am function calling the rad gate of the og door with specified seed and range

rad_tests()

@spec rad_tests() :: {:ok, Noun.t()}

rads_arm()

@spec rads_arm() :: Noun.t()

I represent the rads gate call as a 2-argument gate.

Can be gotten by defining

=lrad => resource-machine |= [a=@ b=@] (~(rads og a) b)

rads_call(seed, range)

@spec rads_call(non_neg_integer(), non_neg_integer()) ::
  {:error, Nock.error()} | {:ok, Noun.t()}

I am function calling the rads gate of the og door with specified seed and range

rads_tests()

@spec rads_tests() :: :ok

raw_27_4()

@spec raw_27_4() :: {:ok, Noun.t()}

raw_arm()

@spec raw_arm() :: Noun.t()

I represent the raw gate call as a 2-argument gate.

Can be gotten by defining

=lraw => resource-machine |= [a=@ b=@] (~(raw og a) b)

raw_call(seed, width)

@spec raw_call(Noun.t(), Noun.t()) :: {:ok, Noun.t()}

I am function calling the raw gate of the og door with specified seed and bitwidth.

raws_arm()

@spec raws_arm() :: Noun.t()

I represent the raws gate call as a 2-argument gate.

Can be gotten by defining

=lraw => resource-machine |= [a=@ b=@] (~(raws og a) b)

raws_call(seed, width)

@spec raws_call(Noun.t(), Noun.t()) :: {:ok, Noun.t()}

I am function calling the raws gate of the og door with specified seed and bitwidth.

raws_test()

@spec raws_test() :: :ok

raws_with_core()

@spec raws_with_core() :: Noun.t()

I represent a raws gate with a specified instantiated og core given as an extra argument.

Can be gotten by defining locally

=l => resource-machine |= [rng=_og width=@] (raws:rng width)

and grabbing the arm with [0 2]

raws_with_core_call(core, width)

@spec raws_with_core_call(non_neg_integer(), non_neg_integer()) ::
  {:error, Nock.error()} | {:ok, Noun.t()}

raws_with_out_core_test()

@spec raws_with_out_core_test() :: any()

rem()

@spec rem() :: Noun.t()

rem_arm()

@spec rem_arm() :: Noun.t()

I represent the rem gate call as a 2-argument gate.

Can be obtained by defining

=lrem => resource-machine |= [a=@s b=@s] (rem [a b])

and computing

.* lrem [0 2]

replacing_terms()

@spec replacing_terms() :: Noun.t()

resource_delta_arm()

resource_delta_call(res)

resource_delta_test(n \\ :rand.uniform(100_000))

rsh0()

@spec rsh0() :: Noun.t()

I evaluate rsh at block size 0 and gate-input [2 40].

rsh(0) evaluates the gate of the block door at block size 0, [6 1 2 40] replaces the sample with [2 40].

rsh1()

@spec rsh1() :: Noun.t()

I evaluate rsh at block size 1 and gate-input [2 40].

rsh(1) evaluates the gate of the block door at block size 1, [6 1 2 40] replaces the sample with [2 40].

rsh2()

@spec rsh2() :: Noun.t()

I evaluate rsh at block size 2 and gate-input [2 40].

rsh(2) evaluates the gate of the block door at block size 2, [6 1 1 40] replaces the sample with [1 40].

rsh(value)

@spec rsh(Noun.t()) :: Noun.t()

I am an lash arm in the block door.

My index inside the door can be seen by asking to dump the logic of =rsh => resource-machine |= a=@ rsh:block

secp_public_key_arm()

secp_public_key_call(priv_key)

secp_public_key_test(key \\ :crypto.strong_rand_bytes(32))

secp_sign_arm()

secp_sign_call(msg, key)

secp_sign_test(msg \\ :crypto.strong_rand_bytes(32), key \\ :crypto.strong_rand_bytes(32))

secp_verify_arm()

secp_verify_call(msg, sig, key)

secp_verify_test(msg \\ :crypto.strong_rand_bytes(32), key \\ :crypto.strong_rand_bytes(32))

shax()

@spec shax() :: Noun.t()

shax_arm()

@spec shax_arm() :: Noun.t()

The shax arm for taking shax:anoma from the resource-machine core environment.

Can be gotten by defining gate locally as:

=localshax => resource-machine |= a=@ (shax a)

and then grabbing the arm of localshax.

sign()

@spec sign() :: Noun.t()

sign_arm()

@spec sign_arm() :: Noun.t()

The sign arm for taking sign:anoma from the resource-machine core environment.

Can be gotten by defining gate locally as:

=localsign => resource-machine |= [a=@ b=@] (sign [a b])

and then grabbing the arm of localsign.

sign_detatched()

@spec sign_detatched() :: Noun.t()

sign_detatched_arm()

@spec sign_detatched_arm() :: Noun.t()

The sign-detatched arm for taking sign-detached:anoma from the resource-machine core environment.

Can be gotten by defining gate locally as:

=localsigndetached => resource-machine |= [a=@ b=@] (sign-detached [a b])

and then grabbing the arm of localsighdetached.

silt_arm()

@spec silt_arm() :: Noun.t()

I represent the mor gate call.

Can be obtained by defining

=lsilt => resource-machine |= a=(list) (silt a)

and computing

.* lsilt [0 2]

silt_call(list)

silt_test()

split_arm()

@spec split_arm() :: Noun.t()

I represent a split gate call given an og core with seed.

Can be gotten by defining locally

=l => resource-machine |= [rng=_og] split:rng

and grabbing the arm with [0 2]

split_call(core)

@spec split_call(Noun.t()) :: {:error, Nock.error()} | {:ok, Noun.t()}

sum()

@spec sum() :: Noun.t()

sum_arm()

@spec sum_arm() :: Noun.t()

I represent the sum gate call as a 2-argument gate.

Can be obtained by defining

=lsum => resource-machine |= [a=@s b=@s] (sum [a b])

and computing

.* lsum [0 2]

sun()

@spec sun() :: Noun.t()

sun_arm()

@spec sun_arm() :: Noun.t()

syn()

@spec syn() :: Noun.t()

syn_arm()

@spec syn_arm() :: Noun.t()

t_compose_arm()

t_compose_call(tx1, tx2)

t_compose_test()

tap_by_test()

tap_by_with_core()

@spec tap_by_with_core() :: Noun.t()

I represent a tap:by call with a specified instantiated in core given as an extra argument.

Can be gotten by defining locally

=l => resource-machine |= a=_by tap:a

and grabbing the arm with [0 2]

tap_by_with_core_call(core)

@spec tap_by_with_core_call(Noun.t()) :: {:error, Nock.error()} | {:ok, Noun.t()}

tap_in_test()

tap_in_with_core()

@spec tap_in_with_core() :: Noun.t()

I represent a tap:in call with a specified instantiated in core given as an extra argument.

Can be gotten by defining locally

=l => resource-machine |= a=_in tap:a

and grabbing the arm with [0 2]

tap_in_with_core_call(core)

@spec tap_in_with_core_call(Noun.t()) :: {:error, Nock.error()} | {:ok, Noun.t()}

transparent_core(tx_noun \\ Examples.ETransparent.ETransaction.swap_from_actions() |> Noun.Nounable.to_noun())

@spec transparent_core(Noun.t()) :: Noun.t()

trivial_swap()

@spec trivial_swap() :: Noun.t()

trivial_swap_no_eph()

@spec trivial_swap_no_eph() :: Noun.t()

uend0()

@spec uend0() :: Noun.t()

I evaluate uend at block size 0 and gate-input [5 80].

uend(0) evaluates the gate of the block door at block size 0, [6 1 5 80] replaces the sample with [5 80].

uend1()

@spec uend1() :: Noun.t()

I evaluate uend at block size 1 and gate-input [3 80] and [4 80].

uend(1) evaluates the gate of the block door at block size 1, [6 1 3 80] replaces the sample with [3 80], [6 1 4 80] replaces the sample with [3 80]

uend(value)

@spec uend(Noun.t()) :: Noun.t()

I am an lash arm in the block door.

My index inside the door can be seen by asking to dump the logic of =luend => resource-machine |= a=@ luend:block

uni_test()

uni_with_core()

@spec uni_with_core() :: Noun.t()

I represent a uni gate with a specified instantiated in core given as an extra argument.

Can be gotten by defining locally

=l => resource-machine |= [a=_in b=(set)] (uni:a b)

and grabbing the arm with [0 2]

uni_with_core_call(core, set)

@spec uni_with_core_call(Noun.t(), Noun.t()) ::
  {:error, Nock.error()} | {:ok, Noun.t()}

verify()

@spec verify() :: Noun.t()

verify_arm()

@spec verify_arm() :: Noun.t()

The verify arm for taking verify:anoma from the resource-machine core environment.

Can be gotten by defining gate locally as:

=localverify => resource-machine |= [a=@ b=@] (verify [a b])

and then grabbing the arm of localverify.

verify_detatched()

@spec verify_detatched() :: Noun.t()

verify_detatched_arm()

@spec verify_detatched_arm() :: Noun.t()

The verify-detatched arm for taking verify-detached:anoma from the resource-machine core environment.

Can be gotten by defining gate locally as:

=localverifydetached => resource-machine |= [a=@ b=@ c=@] (verify-detached [a b])

and then grabbing the arm of localverifydetached.

wyt_test()

wyt_with_core()

@spec wyt_with_core() :: Noun.t()

I represent a wyt gate with a specified instantiated in core given as an extra argument.

Can be gotten by defining locally

=l => resource-machine |= a=_in wyt:a

and grabbing the arm with [0 2]

wyt_with_core_call(core)

@spec wyt_with_core_call(Noun.t()) :: {:error, Nock.error()} | {:ok, Noun.t()}

zero(key \\ "key")

@spec zero(Noun.t()) :: Noun.t()

zero_counter(val)

@spec zero_counter(Noun.t()) :: Noun.t()

zero_delta_arm()

zero_delta_call()

zero_delta_logic()

@spec zero_delta_logic() :: Noun.t()

zero_delta_test()