urbit/shrub
1
1
Fork 0
mirror of https://github.com/urbit/shrub.git synced 2024-12-19 08:32:39 +03:00
Code Issues Packages Projects Releases Wiki Activity
c8b62d8d2c
shrub/pkg/arvo/tests/lib/naive.hoon
drbeefsupreme c8b62d8d2c
naive: expand approval-for-all test
2021-08-17 13:30:04 -04:00

3274 lines
109 KiB
Plaintext
Raw Blame History

/+ *test, naive, ethereum, azimuth, *naive-transactions
::
|%
++ n |=([=^state:naive =^input:naive] (%*(. naive lac |) verifier 1.337 +<))
::
++ addr address-from-prv:key:ethereum
::
:: the log-name here is the head of the topics list, so topics
:: is actually a lest as found in naive.hoon. the changed-dns
:: event has no additional topics, which requires the gate here
:: to take an empty list. TODO: does this create an issue with
:: the rollup RPC or lib/ethereum?
++ log
|= [log-name=@ux data=@ux topics=(list @)]
^- ^input:naive
[%log *@ux data log-name topics]
::
:: ~zod is for testing potential padding issues because of the presence
:: of leading or trailing zeroes
::
++ init-zod
|= =^state:naive
^- [effects:naive ^state:naive]
=^ f1 state (n state (owner-changed:l1 ~zod (addr %zod-key-0)))
=^ f2 state (n state (owner-changed:l1 ~dopzod (addr %dopzod-key-0)))
=^ f3 state (n state (changed-spawn-proxy:l1 ~zod (addr %zod-skey-0)))
=^ f4 state (n state (changed-spawn-proxy:l1 ~zod deposit-address:naive))
=^ f5 state (n state (owner-changed:l1 ~dopzod deposit-address:naive))
[:(welp f1 f2 f3 f4 f5) state]
::
:: ~bud is so that we aren't testing something impossible in Azimuth, like a star spawned before its sponsor galaxy
::
++ init-bud
|= =^state:naive
^- [effects:naive ^state:naive]
(n state (owner-changed:l1 ~bud (addr %bud-key-0)))
::
:: ~wes is for testing sponsors of stars
::
++ init-wes
|= =^state:naive
^- [effects:naive ^state:naive]
(n state (owner-changed:l1 ~wes (addr %wes-key-0)))
::
:: ~rut is for "full testing"
:: ~rigrut is L1 star
:: ~larsyx-mapmeg is L1 planet under ~rigrut
:: ~holrut is L1 star w/ L2 spawn proxy
:: ~rabsum-ravtyd is L1 planet under ~holrut
:: ~dovmul-mogryt is L2 planet under ~holrut made w/ %own proxy
:: ~pidted-dacnum is L2 planet under ~holrut made w/ %spawn proxy predeposited
:: TODO: L2 planet ~nacbes-mogmev made with L2 spawn proxy postdeposited (currently doesnt work)
::
:: ~losrut is L2 star
:: ~radres-tinnyl is L1 planet under ~losrut
:: ~pinpun-pilsun is L2 planet under ~losrut made w/ %own proxy
:: ~habtyc-nibpyx is L2 planet under ~losrut made w/ %spawn proxy predeposited
:: ~disryt-nolpet is L2 planet under ~losrut made w/ %spawn proxy postdeposited
::
:: nonces in the end state (0 if not stated):
:: ~holrut %own 1
:: ~losrut %own 2
:: ~losrut %spawn 1
::
:: ~red is for testing escapes.
:: ~rigred is L1 star
:: ~losred is L2 star
::
++ init-rut-full
|= =^state:naive
^- [effects:naive ^state:naive]
=/ dm-spawn [[~holrut %own] %spawn ~dovmul-mogryt (addr %holrut-dm-key-0)]
=/ dm-xfer [[~dovmul-mogryt %transfer] %transfer-point (addr %holrut-dm-key-0) &]
=/ pd-spawn [[~holrut %spawn] %spawn ~pidted-dacnum (addr %holrut-pd-key-0)]
=/ pd-xfer [[~pidted-dacnum %transfer] %transfer-point (addr %holrut-pd-key-0) &]
=/ pp-spawn [[~losrut %own] %spawn ~pinpun-pilsun (addr %losrut-pp-key-0)]
=/ pp-xfer [[~pinpun-pilsun %transfer] %transfer-point (addr %losrut-pp-key-0) &]
=/ hn-spawn [[~losrut %spawn] %spawn ~habtyc-nibpyx (addr %losrut-hn-key-0)]
=/ hn-xfer [[~habtyc-nibpyx %transfer] %transfer-point (addr %losrut-hn-key-0) &]
=/ dn-spawn [[~losrut %spawn] %spawn ~disryt-nolpet (addr %losrut-dn-key-0)]
=/ dn-xfer [[~disryt-nolpet %transfer] %transfer-point (addr %losrut-dn-key-0) &]
=/ losrut-sproxy [[~losrut %spawn] %set-spawn-proxy (addr %losrut-skey-1)]
=/ losrut-mproxy [[~losrut %own] %set-management-proxy (addr %losrut-mkey-0)]
=/ dm-mkey [[~dovmul-mogryt %own] %set-management-proxy (addr %holrut-dm-mkey-0)]
=/ pd-mkey [[~pidted-dacnum %own] %set-management-proxy (addr %holrut-pd-mkey-0)]
=/ pp-mkey [[~pinpun-pilsun %own] %set-management-proxy (addr %losrut-pp-mkey-0)]
=/ hn-mkey [[~habtyc-nibpyx %own] %set-management-proxy (addr %losrut-hn-mkey-0)]
=/ dn-mkey [[~disryt-nolpet %own] %set-management-proxy (addr %losrut-dn-mkey-0)]
=^ f1 state (n state (owner-changed:l1 ~rut (addr %rut-key-0)))
=^ f2 state (n state (owner-changed:l1 ~rigrut (addr %rigrut-key-0)))
=^ f3 state (n state (owner-changed:l1 ~holrut (addr %holrut-key-0)))
=^ f4 state (n state (owner-changed:l1 ~losrut (addr %losrut-key-0)))
=^ f5 state (n state (owner-changed:l1 ~larsyx-mapmeg (addr %rigrut-lm-key-0)))
=^ f6 state (n state (owner-changed:l1 ~rabsum-ravtyd (addr %holrut-rr-key-0)))
=^ f7 state (n state (owner-changed:l1 ~radres-tinnyl (addr %losrut-rt-key-0)))
=^ f8 state (n state (changed-spawn-proxy:l1 ~holrut (addr %holrut-skey-0)))
=^ f8 state (n state (changed-spawn-proxy:l1 ~losrut (addr %losrut-skey-0)))
=^ f8 state (n state (changed-spawn-proxy:l1 ~holrut deposit-address:naive))
=^ f9 state (n state %bat q:(gen-tx 0 dm-spawn %holrut-key-0))
=^ f10 state (n state %bat q:(gen-tx 0 pd-spawn %holrut-skey-0))
=^ f11 state (n state (owner-changed:l1 ~losrut deposit-address:naive))
=^ f12 state (n state %bat q:(gen-tx 0 pp-spawn %losrut-key-0))
=^ f13 state (n state %bat q:(gen-tx 0 hn-spawn %losrut-skey-0))
=^ f14 state (n state %bat q:(gen-tx 1 losrut-sproxy %losrut-skey-0))
=^ f15 state (n state %bat q:(gen-tx 2 dn-spawn %losrut-skey-1))
=^ f16 state (n state %bat q:(gen-tx 0 dm-xfer %holrut-dm-key-0))
=^ f17 state (n state %bat q:(gen-tx 0 pd-xfer %holrut-pd-key-0))
=^ f18 state (n state %bat q:(gen-tx 0 pp-xfer %losrut-pp-key-0))
=^ f19 state (n state %bat q:(gen-tx 0 hn-xfer %losrut-hn-key-0))
=^ f20 state (n state %bat q:(gen-tx 0 dn-xfer %losrut-dn-key-0))
:: the following sets proxies for testing with various proxies
=^ p1 state (n state (changed-management-proxy:l1 ~rut (addr %rut-mkey-0)))
=^ p2 state (n state (changed-management-proxy:l1 ~rigrut (addr %rigrut-mkey-0)))
=^ p3 state (n state (changed-management-proxy:l1 ~larsyx-mapmeg (addr %rigrut-lm-mkey-0)))
=^ p4 state (n state (changed-management-proxy:l1 ~holrut (addr %holrut-mkey-0)))
=^ p5 state (n state (changed-management-proxy:l1 ~rabsum-ravtyd (addr %holrut-rr-mkey-0)))
=^ p6 state (n state (changed-management-proxy:l1 ~radres-tinnyl (addr %losrut-rt-mkey-0)))
=^ p7 state (n state %bat q:(gen-tx 0 dm-mkey %holrut-dm-key-0))
=^ p8 state (n state %bat q:(gen-tx 0 pd-mkey %holrut-pd-key-0))
=^ p9 state (n state %bat q:(gen-tx 0 pp-mkey %losrut-pp-key-0))
=^ p10 state (n state %bat q:(gen-tx 0 hn-mkey %losrut-hn-key-0))
=^ p11 state (n state %bat q:(gen-tx 0 dn-mkey %losrut-dn-key-0))
=^ p12 state (n state %bat q:(gen-tx 1 losrut-mproxy %losrut-key-0))
:: end of ~rut points, beginning of ~red. TODO this should be removed
:: once i move %escape to +test-red. or maybe %escape should stay here
:: because its the simplest?
=^ g1 state (n state (owner-changed:l1 ~red (addr %red-key-0)))
=^ g2 state (n state (owner-changed:l1 ~rigred (addr %rigred-key-0)))
=^ g3 state (n state (owner-changed:l1 ~losred (addr %losred-key-0)))
=^ g4 state (n state (changed-management-proxy:l1 ~rigred (addr %rigred-mkey-0)))
=^ g5 state (n state (changed-management-proxy:l1 ~losred (addr %losred-mkey-0)))
=^ g6 state (n state (owner-changed:l1 ~losred deposit-address:naive))
:- ;: welp
f1 f2 f3 f4 f5 f6 f7 f8 f9 f10
f11 f12 f13 f14 f15 f16 f17 f18
f19 f20
p1 p2 p3 p4 p5 p6 p7 p8 p9 p10
p11 p12
g1 g2 g3 g4 g5 g6
==
state
::
:: +init-red-full adds another galaxy to the ~rut universe, ~red, and additional
:: points helpful for testing sponsorship actions. this has been separated from
:: ~rut because the concerns are different enough from the other actions that
:: its cleaner to do them separately
::
++ init-red-full
|= =^state:naive
^- [effects:naive ^state:naive]
=/ pp-escape [[~pinpun-pilsun %own] %escape ~losred]
=/ dm-escape [[~dovmul-mogryt %own] %escape ~rigred]
=/ lm-escape [[~larsyx-mapmeg %own] %escape ~losred]
=/ rr-escape [[~rabsum-ravtyd %own] %escape ~rigred]
=^ f1 state (init-rut-full state)
:: TODO uncomment the below once %escape is moved to +test-red
:: =^ f21 state (n state (owner-changed:l1 ~red (addr %red-key-0)))
:: =^ f22 state (n state (owner-changed:l1 ~rigred (addr %rigred-key-0)))
:: =^ f23 state (n state (owner-changed:l1 ~losred (addr %losred-key-0)))
:: =^ f24 state (n state (owner-changed:l1 ~losred deposit-address:naive))
:: each pending escape will be followed by an adopt, reject, or cancel-escape
:: L1->L1
=^ f2 state (n state %bat q:(gen-tx 0 rr-escape %holrut-rr-key-0))
:: L2->L2
=^ f3 state (n state %bat q:(gen-tx 1 pp-escape %losrut-pp-key-0))
:: L2->L1
=^ f4 state (n state %bat q:(gen-tx 1 dm-escape %holrut-dm-key-0))
:: L1->L2
=^ f5 state (n state %bat q:(gen-tx 0 lm-escape %rigrut-lm-key-0))
[:(welp f1 f2 f3 f4 f5) state]
::
:: ~dopbud is for testing L1 ownership with L2 spawn proxy
::
++ init-dopbud
|= =^state:naive
^- [effects:naive ^state:naive]
=^ f1 state (init-bud state)
=^ f2 state (n state (owner-changed:l1 ~dopbud (addr %dopbud-key-0)))
=^ f3 state (n state (changed-spawn-proxy:l1 ~dopbud deposit-address:naive))
[:(welp f1 f2 f3) state]
::
:: ~marbud is for testing L2 ownership
::
++ init-marbud
|= =^state:naive
^- [effects:naive ^state:naive]
=^ f1 state (init-bud state)
=^ f2 state (n state (owner-changed:l1 ~marbud (addr %marbud-key-0)))
=^ f3 state (n state (owner-changed:l1 ~marbud deposit-address:naive))
[:(welp f1 f2 f3) state]
::
:: ~litbud is for testing L2 sponsorship
::
++ init-litbud
|= =^state:naive
^- [effects:naive ^state:naive]
:: ~bud should already be spawned, though trying to init ~bud again shouldn't matter i think?
=^ f1 state (init-bud state)
=^ f2 state (n state (owner-changed:l1 ~litbud (addr %litbud-key-0)))
=^ f3 state (n state (owner-changed:l1 ~litbud deposit-address:naive))
[:(welp f2 f3) state]
::
:: ~sambud is for testing L1 stars
::
++ init-sambud
|= =^state:naive
^- [effects:naive ^state:naive]
=^ f1 state (init-bud state)
=^ f2 state (n state (owner-changed:l1 ~sambud (addr %sambud-key-0)))
[:(welp f1 f2) state]
::
:: generates all possible transactions and maps them to whether they ought
:: to succeed
::
++ l2-event-gen
|%
::
+$ rank ?(%galaxy %star %planet)
+$ tx-type $? %transfer-point
%spawn
%configure-keys
%escape
%cancel-escape
%adopt
%reject
%detach
%set-management-proxy
%set-spawn-proxy
%set-transfer-proxy
==
+$ event [=rank owner=? nonce=? =dominion:naive =proxy:naive =tx-type]
+$ event-list (list event)
+$ success-map (map event ?)
+$ event-jar (jar @p event)
+$ full-tx [nonce=@ =tx:naive pk=@]
+$ tx-list (list full-tx)
::
++ make-success-map
:: +make-success-map maps each event to whether or not that combination of factors
:: ought to succeed or fail, for testing purposes. this is not a complete description atm
:: for instance, it does not take into account whether you are trying to spawn a planet
:: available to you or move to a sponsor of the correct rank.
::
:: it is also done in a more verbose style than strictly necessary to make it easier
:: to read through and determine why a particular event is labeled with %.y or %.n
:: and to make it easier to do future modifications
::
:: TODO: heavily comment this so its obviously correct. can use
:: comments on the right hand side since its narrow
|= =event-list ^- success-map
=| =success-map
|^
?~ event-list success-map
=/ cur-event i.event-list
:: check owner or nonce first
?: ?| =(owner.cur-event %.n)
=(nonce.cur-event %.n)
==
(add-event-check cur-event %.n)
:: check dominion next
?- dominion.cur-event
%l1 (add-event-check cur-event (l1-check cur-event))
%spawn (add-event-check cur-event (spawnd-check cur-event))
%l2 (add-event-check cur-event (l2-check cur-event))
==
::
++ add-event-check
|= [=event suc=?]
%= ^$
success-map (~(put by success-map) event suc)
event-list +.event-list
==
::
++ l1-check
|^
|= cur-event=event ^- ?
?- proxy.cur-event
%own (manage-own-check cur-event)
%spawn %.n
%manage (manage-own-check cur-event)
%vote %.n
%transfer %.n
==
::
++ manage-own-check
|^
|= cur-event=event ^- ?
?- rank.cur-event
%galaxy (galaxy-check cur-event)
%star (star-check cur-event)
%planet (planet-check cur-event)
==
++ galaxy-check
|= cur-event=event ^- ?
?+ tx-type.cur-event %.n
%adopt %.y
%reject %.y
%detach %.y
==
++ star-check
|= cur-event=event ^- ?
?+ tx-type.cur-event %.n
%adopt %.y
%reject %.y
%detach %.y
%escape %.y
%cancel-escape %.y
==
++ planet-check
|= cur-event=event ^- ?
?+ tx-type.cur-event %.n
%escape %.y
%cancel-escape %.y
==
::
-- :: +manage-own-check
::
-- :: +l1-check
::
++ spawnd-check
|^
|= cur-event=event ^- ?
?- rank.cur-event
%galaxy %.n
%star (star-check cur-event)
%planet %.n
==
++ star-check
|^
|= cur-event=event ^- ?
?- proxy.cur-event
%own (ownp-check cur-event)
%manage (managep-check cur-event)
%spawn (spawnp-check cur-event)
%vote %.n
%transfer %.n
==
++ ownp-check
|= cur-event=event ^- ?
?+ tx-type.cur-event %.n
%spawn %.y
%adopt %.y
%reject %.y
%detach %.y
%escape %.y
%cancel-escape %.y
%set-spawn-proxy %.y
==
++ managep-check
|= cur-event=event ^- ?
?+ tx-type.cur-event %.n
%adopt %.y
%reject %.y
%detach %.y
%escape %.y
%cancel-escape %.y
==
++ spawnp-check
|= cur-event=event ^- ?
?+ tx-type.cur-event %.n
%spawn %.y
%set-spawn-proxy %.y
==
-- :: +star-check
::
-- :: +spawnd-check
::
++ l2-check
|^
|= cur-event=event ^- ?
?- rank.cur-event
%galaxy %.n
%star (star-check cur-event)
%planet (planet-check cur-event)
==
++ star-check
|^
|= cur-event=event ^- ?
?- proxy.cur-event
%own %.y
%manage (managep-check cur-event)
%spawn (spawnp-check cur-event)
%vote %.n
%transfer (transferp-check cur-event)
==
++ managep-check
|= cur-event=event ^- ?
?- tx-type.cur-event
%configure-keys %.y
%escape %.y
%cancel-escape %.y
%adopt %.y
%reject %.y
%detach %.y
%set-management-proxy %.y
%set-spawn-proxy %.n
%set-transfer-proxy %.n
%transfer-point %.n
%spawn %.n
==
++ spawnp-check
|= cur-event=event ^- ?
?+ tx-type.cur-event %.n
%spawn %.y
%set-spawn-proxy %.y
==
++ transferp-check
|= cur-event=event ^- ?
?+ tx-type.cur-event %.n
%transfer-point %.y
%set-transfer-proxy %.n
==
-- :: +star-check
++ planet-check
|^
|= cur-event=event ^- ?
?- proxy.cur-event
%own (ownp-check cur-event)
%manage (managep-check cur-event)
%spawn %.n
%vote %.n
%transfer (transferp-check cur-event)
==
++ ownp-check
|= cur-event=event ^- ?
?- tx-type.cur-event
%transfer-point %.y
%spawn %.n
%configure-keys %.y
%escape %.y
%cancel-escape %.y
%adopt %.n
%reject %.n
%detach %.n
%set-management-proxy %.y
%set-spawn-proxy %.n
%set-transfer-proxy %.y
==
++ managep-check
|= cur-event=event ^- ?
?+ tx-type.cur-event %.n
%configure-keys %.y
%escape %.y
%cancel-escape %.y
%set-management-proxy %.y
==
++ transferp-check
|= cur-event=event ^- ?
?+ tx-type.cur-event %.y
%transfer-point %.y
%set-transfer-proxy %.y
==
::
-- :: +planet-check
::
-- :: +l2-check
::
-- :: make-success-map
::
++ filter-tx-type
|= [typs=(list =tx-type) =event-list]
|^
(skim event-list filter)
++ filter
:: I think I can shorten this a bit with a fold or something
|= =event ^- ?
=/ match=? %.n
|-
?~ typs match
=/ cur-typ i.typs
%= $
match |(match =(cur-typ tx-type.event))
typs t.typs
==
--
::
++ filter-proxy
|= [=proxy:naive =event-list]
|^
(skim event-list filter)
++ filter
|= =event
=(proxy.event proxy)
--
::
++ filter-rank
|= [=rank =event-list]
|^
(skim event-list filter)
++ filter
|= =event
=(rank.event rank)
--
::
++ filter-owner
|= [owner=? =event-list]
|^
(skim event-list filter)
++ filter
|= =event
=(owner.event owner)
--
::
++ filter-nonce
|= [nonce=? =event-list]
|^
(skim event-list filter)
++ filter
|= =event
=(nonce.event nonce)
--
::
++ filter-dominion
|= [=dominion:naive =event-list]
|^
(skim event-list filter)
++ filter
|= =event
=(dominion.event dominion)
--
::
++ make-event-list ^- event-list
=| =event-list
=/ rank-i 1
|-
?: (gth rank-i 3)
(remove-wrong-dominion event-list)
=/ owner-i 0
|-
?. (lte owner-i 1)
^$(rank-i +(rank-i))
=/ nonce-i 0
|-
?. (lte nonce-i 1)
^$(owner-i +(owner-i))
=/ dominion-i 1
|-
?. (lte dominion-i 3)
^$(nonce-i +(nonce-i))
=/ proxy-i 1
|-
?. (lte proxy-i 5)
^$(dominion-i +(dominion-i))
=/ tx-type-i 1
|-
?. (lte tx-type-i 11)
^$(proxy-i +(proxy-i))
%= $
tx-type-i +(tx-type-i)
event-list :- :* (num-to-rank rank-i)
(num-to-flag owner-i)
(num-to-flag nonce-i)
(num-to-dominion dominion-i)
(num-to-proxy proxy-i)
(num-to-tx-type tx-type-i)
==
event-list
==
::
++ remove-wrong-dominion
|= in=event-list
=| =event-list
|-
?~ in event-list
=/ current-event i.in
?: ?& =(rank.current-event %galaxy)
!=(dominion.current-event %l1)
==
$(in t.in)
?: ?& =(rank.current-event %planet)
=(dominion.current-event %spawn)
==
$(in t.in)
%= $
in t.in
event-list current-event^event-list
==
::
++ num-to-flag
|= val=@ud ^- ?
?+ val !!
%0 %.y
%1 %.n
==
::
++ num-to-rank
|= val=@ud ^- rank
?+ val !!
%1 %galaxy
%2 %star
%3 %planet
==
::
++ num-to-dominion
|= val=@ud ^- dominion:naive
?+ val !!
%1 %l1
%2 %l2
%3 %spawn
==
::
++ num-to-proxy
|= val=@ud ^- proxy:naive
?+ val !!
%1 %own
%2 %spawn
%3 %manage
%4 %vote
%5 %transfer
==
::
++ num-to-tx-type
|= val=@ud ^- tx-type
?+ val !!
%1 %transfer-point
%2 %spawn
%3 %configure-keys
%4 %escape
%5 %cancel-escape
%6 %adopt
%7 %reject
%8 %detach
%9 %set-management-proxy
%10 %set-spawn-proxy
%11 %set-transfer-proxy
==
::
:: jar of events for rut. each @p is mapped to a list of events
:: it ought to test, and +success-map says whether or not that
:: event should succed or fail
::
::
++ gen-rut-jar
^- (jar @p event)
=/ filter ;: cork
(cury filter-owner %.y)
(cury filter-proxy %own)
(cury filter-nonce %.y)
(cury filter-rank %planet)
::(cury filter-dominion %spawn)
%- cury
:- filter-tx-type
:* ::%spawn
::%transfer-point
%configure-keys
::%set-management-proxy
::%set-spawn-proxy :: planets can set spawn proxy atm
::%set-transfer-proxy
::%escape
~
==
==
=/ filtered-events (filter make-event-list)
=| mgmt-jar=(jar @p event)
|^
?~ filtered-events mgmt-jar
=/ current-event i.filtered-events
?: =(rank.current-event %galaxy)
(list-in-jar (ly ~[~rut]) current-event)
?: =(rank.current-event %star)
?- dominion.current-event
%l1 (list-in-jar (ly ~[~rigrut]) current-event)
%spawn (list-in-jar (ly ~[~holrut]) current-event)
%l2 (list-in-jar (ly ~[~losrut]) current-event)
==
?: =(rank.current-event %planet)
?+ dominion.current-event !!
%l1 %- list-in-jar
:- %- ly
:^ ~larsyx-mapmeg
~rabsum-ravtyd
~radres-tinnyl
~
current-event
%l2 %- list-in-jar
:- %- ly
:* ~dovmul-mogryt
~pidted-dacnum
~pinpun-pilsun
~habtyc-nibpyx
~disryt-nolpet
~
==
current-event
==
$(filtered-events t.filtered-events)
::
++ list-in-jar
|= [ships=(list ship) =event]
^+ mgmt-jar
=/ new-jar mgmt-jar
|-
?~ ships %= ^^$
mgmt-jar new-jar
filtered-events +.filtered-events
==
=. new-jar (~(add ja new-jar) i.ships event)
$(ships t.ships)
::
--
::
:: takes in a list of full-tx and turns them into a batch
:: to be submitted to +n. The ordering on the list is the order in which
:: the transactions are processed
++ tx-list-to-batch
|= =tx-list ^- @
(can 3 (turn tx-list gen-tx))
-- :: end +l2-event-gen
::
++ l1
|%
::
:: Azimuth.sol events
::
++ owner-changed
|= [=ship =address]
(log owner-changed:log-names:naive *@ux ship address ~)
::
:: TODO: Activated (not in lib/naive.hoon)
:: TODO: Spawned (not in lib/naive.hoon)
::
++ escape-requested
|= [escapee=ship parent=ship]
(log escape-requested:log-names:naive *@ux escapee parent ~)
::
++ escape-canceled
:: The parent is pinned but not used in lib/naive.hoon for some reason
|= [escapee=ship parent=ship]
(log escape-canceled:log-names:naive *@ux escapee parent ~)
::
++ escape-accepted
|= [escapee=ship parent=ship]
(log escape-accepted:log-names:naive *@ux escapee parent ~)
::
++ lost-sponsor
|= [lost=ship parent=ship]
(log lost-sponsor:log-names:naive *@ux lost parent ~)
::
++ changed-keys
|= [=ship suite=@ encr=@ auth=@ life=@]
=/ keys=@ux
%: can 8
1^life
1^suite
1^auth
1^encr
~
==
(log changed-keys:log-names:naive keys ship ~)
::
++ broke-continuity
|= [=ship rift=@]
(log broke-continuity:log-names:naive rift ship ~)
::
++ changed-spawn-proxy
|= [=ship =address]
(log changed-spawn-proxy:log-names:naive *@ux ship address ~)
::
++ changed-transfer-proxy
|= [=ship =address]
(log changed-transfer-proxy:log-names:naive *@ux ship address ~)
::
++ changed-management-proxy
|= [=ship =address]
(log changed-management-proxy:log-names:naive *@ux ship address ~)
::
++ changed-voting-proxy
|= [=ship =address]
(log changed-voting-proxy:log-names:naive *@ux ship address ~)
::
++ changed-dns
|= [data=@]
(log changed-dns:log-names:naive data ~)
::
:: Ecliptic.sol events
::
++ approval-for-all
|= [owner=address operator=address approved=@]
(log approval-for-all:log-names:naive approved owner operator ~)
::
--
::
--
::
:: Common values used for tests
::
|%
::
++ encr (shax 'You will forget that you ever read this sentence.')
++ auth (shax 'You cant know that this sentence is true.')
++ suit 1
::
++ marbud-own [~marbud %own] ::key %marbud-key-0
++ marbud-spn [~marbud %spawn] :: key %marbud-skey
++ marbud-mgt [~marbud %manage] :: key %marbud-mkey
++ marbud-xfr [~marbud %transfer] :: key %marbud-key-1
::
++ dopbud-own [~dopbud %own] :: key %dopbud-key-0
::
++ litbud-own [~litbud %own] :: key %litbud-key-0
::
++ lt-own [~linnup-torsyx %own] :: key %lt-key-0
++ lt-xfr [~linnup-torsyx %transfer] :: key %lt-key-0
::
::
:: rut tests
::
::
++ common-mgmt %mgmt-key-0
++ common-spwn %spwn-key-0
++ common-vote %vote-key-0
++ common-ownr %ownr-key-0
++ common-tran %tran-key-0
++ rut-ship-list %- ly
:* ~rut
~holrut
~rigrut
~losrut
~larsyx-mapmeg
~rabsum-ravtyd
~disryt-nolpet
~pinpun-pilsun
~dovmul-mogryt
~habtyc-nibpyx
~pidted-dacnum
~radres-tinnyl
~
==
::
:: initial keys for each point under ~rut
++ default-own-keys %- my:nl
:* [~rut %rut-key-0]
[~holrut %holrut-key-0]
[~rigrut %rigrut-key-0]
[~losrut %losrut-key-0]
[~larsyx-mapmeg %rigrut-lm-key-0]
[~rabsum-ravtyd %holrut-rr-key-0]
[~disryt-nolpet %losrut-dn-key-0]
[~pinpun-pilsun %losrut-pp-key-0]
[~dovmul-mogryt %holrut-dm-key-0]
[~habtyc-nibpyx %losrut-hn-key-0]
[~pidted-dacnum %holrut-pd-key-0]
[~radres-tinnyl %losrut-rt-key-0]
~
==
::
++ default-manage-keys %- my:nl
:* [~rut %rut-mkey-0]
[~holrut %holrut-mkey-0]
[~rigrut %rigrut-mkey-0]
[~losrut %losrut-mkey-0]
[~larsyx-mapmeg %rigrut-lm-mkey-0]
[~rabsum-ravtyd %holrut-rr-mkey-0]
[~disryt-nolpet %losrut-dn-mkey-0]
[~pinpun-pilsun %losrut-pp-mkey-0]
[~dovmul-mogryt %holrut-dm-mkey-0]
[~habtyc-nibpyx %losrut-hn-mkey-0]
[~pidted-dacnum %holrut-pd-mkey-0]
[~radres-tinnyl %losrut-rt-mkey-0]
~
==
++ default-spawn-keys %- my:nl
:* [~holrut %holrut-skey-0]
[~losrut %losrut-skey-0]
~
==
::
:: sponsorship tests
++ losrut-own [~losrut %own]
++ losrut-mgmt [~losrut %manage]
++ holrut-own [~holrut %own]
++ holrut-mgmt [~holrut %manage]
++ rigrut-own [~rigrut %own]
++ rigrut-mgmt [~rigrut %manage]
++ losred-own [~losred %own]
++ losred-mgmt [~losred %manage]
++ rigred-own [~rigred %own]
++ rigred-mgmt [~rigred %manage]
::
--
::
:: Tests
::
|%
:: new tests
::
:: this test spawns a "full galaxy" containing all varieties of points. it then
:: saves this initial state, and runs single transaction batches for all possible
:: L2 "event types". it compares the entire new state to the entire initial state and checks for
:: the expected state change. it then resets the state to the initial state and
:: tries the next event in on the list.
::
:: more specifically, there is a $jar called event-jar that maps ships to lists of
:: events it should try. it then picks off a ship, tries all the events in the list
:: associated to it as described above, and then moves on to the next ship, until
:: the jar is empty.
::
:: this arm does not test any L1 transactions beyond the ones needed to spawn the
:: galaxy (+init-rut).
::
++ test-rut ^- tang
=, l2-event-gen
::
=/ event-jar gen-rut-jar
=| =^state:naive
=^ f state (init-rut-full state)
=/ initial-state state
=/ ship-list rut-ship-list
=/ suc-map (make-success-map make-event-list)
~& event-jar
::
|- ^- tang
?~ ship-list ~
%+ weld $(ship-list t.ship-list)
=/ cur-ship i.ship-list
%+ category (scow %p cur-ship)
=/ current-events (~(get ja event-jar) cur-ship)
::
|- ^- tang
?~ current-events ~
%+ weld $(current-events t.current-events)
=/ cur-event i.current-events
%+ category (weld "dominion " (scow %tas dominion.cur-event))
%+ category (weld "proxy " (scow %tas proxy.cur-event))
%+ category (weld "tx-type " (scow %tas tx-type.cur-event))
%+ category (weld "owner? " (scow %f owner.cur-event))
%+ category (weld "correct nonce? " (scow %f nonce.cur-event))
::
=/ cur-point (~(got by points.initial-state) cur-ship)
=* own own.cur-point
=/ cur-nonce
?- proxy.cur-event
%own nonce.owner.own
%spawn nonce.spawn-proxy.own
%manage nonce.management-proxy.own
%vote nonce.voting-proxy.own
%transfer nonce.transfer-proxy.own
==
:: wrong nonce and/or wrong owner do not increment nonce
:: TODO: fix nonce calculation for e.g. %spawn proxy for planets
=/ new-nonce ?: &(nonce.cur-event owner.cur-event)
+(cur-nonce)
cur-nonce
::
=/ state initial-state
=/ expect-state initial-state
|^
%+ expect-eq
!>
|^ ^- ^state:naive
?. (~(got by suc-map) cur-event)
%- alter-state
?- proxy.cur-event
%own cur-point(nonce.owner.own new-nonce)
%spawn cur-point(nonce.spawn-proxy.own new-nonce)
%manage cur-point(nonce.management-proxy.own new-nonce)
%vote cur-point(nonce.voting-proxy.own new-nonce)
%transfer cur-point(nonce.transfer-proxy.own new-nonce)
==
?+ tx-type.cur-event !!
%transfer-point set-xfer
%configure-keys set-keys
%set-management-proxy set-mgmt-proxy
%set-spawn-proxy set-spwn-proxy
%set-transfer-proxy set-xfer-proxy
%spawn (new-point which-spawn)
%escape (set-escape which-escape-l1)
==
::
++ set-keys ^- ^state:naive
=/ new-keys
%= cur-point
life.keys.net +(life.keys.net:(~(got by points.initial-state) cur-ship))
suite.keys.net suit
auth.keys.net auth
crypt.keys.net encr
==
(alter-state new-keys)
::
++ set-xfer ^- ^state:naive
=/ new-xfer
%= cur-point
address.owner.own (addr %transfer-test)
==
(alter-state new-xfer)
::
++ set-mgmt-proxy ^- ^state:naive
=/ new-mgmt
%= cur-point
address.management-proxy.own (addr %proxy-test)
==
(alter-state new-mgmt)
::
++ set-spwn-proxy ^- ^state:naive
=/ new-spwn
%= cur-point
address.spawn-proxy.own (addr %proxy-test)
==
(alter-state new-spwn)
::
++ set-xfer-proxy ^- ^state:naive
=/ new-xfer
%= cur-point
address.transfer-proxy.own (addr %proxy-test)
==
(alter-state new-xfer)
::
++ set-escape
|= =ship ^- ^state:naive
=/ new-escp
%= cur-point
escape.net (some ship)
==
(alter-state new-escp)
::
++ new-point
:: TODO clean up this horrifying gate
|= =ship ^- ^state:naive
=| new-point=point:naive
=/ spawned
%= new-point
dominion %l2
address.owner.own (addr (~(got by default-own-keys) cur-ship))
address.transfer-proxy.own (addr %spawn-test)
sponsor.net [has=%.y who=cur-ship]
==
=/ expect-state (alter-state cur-point) :: this updates the nonce of the spawner
%= expect-state
points (~(put by points.expect-state) ship spawned)
==
::
++ alter-state
:: this updates the expect-state with the new point, and takes
:: care of incrementing the nonce as well.
|= alt-point=point:naive ^- ^state:naive
=/ updated-point=point:naive
?- proxy.cur-event
%own alt-point(nonce.owner.own new-nonce)
%spawn alt-point(nonce.spawn-proxy.own new-nonce)
%manage alt-point(nonce.management-proxy.own new-nonce)
%vote alt-point(nonce.voting-proxy.own new-nonce)
%transfer alt-point(nonce.transfer-proxy.own new-nonce)
==
%= expect-state
points (~(put by points.expect-state) cur-ship updated-point)
==
::
-- :: end of expected state
:: actual state
!>
|^ ^- ^state:naive
=^ f
state
%- n
:+ state
%bat
=< q
%- gen-tx
:+ ?: nonce.cur-event
cur-nonce
999 :: wrong nonce
:- :- cur-ship
proxy.cur-event
def-args
?: owner.cur-event
?+ proxy.cur-event %wrong-key
%own (~(got by default-own-keys) cur-ship)
%manage (~(got by default-manage-keys) cur-ship)
%spawn ?: =(rank.cur-event %star)
(~(got by default-spawn-keys) cur-ship)
%wrong-key
==
%wrong-key :: if not owner then use wrong key
state
::
++ def-args
^- skim-tx:naive
|^
?+ tx-type.cur-event !!
%spawn [%spawn which-spawn (addr %spawn-test)]
%transfer-point [%transfer-point (addr %transfer-test) |]
%configure-keys [%configure-keys encr auth suit |]
%escape [%escape which-escape-l2]
:: %cancel-escape
:: %adopt
:: %reject
:: %detach
%set-management-proxy [%set-management-proxy (addr %proxy-test)]
%set-spawn-proxy [%set-spawn-proxy (addr %proxy-test)]
%set-transfer-proxy [%set-transfer-proxy (addr %proxy-test)]
==
::
-- :: +def-args
::
-- :: end of actual state
::
++ encr (shax 'You will forget that you ever read this sentence.')
++ auth (shax 'You cant know that this sentence is true.')
++ suit 1
::
++ which-spawn ^- ship
?+ cur-ship !!
%~rut ~hasrut
%~rigrut ~batbec-tapmep
%~larsyx-mapmeg ~nocryl-tobned
%~holrut ~namtuc-ritnux
%~rabsum-ravtyd ~docsec-wanlug
%~dovmul-mogryt ~docsec-wanlug
%~pidted-dacnum ~docsec-wanlug
%~losrut ~mishus-loplus
%~radres-tinnyl ~tapfur-fitsep
%~pinpun-pilsun ~tapfur-fitsep
%~habtyc-nibpyx ~tapfur-fitsep
%~disryt-nolpet ~tapfur-fitsep
==
::
++ which-escape-l1 ^- ship
:: currently unused
:: escaping to a L1 point
?- rank.cur-event
%galaxy ~red
%star ~red
%planet ~rigred
==
::
++ which-escape-l2 ^- ship
:: escaping to a L2 point
?- rank.cur-event
%galaxy ~red
%star ~red
%planet ~losred
==
::
-- :: end of +expect-eq
::
:: the following are sponsorship tests. they ought to eventually be consolidated
:: into one large test, but for now it will be easier to tell which one is failing
:: by splitting them up
::
:: the following are L2 sponsorship tests. the syntax is test-galaxy-X-Y-action. X is the
:: layer of the sponsee, Y is the layer of the sponsor.
::
:: Each row of the following table has one or more tests that cover it.
:: The corresponding row is listed as a comment in that test. Thus
:: you can grep for the line and fine the appropriate test. A few of
:: the tests cannot be performed here - there are the ones marked by !!
:: but we include what the tests would look like anyways as a comment
::
:: * on the left means all possible states, on the right it means no change.
:: !! means that case can never happen per L1 contract
:: L1-cancel can be triggered by "cancel escape" by the child or "reject" by the sponsor
:: A1 and A2 are arbitrary but distinct ships one class above the main ship
:: Event | E_1 | E_2 | S_1 | S_2 | -> | E_1 | E_2 | S_1 | S_2
:: L1-escape A1 | * | * | * | * | -> | A1 | A1 | * | *
:: L1-cancel A1 | ~ | * | * | * | -> !! :: no cancel if not escaping
:: L1-cancel A1 | A1 | * | * | * | -> | ~ | ~ | * | *
:: L1-adopt A1 | A1 | * | * | * | -> | ~ | ~ | A1 | A2
:: L1-adopt A1 | ~ | * | * | * | -> !! :: no adopt if not escaping
:: L1-adopt A1 | A2 | * | * | * | -> !! :: no adopt if not escaping
:: L1-detach A1 | * | * | A1 | A1 | -> | * | * | ~ | ~
:: L1-detach A1 | * | * | A1 | A2 | -> | * | * | ~ | A2
:: L1-detach A1 | * | * | A1 | ~ | -> | * | * | ~ | ~
:: L2-escape A1 | * | * | * | * | -> | * | A1 | * | *
:: L2-cancel A1 | * | * | * | * | -> | * | ~ | * | *
:: L2-adopt A1 | * | A1 | * | * | -> | * | ~ | * | A1
:: L2-adopt A1 | * | A2 | * | * | -> | * | A2 | * | *
:: L2-adopt A1 | * | ~ | * | * | -> | * | ~ | * | *
:: L2-reject A1 | * | A1 | * | * | -> | * | ~ | * | *
:: L2-reject A1 | * | A2 | * | * | -> | * | A2 | * | *
:: L2-reject A1 | * | ~ | * | * | -> | * | ~ | * | *
:: L2-detach A1 | * | * | * | A1 | -> | * | * | * | ~
:: L2-detach A1 | * | * | * | A2 | -> | * | * | * | A2
:: L2-detach A1 | * | * | * | ~ | -> | * | * | * | ~
::
:: the following test L1 escape actions
::
++ test-rut-l1-l1-escape-l1 ^- tang
:: L1-escape A1 | * | * | * | * | -> | A1 | A1 | * | *
%+ expect-eq
!> [[~ ~rigred] %.y ~holrut]
::
!>
=| =^state:naive
=^ f state (init-rut-full state)
=^ f state (n state (escape-requested:l1 ~rabsum-ravtyd ~rigred))
[escape.net sponsor.net]:(~(got by points.state) ~rabsum-ravtyd)
::
++ test-rut-l1-l2-escape-l1 ^- tang
:: L1-escape A1 | * | * | * | * | -> | A1 | A1 | * | *
:: An L1 ship can L1 escape to an L2 ship, but the L2 ship must
:: adopt on L2
%+ expect-eq
!> [[~ ~losred] %.y ~rigrut]
::
!>
=| =^state:naive
=^ f state (init-rut-full state)
=^ f state (n state (escape-requested:l1 ~larsyx-mapmeg ~losred))
[escape.net sponsor.net]:(~(got by points.state) ~larsyx-mapmeg)
::
++ test-rut-l2-lx-escape-l1 ^- tang
:: L2 ships can't escape on L1
;: weld
:: escaping to L1 ship
%+ expect-eq
!> [~ %.y ~holrut]
::
!>
=| =^state:naive
=^ f state (init-rut-full state)
=^ f state (n state (escape-requested:l1 ~dovmul-mogryt ~rigred))
[escape.net sponsor.net]:(~(got by points.state) ~dovmul-mogryt)
::
:: escaping to L2 ship
%+ expect-eq
!> [~ %.y ~losrut]
::
!>
=| =^state:naive
=^ f state (init-rut-full state)
=^ f state (n state (escape-requested:l1 ~pinpun-pilsun ~losred))
[escape.net sponsor.net]:(~(got by points.state) ~pinpun-pilsun)
==
::
++ test-red-l2-l2-adopt-l2-1 ^- tang
:: L2-adopt A1 | * | A1 | * | * | -> | * | ~ | * | A1
=/ pp-adopt [losred-own %adopt ~pinpun-pilsun]
=/ pp-m-adopt [losred-mgmt %adopt ~pinpun-pilsun]
::
;: weld
%+ expect-eq
!> [~ %.y ~losred]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 0 pp-adopt %losred-key-0))
[escape.net sponsor.net]:(~(got by points.state) ~pinpun-pilsun)
::
%+ expect-eq
!> [~ %.y ~losred]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 0 pp-m-adopt %losred-mkey-0))
[escape.net sponsor.net]:(~(got by points.state) ~pinpun-pilsun)
==
::
++ test-red-l1-l2-adopt-l2-1
:: L2-adopt A1 | * | A1 | * | * | -> | * | ~ | * | A1
=/ lm-adopt [losred-own %adopt ~larsyx-mapmeg]
=/ lm-m-adopt [losred-mgmt %adopt ~larsyx-mapmeg]
::
;: weld
%+ expect-eq
!> [~ %.y ~losred]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 0 lm-adopt %losred-key-0))
[escape.net sponsor.net]:(~(got by points.state) ~larsyx-mapmeg)
::
%+ expect-eq
!> [~ %.y ~losred]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 0 lm-m-adopt %losred-mkey-0))
[escape.net sponsor.net]:(~(got by points.state) ~larsyx-mapmeg)
==
::
++ test-red-l2-l1-adopt-l2-1
:: L2-adopt A1 | * | A1 | * | * | -> | * | ~ | * | A1
=/ dm-adopt [rigred-own %adopt ~dovmul-mogryt]
=/ dm-m-adopt [rigred-mgmt %adopt ~dovmul-mogryt]
::
;: weld
%+ expect-eq
!> [~ %.y ~rigred]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 0 dm-adopt %rigred-key-0))
[escape.net sponsor.net]:(~(got by points.state) ~dovmul-mogryt)
::
%+ expect-eq
!> [~ %.y ~rigred]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 0 dm-m-adopt %rigred-mkey-0))
[escape.net sponsor.net]:(~(got by points.state) ~dovmul-mogryt)
==
::
++ test-red-l1-l1-adopt-l2-1
:: L2-adopt A1 | * | A1 | * | * | -> | * | ~ | * | A1
=/ rr-adopt [rigred-own %adopt ~rabsum-ravtyd]
=/ rr-m-adopt [rigred-mgmt %adopt ~rabsum-ravtyd]
::
;: weld
%+ expect-eq
!> [~ %.y ~rigred]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 0 rr-adopt %rigred-key-0))
[escape.net sponsor.net]:(~(got by points.state) ~rabsum-ravtyd)
::
%+ expect-eq
!> [~ %.y ~rigred]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 0 rr-m-adopt %rigred-mkey-0))
[escape.net sponsor.net]:(~(got by points.state) ~rabsum-ravtyd)
==
::
++ test-red-l1-l1-adopt-l2-2
:: L2-adopt A1 | * | A2 | * | * | -> | * | A2 | * | *
=/ rr-adopt [losred-own %adopt ~rabsum-ravtyd]
=/ rr-m-adopt [losred-mgmt %adopt ~rabsum-ravtyd]
::
;: weld
%+ expect-eq
!> [[~ ~rigred] %.y ~holrut]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 0 rr-adopt %losred-key-0))
[escape.net sponsor.net]:(~(got by points.state) ~rabsum-ravtyd)
::
%+ expect-eq
!> [[~ ~rigred] %.y ~holrut]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 0 rr-m-adopt %losred-mkey-0))
[escape.net sponsor.net]:(~(got by points.state) ~rabsum-ravtyd)
==
::
++ test-rut-l1-l1-adopt-l2-3 ^- tang
:: L2-adopt A1 | * | ~ | * | * | -> | * | ~ | * | *
::
=/ rr-h-detach [1 [holrut-own %detach ~rabsum-ravtyd] %holrut-key-0]
=/ rr-h-m-detach [0 [holrut-mgmt %detach ~rabsum-ravtyd] %holrut-mkey-0]
=/ rr-adopt [0 [losred-own %adopt ~rabsum-ravtyd] %losred-key-0]
=/ rr-m-adopt [0 [losred-mgmt %adopt ~rabsum-ravtyd] %losred-mkey-0]
::
=, l2-event-gen
=/ rr-batch-1=tx-list (limo ~[rr-h-detach rr-adopt])
=/ rr-batch-2=tx-list (limo ~[rr-h-m-detach rr-m-adopt])
::
=/ init-state=^state:naive +:(init-rut-full *^state:naive)
;: weld
%+ expect-eq
!> [~ %.n ~holrut]
::
!>
=| =^state:naive
=^ f state (n init-state %bat q:(gen-tx rr-h-detach))
=^ f state (n state %bat q:(gen-tx rr-adopt))
[escape.net sponsor.net]:(~(got by points.state) ~rabsum-ravtyd)
::
%+ expect-eq
!> [~ %.n ~holrut]
!>
=| =^state:naive
=^ f state (n init-state %bat (tx-list-to-batch rr-batch-1))
[escape.net sponsor.net]:(~(got by points.state) ~rabsum-ravtyd)
::
%+ expect-eq
!> [~ %.n ~holrut]
::
!>
=| =^state:naive
=^ f state (n init-state %bat q:(gen-tx rr-h-m-detach))
=^ f state (n state %bat q:(gen-tx rr-m-adopt))
[escape.net sponsor.net]:(~(got by points.state) ~rabsum-ravtyd)
::
%+ expect-eq
!> [~ %.n ~holrut]
::
!>
=| =^state:naive
=^ f state (n init-state %bat (tx-list-to-batch rr-batch-2))
[escape.net sponsor.net]:(~(got by points.state) ~rabsum-ravtyd)
==
::
:: the following tests L2 %rejects
++ test-red-l2-l2-reject-l2-1 ^- tang
:: L2-reject A1 | * | A1 | * | * | -> | * | ~ | * | *
=/ pp-reject [losred-own %reject ~pinpun-pilsun]
=/ pp-m-reject [losred-mgmt %reject ~pinpun-pilsun]
::
;: weld
%+ expect-eq
!> [~ %.y ~losrut]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 0 pp-reject %losred-key-0))
[escape.net sponsor.net]:(~(got by points.state) ~pinpun-pilsun)
::
%+ expect-eq
!> [~ %.y ~losrut]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 0 pp-m-reject %losred-mkey-0))
[escape.net sponsor.net]:(~(got by points.state) ~pinpun-pilsun)
==
::
++ test-red-l2-l1-reject-l2-1 ^- tang
:: L2-reject A1 | * | A1 | * | * | -> | * | ~ | * | *
=/ dm-reject [rigred-own %reject ~dovmul-mogryt]
=/ dm-m-reject [rigred-mgmt %reject ~dovmul-mogryt]
::
;: weld
%+ expect-eq
!> [~ %.y ~holrut]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 0 dm-reject %rigred-key-0))
[escape.net sponsor.net]:(~(got by points.state) ~dovmul-mogryt)
::
%+ expect-eq
!> [~ %.y ~holrut]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 0 dm-m-reject %rigred-mkey-0))
[escape.net sponsor.net]:(~(got by points.state) ~dovmul-mogryt)
==
::
++ test-red-l1-l2-reject-l2-1 ^- tang
:: L2-reject A1 | * | A1 | * | * | -> | * | ~ | * | *
=/ lm-reject [losred-own %reject ~larsyx-mapmeg]
=/ lm-m-reject [losred-mgmt %reject ~larsyx-mapmeg]
::
;: weld
%+ expect-eq
!> [~ %.y ~rigrut]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 0 lm-reject %losred-key-0))
[escape.net sponsor.net]:(~(got by points.state) ~larsyx-mapmeg)
::
%+ expect-eq
!> [~ %.y ~rigrut]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 0 lm-m-reject %losred-mkey-0))
[escape.net sponsor.net]:(~(got by points.state) ~larsyx-mapmeg)
==
::
++ test-red-l1-l1-reject-l2-1 ^- tang
:: L2-reject A1 | * | A1 | * | * | -> | * | ~ | * | *
=/ rr-reject [rigred-own %reject ~rabsum-ravtyd]
=/ rr-m-reject [rigred-mgmt %reject ~rabsum-ravtyd]
::
;: weld
%+ expect-eq
!> [~ %.y ~holrut]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 0 rr-reject %rigred-key-0))
[escape.net sponsor.net]:(~(got by points.state) ~rabsum-ravtyd)
::
%+ expect-eq
!> [~ %.y ~holrut]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 0 rr-m-reject %rigred-mkey-0))
[escape.net sponsor.net]:(~(got by points.state) ~rabsum-ravtyd)
==
++ test-red-l2-l2-reject-l2-2 ^- tang
:: L2-reject A1 | * | A2 | * | * | -> | * | A2 | * | *
=/ pp-reject [losrut-own %reject ~pinpun-pilsun]
=/ pp-m-reject [losrut-mgmt %reject ~pinpun-pilsun]
::
;: weld
%+ expect-eq
!> [[~ ~losred] %.y ~losrut]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 2 pp-reject %losrut-key-0))
[escape.net sponsor.net]:(~(got by points.state) ~pinpun-pilsun)
::
%+ expect-eq
!> [[~ ~losred] %.y ~losrut]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 0 pp-m-reject %losrut-mkey-0))
[escape.net sponsor.net]:(~(got by points.state) ~pinpun-pilsun)
==
::
++ test-red-l2-l1-reject-l2-2 ^- tang
:: L2-reject A1 | * | A2 | * | * | -> | * | A2 | * | *
=/ dm-reject [holrut-own %reject ~dovmul-mogryt]
=/ dm-m-reject [holrut-mgmt %reject ~dovmul-mogryt]
::
;: weld
%+ expect-eq
!> [[~ ~rigred] %.y ~holrut]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 1 dm-reject %holrut-key-0))
[escape.net sponsor.net]:(~(got by points.state) ~dovmul-mogryt)
::
%+ expect-eq
!> [[~ ~rigred] %.y ~holrut]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 0 dm-m-reject %holrut-mkey-0))
[escape.net sponsor.net]:(~(got by points.state) ~dovmul-mogryt)
==
::
++ test-red-l1-l2-reject-l2-2 ^- tang
:: L2-reject A1 | * | A2 | * | * | -> | * | A2 | * | *
=/ lm-reject [rigrut-own %reject ~larsyx-mapmeg]
=/ lm-m-reject [rigrut-mgmt %reject ~larsyx-mapmeg]
::
;: weld
%+ expect-eq
!> [[~ ~losred] %.y ~rigrut]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 0 lm-reject %rigrut-key-0))
[escape.net sponsor.net]:(~(got by points.state) ~larsyx-mapmeg)
::
%+ expect-eq
!> [[~ ~losred] %.y ~rigrut]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 0 lm-m-reject %rigrut-mkey-0))
[escape.net sponsor.net]:(~(got by points.state) ~larsyx-mapmeg)
==
::
++ test-red-l1-l1-reject-l2-2 ^- tang
:: L2-reject A1 | * | A2 | * | * | -> | * | A2 | * | *
=/ rr-reject [holrut-own %reject ~rabsum-ravtyd]
=/ rr-m-reject [holrut-mgmt %reject ~rabsum-ravtyd]
::
;: weld
%+ expect-eq
!> [[~ ~rigred] %.y ~holrut]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 1 rr-reject %holrut-key-0))
[escape.net sponsor.net]:(~(got by points.state) ~rabsum-ravtyd)
::
%+ expect-eq
!> [[~ ~rigred] %.y ~holrut]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 0 rr-m-reject %holrut-mkey-0))
[escape.net sponsor.net]:(~(got by points.state) ~rabsum-ravtyd)
==
::
++ test-red-l1-l1-reject-l2-3 ^- tang
:: L2-reject A1 | * | ~ | * | * | -> | * | ~ | * | *
=/ rt-reject [holrut-own %reject ~radres-tinnyl]
=/ rt-m-reject [holrut-mgmt %reject ~radres-tinnyl]
::
;: weld
%+ expect-eq
!> [~ %.y ~losrut]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 1 rt-reject %holrut-key-0))
[escape.net sponsor.net]:(~(got by points.state) ~radres-tinnyl)
::
%+ expect-eq
!> [~ %.y ~losrut]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 0 rt-m-reject %holrut-mkey-0))
[escape.net sponsor.net]:(~(got by points.state) ~radres-tinnyl)
==
::
:: the following tests L2 %cancel-escape
::
++ test-red-l2-l2-cancel-escape-l2 ^- tang
:: L2-cancel A1 | * | * | * | * | -> | * | ~ | * | *
=/ pp-cancel-escape [[~pinpun-pilsun %own] %cancel-escape ~losred]
=/ pp-m-cancel-escape [[~pinpun-pilsun %manage] %cancel-escape ~losred]
::
;: weld
%+ expect-eq
!> [~ %.y ~losrut]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 2 pp-cancel-escape %losrut-pp-key-0))
[escape.net sponsor.net]:(~(got by points.state) ~pinpun-pilsun)
::
%+ expect-eq
!> [~ %.y ~losrut]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 0 pp-m-cancel-escape %losrut-pp-mkey-0))
[escape.net sponsor.net]:(~(got by points.state) ~pinpun-pilsun)
==
::
++ test-red-l2-l1-cancel-escape-l2 ^- tang
:: L2-cancel A1 | * | * | * | * | -> | * | ~ | * | *
=/ dm-cancel-escape [[~dovmul-mogryt %own] %cancel-escape ~rigred]
=/ dm-m-cancel-escape [[~dovmul-mogryt %manage] %cancel-escape ~rigred]
::
;: weld
%+ expect-eq
!> [~ %.y ~holrut]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 2 dm-cancel-escape %holrut-dm-key-0))
[escape.net sponsor.net]:(~(got by points.state) ~dovmul-mogryt)
::
%+ expect-eq
!> [~ %.y ~holrut]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 0 dm-m-cancel-escape %holrut-dm-mkey-0))
[escape.net sponsor.net]:(~(got by points.state) ~dovmul-mogryt)
==
::
++ test-red-l1-l2-cancel-escape-l2 ^- tang
:: L2-cancel A1 | * | * | * | * | -> | * | ~ | * | *
=/ lm-cancel-escape [[~larsyx-mapmeg %own] %cancel-escape ~losred]
=/ lm-m-cancel-escape [[~larsyx-mapmeg %manage] %cancel-escape ~losred]
::
;: weld
%+ expect-eq
!> [~ %.y ~rigrut]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 1 lm-cancel-escape %rigrut-lm-key-0))
[escape.net sponsor.net]:(~(got by points.state) ~larsyx-mapmeg)
::
%+ expect-eq
!> [~ %.y ~rigrut]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 0 lm-m-cancel-escape %rigrut-lm-mkey-0))
[escape.net sponsor.net]:(~(got by points.state) ~larsyx-mapmeg)
==
::
++ test-red-l1-l1-cancel-escape-l2 ^- tang
:: L2-cancel A1 | * | * | * | * | -> | * | ~ | * | *
=/ rr-cancel-escape [[~rabsum-ravtyd %own] %cancel-escape ~rigred]
=/ rr-m-cancel-escape [[~rabsum-ravtyd %manage] %cancel-escape ~rigred]
::
;: weld
%+ expect-eq
!> [~ %.y ~holrut]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 1 rr-cancel-escape %holrut-rr-key-0))
[escape.net sponsor.net]:(~(got by points.state) ~rabsum-ravtyd)
::
%+ expect-eq
!> [~ %.y ~holrut]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 0 rr-m-cancel-escape %holrut-rr-mkey-0))
[escape.net sponsor.net]:(~(got by points.state) ~rabsum-ravtyd)
==
::
:: the following tests L2 %detach. the format test-rut-X-Y-detach means
:: X is the layer of the sponsor, Y is the layer of the sponsee
::
++ test-rut-l2-l2-detach-l2-1 ^- tang
:: L2-detach A1 | * | * | * | A1 | -> | * | * | * | ~
=/ pp-detach [losrut-own %detach ~pinpun-pilsun]
=/ pp-m-detach [losrut-mgmt %detach ~pinpun-pilsun]
::
;: weld
%+ expect-eq
!> [~ %.n ~losrut]
::
!>
=| =^state:naive
=^ f state (init-rut-full state)
=^ f state (n state %bat q:(gen-tx 2 pp-detach %losrut-key-0))
[escape.net sponsor.net]:(~(got by points.state) ~pinpun-pilsun)
::
%+ expect-eq
!> [~ %.n ~losrut]
::
!>
=| =^state:naive
=^ f state (init-rut-full state)
=^ f state (n state %bat q:(gen-tx 0 pp-m-detach %losrut-mkey-0))
[escape.net sponsor.net]:(~(got by points.state) ~pinpun-pilsun)
==
::
++ test-rut-l2-l1-detach-l2-1 ^- tang
:: L2-detach A1 | * | * | * | A1 | -> | * | * | * | ~
=/ rt-detach [losrut-own %detach ~radres-tinnyl]
=/ rt-m-detach [losrut-mgmt %detach ~radres-tinnyl]
::
;: weld
%+ expect-eq
!> [~ %.n ~losrut]
::
!>
=| =^state:naive
=^ f state (init-rut-full state)
=^ f state (n state %bat q:(gen-tx 2 rt-detach %losrut-key-0))
[escape.net sponsor.net]:(~(got by points.state) ~radres-tinnyl)
::
%+ expect-eq
!> [~ %.n ~losrut]
::
!>
=| =^state:naive
=^ f state (init-rut-full state)
=^ f state (n state %bat q:(gen-tx 0 rt-m-detach %losrut-mkey-0))
[escape.net sponsor.net]:(~(got by points.state) ~radres-tinnyl)
==
::
++ test-rut-l1-l2-detach-l2-1 ^- tang
:: L2-detach A1 | * | * | * | A1 | -> | * | * | * | ~
=/ dm-detach [holrut-own %detach ~dovmul-mogryt]
=/ dm-m-detach [holrut-mgmt %detach ~dovmul-mogryt]
::
;: weld
%+ expect-eq
!> [~ %.n ~holrut]
::
!>
=| =^state:naive
=^ f state (init-rut-full state)
=^ f state (n state %bat q:(gen-tx 1 dm-detach %holrut-key-0))
[escape.net sponsor.net]:(~(got by points.state) ~dovmul-mogryt)
::
%+ expect-eq
!> [~ %.n ~holrut]
::
!>
=| =^state:naive
=^ f state (init-rut-full state)
=^ f state (n state %bat q:(gen-tx 0 dm-m-detach %holrut-mkey-0))
[escape.net sponsor.net]:(~(got by points.state) ~dovmul-mogryt)
==
::
++ test-rut-l1-l1-detach-l2-1 ^- tang
:: L2-detach A1 | * | * | * | A1 | -> | * | * | * | ~
=/ lm-detach [rigrut-own %detach ~larsyx-mapmeg]
=/ lm-m-detach [rigrut-mgmt %detach ~larsyx-mapmeg]
::
;: weld
%+ expect-eq
!> [~ %.n ~rigrut]
::
!>
=| =^state:naive
=^ f state (init-rut-full state)
=^ f state (n state %bat q:(gen-tx 0 lm-detach %rigrut-key-0))
[escape.net sponsor.net]:(~(got by points.state) ~larsyx-mapmeg)
::
%+ expect-eq
!> [~ %.n ~rigrut]
::
!>
=| =^state:naive
=^ f state (init-rut-full state)
=^ f state (n state %bat q:(gen-tx 0 lm-m-detach %rigrut-mkey-0))
[escape.net sponsor.net]:(~(got by points.state) ~larsyx-mapmeg)
==
::
++ test-rut-l1-l1-detach-l2-2 ^- tang
:: L2-detach A1 | * | * | * | A2 | -> | * | * | * | A2
:: makes sure that you cannot detach someone who your arent sponsoring
::
=/ rr-detach [rigrut-own %detach ~rabsum-ravtyd]
=/ rr-m-detach [rigrut-mgmt %detach ~rabsum-ravtyd]
::
;: weld
%+ expect-eq
!> [~ %.y ~holrut]
::
!>
=| =^state:naive
=^ f state (init-rut-full state)
=^ f state (n state %bat q:(gen-tx 0 rr-detach %rigrut-key-0))
[escape.net sponsor.net]:(~(got by points.state) ~rabsum-ravtyd)
::
%+ expect-eq
!> [~ %.y ~holrut]
::
!>
=| =^state:naive
=^ f state (init-rut-full state)
=^ f state (n state %bat q:(gen-tx 0 rr-m-detach %rigrut-mkey-0))
[escape.net sponsor.net]:(~(got by points.state) ~rabsum-ravtyd)
==
::
++ test-rut-l1-l1-detach-l2-3 ^- tang
:: L2-detach A1 | * | * | * | ~ | -> | * | * | * | ~
:: makes sure detach on someone without a sponsor is a no-op
::
=/ rr-h-detach [1 [holrut-own %detach ~rabsum-ravtyd] %holrut-key-0]
=/ rr-h-m-detach [0 [holrut-mgmt %detach ~rabsum-ravtyd] %holrut-mkey-0]
=/ rr-detach [0 [rigrut-own %detach ~rabsum-ravtyd] %rigrut-key-0]
=/ rr-m-detach [0 [rigrut-mgmt %detach ~rabsum-ravtyd] %rigrut-mkey-0]
::
=, l2-event-gen
=/ rr-detach-batch-1=tx-list (limo rr-h-detach rr-detach ~)
=/ rr-detach-batch-2=tx-list (limo rr-h-m-detach rr-m-detach ~)
::
=/ init-state=^state:naive +:(init-rut-full *^state:naive)
;: weld
%+ expect-eq
!> [~ %.n ~holrut]
::
!>
=| =^state:naive
=^ f state (n init-state %bat q:(gen-tx rr-h-detach))
=^ f state (n state %bat q:(gen-tx rr-detach))
[escape.net sponsor.net]:(~(got by points.state) ~rabsum-ravtyd)
::
%+ expect-eq
!> [~ %.n ~holrut]
::
!>
=| =^state:naive
=^ f state (n init-state %bat (tx-list-to-batch rr-detach-batch-1))
[escape.net sponsor.net]:(~(got by points.state) ~rabsum-ravtyd)
::
%+ expect-eq
!> [~ %.n ~holrut]
::
!>
=| =^state:naive
=^ f state (n init-state %bat q:(gen-tx rr-h-m-detach))
=^ f state (n state %bat q:(gen-tx rr-m-detach))
[escape.net sponsor.net]:(~(got by points.state) ~rabsum-ravtyd)
::
%+ expect-eq
!> [~ %.n ~holrut]
::
!>
=| =^state:naive
=^ f state (n init-state %bat (tx-list-to-batch rr-detach-batch-2))
[escape.net sponsor.net]:(~(got by points.state) ~rabsum-ravtyd)
==
::
:: the following tests are for sponsorship actions between two L1 points
++ test-red-l1-escape-l2-adopt ^- tang
=/ rr-adopt [rigred-own %adopt ~rabsum-ravtyd]
%+ expect-eq
!> [~ %.y ~rigred]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state (escape-requested:l1 ~rabsum-ravtyd ~rigred))
=^ f state (n state %bat q:(gen-tx 0 rr-adopt %rigred-key-0))
[escape.net sponsor.net]:(~(got by points.state) ~rabsum-ravtyd)
::
:: The following test fails but only because ecliptic.sol only allows
:: an adopt when its valid to do so.
::
:: ++ test-red-l2-escape-l1-adopt ^- tang
:: :: shouldn't be possible to accept a L2 escape with a L1 adopt
:: %+ expect-eq
:: !> [[~ ~rigred] %.y ~holrut]
:: ::
:: !>
:: =| =^state:naive
:: =^ f state (init-red-full state)
:: =^ f state (n state (escape-accepted:l1 ~rabsum-ravtyd ~rigred))
:: [escape.net sponsor.net]:(~(got by points.state) ~rabsum-ravtyd)
::
++ test-rut-l1-adoption-on-l2-wrong-key-or-nonce
=/ rr-escape [[~rabsum-ravtyd %own] %escape ~rigred]
=/ rr-adopt [rigred-own %adopt ~rabsum-ravtyd]
::
=/ init-state +:(init-rut-full *^state:naive)
::
;: weld
%+ expect-eq
!> [~ %.y ~holrut]
::
!>
=| =^state:naive
=^ f state (n init-state %bat q:(gen-tx 1 rr-escape %wrong-key))
=^ f state (n state %bat q:(gen-tx 0 rr-adopt %rigred-key-0))
[escape.net sponsor.net]:(~(got by points.state) ~rabsum-ravtyd)
::
%+ expect-eq
!> [~ %.y ~holrut]
::
!>
=| =^state:naive
=^ f state (n init-state %bat q:(gen-tx 999 rr-escape %holrut-rr-key-0))
=^ f state (n state %bat q:(gen-tx 0 rr-adopt %rigred-key-0))
[escape.net sponsor.net]:(~(got by points.state) ~rabsum-ravtyd)
==
::
++ test-own-sponsor-l2-escape
:: You can't escape to your own sponsor on L1, so you shouldn't be able
:: to on L2 either
::
=/ rr-escape [[~rabsum-ravtyd %own] %escape ~holrut]
::
%+ expect-eq
!> [~ %.y ~holrut]
::
!>
=| =^state:naive
=^ f state (init-rut-full state)
=^ f state (n state %bat q:(gen-tx 0 rr-escape %holrut-rr-key-0))
[escape.net sponsor.net]:(~(got by points.state) ~rabsum-ravtyd)
::
++ test-rut-l1-detach-1
:: L1-detach A1 | * | * | A1 | A1 | -> | * | * | ~ | ~
:: this checks that if you have the same sponsor on L1 and L2, then
:: a L1 detach makes you lose both
::
:: ~rabsum-ravtyd is a L1 planet under a L1 star so would theortically
:: already be sponsored by ~holrut on L1. this already appears in
:: the L2 state as being sponsored by ~holrut, but we will go through
:: with adopting ~rabsum-ravtyd on L2 anyways before the L1 detach
::
:: TODO: escaping to your own sponsor shouldn't be allowed since it isn't
:: on L1, so I should remove the lines that have RR escaping to its
:: own sponsor
::
=/ rr-escape [[~rabsum-ravtyd %own] %escape ~holrut]
=/ rr-adopt [holrut-own %adopt ~rabsum-ravtyd]
%+ expect-eq
!> [~ %.n ~holrut]
::
!>
=| =^state:naive
=^ f state (init-rut-full state)
=^ f state (n state %bat q:(gen-tx 0 rr-escape %holrut-rr-key-0))
=^ f state (n state %bat q:(gen-tx 1 rr-adopt %holrut-key-0))
=^ f state (n state (lost-sponsor:l1 ~rabsum-ravtyd ~holrut))
[escape.net sponsor.net]:(~(got by points.state) ~rabsum-ravtyd)
::
++ test-red-l1-detach-2
:: this takes a L1 planet with L1 sponsor that acquires a L2 sponsor
:: and is then detached by their L1 sponsor
::
:: L1-detach A1 | * | * | A1 | A2 | -> | * | * | ~ | A2
::
=/ lm-adopt [losred-own %adopt ~larsyx-mapmeg]
::
%+ expect-eq
!> [~ %.y ~losred]
::
!>
=| =^state:naive
=^ f state (init-red-full state)
=^ f state (n state %bat q:(gen-tx 0 lm-adopt %losred-key-0))
=^ f state (n state (lost-sponsor:l1 ~larsyx-mapmeg ~rigrut))
[escape.net sponsor.net]:(~(got by points.state) ~larsyx-mapmeg)
::
++ test-rut-l1-detach-3
:: L1-detach A1 | * | * | A1 | ~ | -> | * | * | ~ | ~
:: Since we don't see L1 state explicitly, we can't really test
:: this transition here. But I've included it for completeness sake
=/ rr-detach [holrut-own %detach ~rabsum-ravtyd]
::
%+ expect-eq
!> [~ %.n ~holrut]
::
!>
=| =^state:naive
=^ f state (init-rut-full state)
=^ f state (n state %bat q:(gen-tx 1 rr-detach %holrut-key-0))
=^ f state (n state (escape-requested:l1 ~rabsum-ravtyd ~holrut))
=^ f state (n state (escape-accepted:l1 ~rabsum-ravtyd ~holrut))
=^ f state (n state (lost-sponsor:l1 ~rabsum-ravtyd ~holrut))
[escape.net sponsor.net]:(~(got by points.state) ~rabsum-ravtyd)
::
:: This test is commented since ecliptic.sol will not allow a cancel
:: if not escaping, so this row of the table cannot be tested here.
:: ++ test-rut-l1-cancel-1
:: :: L1-cancel A1 | ~ | * | * | * | -> !! :: no cancel if not escaping
:: :: Note we're using ~rut so there are no initial escapes
:: ::
:: %+ expect-eq
:: !> ~
:: ::
:: !>
:: =| =^state:naive
:: =^ f state (init-rut-full state)
:: =^ f state (n state (escape-canceled:l1 ~rabsum-ravtyd ~rigred))
:: escape.net:(~(got by points.state) ~rabsum-ravtyd)
::
++ test-rut-l1-cancel-2
:: L1-cancel A1 | A1 | * | * | * | -> | ~ | ~ | * | *
%+ expect-eq
!> ~
::
!>
=| =^state:naive
=^ f state (init-rut-full state)
=^ f state (n state (escape-requested:l1 ~rabsum-ravtyd ~rigred))
=^ f state (n state (escape-canceled:l1 ~rabsum-ravtyd ~rigred))
escape.net:(~(got by points.state) ~rabsum-ravtyd)
::
++ test-rut-l1-adopt-1
:: L1-adopt A1 | A1 | * | * | * | -> | ~ | ~ | A1 | A2
%+ expect-eq
!> [~ %.y ~rigred]
::
!>
=| =^state:naive
=^ f state (init-rut-full state)
=^ f state (n state (escape-requested:l1 ~rabsum-ravtyd ~rigred))
=^ f state (n state (escape-accepted:l1 ~rabsum-ravtyd ~rigred))
[escape.net sponsor.net]:(~(got by points.state) ~rabsum-ravtyd)
::
:: These commented out tests fail, but it is because L1 adopt is only
:: accepted if the ecliptic.sol allows it. So these rows of the table
:: cannot be tested here.
::
:: ++ test-rut-l1-adopt-2
:: :: L1-adopt A1 | ~ | * | * | * | -> !! :: no adopt if not escaping
:: %+ expect-eq
:: !> [~ %.y ~holrut]
:: ::
:: !>
:: =| =^state:naive
:: =^ f state (init-rut-full state)
:: =^ f state (n state (escape-accepted:l1 ~rabsum-ravtyd ~rigred))
:: [escape.net sponsor.net]:(~(got by points.state) ~rabsum-ravtyd)
:: ::
:: ++ test-rut-l1-adopt-3
:: :: L1-adopt A1 | A2 | * | * | * | -> !! :: no adopt if not escaping
:: %+ expect-eq
:: !> [[~ ~rigrut] %.y ~holrut]
:: ::
:: !>
:: =| =^state:naive
:: =^ f state (init-rut-full state)
:: =^ f state (n state (escape-requested:l1 ~rabsum-ravtyd ~rigrut))
:: =^ f state (n state (escape-accepted:l1 ~rabsum-ravtyd ~rigred))
:: [escape.net sponsor.net]:(~(got by points.state) ~rabsum-ravtyd)
::
++ test-marbud-l2-change-keys-whole-state ^- tang
=/ new-keys [%configure-keys encr auth suit |]
=| =^state:naive
=^ f state (init-marbud state)
=/ marbud-point (~(got by points.state) ~marbud)
=/ new-marbud marbud-point(keys.net [1 suit auth encr], nonce.owner.own 1)
::
%+ expect-eq
!> state(points (~(put by points.state) ~marbud new-marbud))
::
!>
=^ f state (n state %bat q:(gen-tx 0 [marbud-own new-keys] %marbud-key-0))
state
::
:: old tests. Some of these test the same things as +test-rut but
:: they've been left in since the circumstances are slightly different
:: in a way that ought to be unimportant but you never know.
::
++ test-log ^- tang
%+ expect-eq
!>
:- [%point ~bud %owner (addr %bud-key-0)]~
:_ [~ ~] :_ [~ ~]
:- ~bud
%*(. *point:naive dominion %l1, owner.own (addr %bud-key-0)^0, who.sponsor.net ~bud)
::
!>
%^ naive verifier 1.337 :- *^state:naive
:* %log *@ux *@ux
owner-changed:log-names:naive (@ux ~bud) (addr %bud-key-0) ~
==
::
++ test-deposit ^- tang
%+ expect-eq
!> %l2
::
!>
=| =^state:naive
=^ f state (init-marbud state)
dominion:(~(got by points.state) ~marbud)
::
++ test-transfer-batch ^- tang
=/ marbud-transfer [0 [marbud-own %transfer-point (addr %marbud-key-0) |] %marbud-key-0]
=/ marbud-transfer-2 [1 [marbud-own %transfer-point (addr %marbud-key-1) |] %marbud-key-0]
::
=, l2-event-gen
=/ marbud-batch=tx-list (limo marbud-transfer marbud-transfer-2 ~)
::
;: weld
%+ expect-eq
!> [(addr %marbud-key-1) 2]
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state %bat q:(gen-tx marbud-transfer))
=^ f state (n state %bat q:(gen-tx marbud-transfer-2))
owner.own:(~(got by points.state) ~marbud)
::
%+ expect-eq
!> [(addr %marbud-key-1) 2]
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state %bat (tx-list-to-batch marbud-batch))
owner.own:(~(got by points.state) ~marbud)
==
::
++ test-l1-changed-spawn-proxy ^- tang
%+ expect-eq
!> [(addr %bud-skey) 0]
::
!>
=| =^state:naive
=^ f state (init-bud state)
=^ f state (n state (changed-spawn-proxy:l1 ~bud (addr %bud-skey)))
spawn-proxy.own:(~(got by points.state) ~bud)
::
++ test-l1-changed-transfer-proxy ^- tang
%+ expect-eq
!> [(addr %bud-key-1) 0]
::
!>
=| =^state:naive
=^ f state (init-bud state)
=^ f state (n state (changed-transfer-proxy:l1 ~bud (addr %bud-key-1)))
transfer-proxy.own:(~(got by points.state) ~bud)
::
++ test-l1-changed-management-proxy ^- tang
%+ expect-eq
!> [(addr %bud-mkey) 0]
::
!>
=| =^state:naive
=^ f state (init-bud state)
=^ f state (n state (changed-management-proxy:l1 ~bud (addr %bud-mkey)))
management-proxy.own:(~(got by points.state) ~bud)
::
++ test-l1-changed-voting-proxy ^- tang
%+ expect-eq
!> [(addr %bud-vkey) 0]
::
!>
=| =^state:naive
=^ f state (init-bud state)
=^ f state (n state (changed-voting-proxy:l1 ~bud (addr %bud-vkey)))
voting-proxy.own:(~(got by points.state) ~bud)
::
++ test-l1-changed-keys ^- tang
=/ life 1
=/ new-keys [~bud suit encr auth life]
::
%+ expect-eq
!> [suit auth encr]
::
!>
=| =^state:naive
=^ f state (init-bud state)
=^ f state (n state (changed-keys:l1 new-keys))
|1:keys.net:(~(got by points.state) ~bud)
::
++ test-l1-star-escape-requested ^- tang
%+ expect-eq
!> [~ ~wes]
::
!>
=| =^state:naive
=^ f state (init-wes state)
=^ f state (init-sambud state)
=^ f state (n state (escape-requested:l1 ~sambud ~wes))
escape.net:(~(got by points.state) ~sambud)
::
++ test-l1-star-escape-canceled ^- tang
%+ expect-eq
!> ~
::
!>
=| =^state:naive
=^ f state (init-wes state)
=^ f state (init-sambud state)
=^ f state (n state (escape-requested:l1 ~sambud ~wes))
=^ f state (n state (escape-canceled:l1 ~sambud ~wes))
escape.net:(~(got by points.state) ~sambud)
::
++ test-l1-star-adopt-accept ^- tang
%+ expect-eq
!> [~ %.y ~wes]
::
!>
=| =^state:naive
=^ f state (init-wes state)
=^ f state (init-sambud state)
=^ f state (n state (escape-requested:l1 ~sambud ~wes))
=^ f state (n state (escape-accepted:l1 ~sambud ~wes))
[escape.net sponsor.net]:(~(got by points.state) ~sambud)
::
++ test-l1-star-lost-sponsor ^- tang
%+ expect-eq
!> [~ %.n ~bud]
::
!>
=| =^state:naive
=^ f state (init-sambud state)
=^ f state (n state (lost-sponsor:l1 ~sambud ~bud))
[escape.net sponsor.net]:(~(got by points.state) ~sambud)
::
++ test-l2-set-spawn-proxy ^- tang
=/ marbud-sproxy [marbud-own %set-spawn-proxy (addr %marbud-skey)]
::
%+ expect-eq
!> [(addr %marbud-skey) 0]
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state %bat q:(gen-tx 0 marbud-sproxy %marbud-key-0))
spawn-proxy.own:(~(got by points.state) ~marbud)
::
++ test-l2-set-transfer-proxy ^- tang
=/ marbud-tproxy [marbud-own %set-transfer-proxy (addr %marbud-tkey)]
::
%+ expect-eq
!> [(addr %marbud-tkey) 0]
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state %bat q:(gen-tx 0 marbud-tproxy %marbud-key-0))
transfer-proxy.own:(~(got by points.state) ~marbud)
::
++ test-l2-set-management-proxy ^- tang
=/ marbud-mproxy [marbud-own %set-management-proxy (addr %marbud-mkey)]
::
%+ expect-eq
!> [(addr %marbud-mkey) 0]
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state %bat q:(gen-tx 0 marbud-mproxy %marbud-key-0))
management-proxy.own:(~(got by points.state) ~marbud)
::
++ test-l2-dopbud-spawn-proxy-deposit ^- tang
%+ expect-eq
!> %spawn
::
!>
=| =^state:naive
=^ f state (init-dopbud state)
dominion:(~(got by points.state) ~dopbud)
::
++ test-l2-sambud-spawn-proxy-predeposit ^- tang
%+ expect-eq
!> [(addr %sambud-skey) 0]
::
!>
=| =^state:naive
=^ f state (init-sambud state)
=^ f state (n state (changed-spawn-proxy:l1 ~sambud (addr %sambud-skey)))
=^ f state (n state (changed-spawn-proxy:l1 ~sambud deposit-address:naive))
spawn-proxy.own:(~(got by points.state) ~sambud)
::
++ test-l2-sambud-own-spawn-proxy-postdeposit ^- tang
=/ sambud-sproxy [[~sambud %own] %set-spawn-proxy (addr %sambud-skey-0)]
%+ expect-eq
!> [(addr %sambud-skey-0) 0]
::
!>
=| =^state:naive
=^ f state (init-sambud state)
=^ f state (n state (changed-spawn-proxy:l1 ~sambud deposit-address:naive))
=^ f state (n state %bat q:(gen-tx 0 sambud-sproxy %sambud-key-0))
spawn-proxy.own:(~(got by points.state) ~sambud)
::
++ test-l2-sambud-spawn-spawn-proxy-postdeposit ^- tang
=/ sambud-sproxy [[~sambud %spawn] %set-spawn-proxy (addr %sambud-skey-1)]
%+ expect-eq
!> [(addr %sambud-skey-1) 1]
::
!>
=| =^state:naive
=^ f state (init-sambud state)
=^ f state (n state (changed-spawn-proxy:l1 ~sambud (addr %sambud-skey-0)))
=^ f state (n state (changed-spawn-proxy:l1 ~sambud deposit-address:naive))
=^ f state (n state %bat q:(gen-tx 0 sambud-sproxy %sambud-skey-0))
spawn-proxy.own:(~(got by points.state) ~sambud)
::
++ test-l2-sambud-spawn-proxy-predeposit-spawn ^- tang
=/ lf-spawn [[~sambud %spawn] %spawn ~lisdur-fodrys (addr %lf-key-0)]
%+ expect-eq
!> [`@ux`(addr %lf-key-0) 0]
::
!>
=| =^state:naive
=^ f state (init-sambud state)
=^ f state (n state (changed-spawn-proxy:l1 ~sambud (addr %sambud-skey)))
=^ f state (n state (changed-spawn-proxy:l1 ~sambud deposit-address:naive))
=^ f state (n state %bat q:(gen-tx 0 lf-spawn %sambud-skey))
transfer-proxy.own:(~(got by points.state) ~lisdur-fodrys)
::
++ test-linnup-torsyx-spawn ^- tang
:: try to spawn a L2 planet with a L2 planet
:: this test is deprecated, covered by +test-rut
=/ rt-spawn [lt-own %spawn ~radres-tinnyl (addr %rt-key-0)]
=/ lt-spawn [marbud-own %spawn ~linnup-torsyx (addr %lt-key-0)]
=/ lt-transfer-yes-breach [lt-xfr %transfer-point (addr %lt-key-0) &]
::
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (init-litbud state)
=^ f state (n state %bat q:(gen-tx 0 lt-spawn %marbud-key-0))
=^ f state (n state %bat q:(gen-tx 0 lt-transfer-yes-breach %lt-key-0))
=/ lt-point (~(got by points.state) ~linnup-torsyx)
=/ new-lt lt-point(nonce.owner.own 1)
=/ no-op-state state(points (~(put by points.state) ~linnup-torsyx new-lt))
::
%+ expect-eq
!> no-op-state
::
!>
=^ f state (n state %bat q:(gen-tx 0 rt-spawn %lt-key-0))
state
::
++ test-marbud-l2-spawn ^- tang
=/ marbud-sproxy [0 [marbud-own %set-spawn-proxy (addr %marbud-skey)] %marbud-key-0]
=/ lt-spawn [%spawn ~linnup-torsyx (addr %lt-key-0)]
=, l2-event-gen
=/ spawn-batch=tx-list (limo marbud-sproxy [0 [marbud-spn lt-spawn] %marbud-skey] ~)
::
;: weld
%+ expect-eq
:: Tests l2 spawning with ownership
!> [`@ux`(addr %lt-key-0) 0]
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state %bat q:(gen-tx 0 [marbud-own lt-spawn] %marbud-key-0))
transfer-proxy.own:(~(got by points.state) ~linnup-torsyx)
::
%+ expect-eq
:: Tests l2 spawning with spawn proxy
!> [`@ux`(addr %lt-key-0) 0]
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state %bat q:(gen-tx marbud-sproxy))
=^ f state (n state %bat q:(gen-tx 0 [marbud-spn lt-spawn] %marbud-skey))
transfer-proxy.own:(~(got by points.state) ~linnup-torsyx)
::
%+ expect-eq
:: Tests l2 spawning with spawn proxy as a batch
!> [`@ux`(addr %lt-key-0) 0]
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state %bat (tx-list-to-batch spawn-batch))
transfer-proxy.own:(~(got by points.state) ~linnup-torsyx)
==
::
++ test-marbud-l2-double-spawn ^- tang
:: Attempts to spawn the same planet twice, once with ownership and once with spawn proxy
=/ marbud-sproxy [marbud-own %set-spawn-proxy (addr %marbud-skey)]
=/ lt-spawn-0 [marbud-own %spawn ~linnup-torsyx (addr %lt-key-0)]
=/ lt-spawn-1 [marbud-spn %spawn ~linnup-torsyx (addr %lt-key-1)]
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state %bat q:(gen-tx 0 marbud-sproxy %marbud-key-0))
=^ f state (n state %bat q:(gen-tx 1 lt-spawn-0 %marbud-key-0))
=/ marbud-point (~(got by points.state) ~marbud)
=/ new-marbud marbud-point(nonce.spawn-proxy.own 1)
=/ no-op-state state(points (~(put by points.state) ~marbud new-marbud))
::
%+ expect-eq
!> no-op-state
::
!>
=^ f state (n state %bat q:(gen-tx 0 lt-spawn-1 %marbud-skey))
state
::
++ test-marbud-l2-change-keys ^- tang
=/ new-keys [%configure-keys encr auth suit |]
=/ marbud-mproxy [marbud-own %set-management-proxy (addr %marbud-mkey)]
::
;: weld
%+ expect-eq
!> [suit auth encr]
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state %bat q:(gen-tx 0 [marbud-own new-keys] %marbud-key-0))
|1:keys.net:(~(got by points.state) ~marbud)
::
%+ expect-eq
!> [suit auth encr]
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state %bat q:(gen-tx 0 marbud-mproxy %marbud-key-0))
=^ f state (n state %bat q:(gen-tx 0 [marbud-mgt new-keys] %marbud-mkey))
|1:keys.net:(~(got by points.state) ~marbud)
::
==
::
++ test-marbud-l2-proxies-transfer ^- tang
=/ marbud-new-keys [0 [marbud-own %configure-keys encr auth suit |] %marbud-key-0]
=/ marbud-sproxy [0 [marbud-own %set-spawn-proxy (addr %marbud-skey)] %marbud-key-0]
=/ marbud-mproxy [1 [marbud-own %set-management-proxy (addr %marbud-mkey)] %marbud-key-0]
=/ marbud-tproxy [2 [marbud-own %set-transfer-proxy (addr %marbud-key-1)] %marbud-key-0]
=/ marbud-transfer-breach [1 [marbud-own %transfer-point (addr %marbud-key-1) &] %marbud-key-0]
=/ marbud-transfer-no-breach [1 [marbud-own %transfer-point (addr %marbud-key-1) |] %marbud-key-0]
=/ marbud-xfr-breach [0 [marbud-xfr %transfer-point (addr %marbud-key-1) &] %marbud-key-1]
=/ marbud-xfr-no-breach [0 [marbud-xfr %transfer-point (addr %marbud-key-1) |] %marbud-key-1]
::
=, l2-event-gen
=/ test1=tx-list (limo marbud-sproxy marbud-mproxy marbud-tproxy marbud-xfr-breach ~)
=/ test2=tx-list (limo marbud-new-keys marbud-transfer-breach ~)
=/ test3=tx-list (limo marbud-sproxy marbud-mproxy marbud-tproxy marbud-xfr-no-breach ~)
=/ test4=tx-list (limo marbud-new-keys marbud-transfer-no-breach ~)
::
;: weld
%+ expect-eq
:: Tests that proxies are reset on transfer with breach
::
!>
:* [(addr %marbud-key-1) 3] :: ownership
[0 0] :: spawn-proxy
[0 0] :: management-proxy
[0 0] :: voting-proxy
[0 1] :: transfer-proxy
==
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state %bat q:(gen-tx marbud-sproxy))
=^ f state (n state %bat q:(gen-tx marbud-mproxy))
=^ f state (n state %bat q:(gen-tx marbud-tproxy))
=^ f state (n state %bat q:(gen-tx marbud-xfr-breach))
^- [[@ @] [@ @] [@ @] [@ @] [@ @]]
own:(~(got by points.state) ~marbud)
::
%+ expect-eq
:: batch version
::
!>
:* [(addr %marbud-key-1) 3] :: ownership
[0 0] :: spawn-proxy
[0 0] :: management-proxy
[0 0] :: voting-proxy
[0 1] :: transfer-proxy
==
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state %bat (tx-list-to-batch test1))
^- [[@ @] [@ @] [@ @] [@ @] [@ @]]
own:(~(got by points.state) ~marbud)
::
%+ expect-eq
:: Tests that networking keys are reset on transfer with breach
!>
[0 0 0]
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state %bat q:(gen-tx marbud-new-keys))
=^ f state (n state %bat q:(gen-tx marbud-transfer-breach))
|1:keys.net:(~(got by points.state) ~marbud)
::
%+ expect-eq
:: batch version
!>
[0 0 0]
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state %bat (tx-list-to-batch test2))
|1:keys.net:(~(got by points.state) ~marbud)
::
%+ expect-eq
:: Tests that proxies are not reset when transfering without breach
!>
:* [(addr %marbud-key-1) 3] :: ownership
[(addr %marbud-skey) 0] :: spawn-proxy
[(addr %marbud-mkey) 0] :: management-proxy
[0 0] :: voting-proxy
[0 1] :: transfer-proxy
==
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state %bat q:(gen-tx marbud-sproxy))
=^ f state (n state %bat q:(gen-tx marbud-mproxy))
=^ f state (n state %bat q:(gen-tx marbud-tproxy))
=^ f state (n state %bat q:(gen-tx marbud-xfr-no-breach))
^- [[@ @] [@ @] [@ @] [@ @] [@ @]]
own:(~(got by points.state) ~marbud)
::
%+ expect-eq
:: batch version
!>
:* [(addr %marbud-key-1) 3] :: ownership
[(addr %marbud-skey) 0] :: spawn-proxy
[(addr %marbud-mkey) 0] :: management-proxy
[0 0] :: voting-proxy
[0 1] :: transfer-proxy
==
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state %bat (tx-list-to-batch test3))
^- [[@ @] [@ @] [@ @] [@ @] [@ @]]
own:(~(got by points.state) ~marbud)
::
%+ expect-eq
:: Tests that networking keys are not reset when transfering without breach
!>
[suit auth encr]
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state %bat q:(gen-tx marbud-new-keys))
=^ f state (n state %bat q:(gen-tx marbud-transfer-no-breach))
|1:keys.net:(~(got by points.state) ~marbud)
::
%+ expect-eq
:: batch version
!>
[suit auth encr]
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state %bat (tx-list-to-batch test4))
|1:keys.net:(~(got by points.state) ~marbud)
==
::
:: TODO: life+rift changes via transfer proxy
::
++ test-marbud-life-rift ^- tang
=/ new-keys-no-reset [marbud-own %configure-keys encr auth suit |]
=/ new-keys-yes-reset [marbud-own %configure-keys encr auth suit &]
=/ zero-keys-no-reset [marbud-own %configure-keys 0 0 0 |]
=/ zero-keys-yes-reset [marbud-own %configure-keys 0 0 0 &]
=/ marbud-transfer-no-breach [marbud-own %transfer-point (addr %marbud-key-1) |]
=/ marbud-transfer-yes-breach [marbud-own %transfer-point (addr %marbud-key-1) &]
=/ marbud-own-1 [~marbud %marbud-key-1 %own]
::
;: weld
%+ expect-eq
:: breach=%.n
!> [0 1] :: [rift life]
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state %bat q:(gen-tx 0 new-keys-no-reset %marbud-key-0))
=^ f state (n state %bat q:(gen-tx 1 new-keys-no-reset %marbud-key-0))
[rift.net life.keys.net]:(~(got by points.state) ~marbud)
::
%+ expect-eq
:: breach=%.y
!> [1 1]
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state %bat q:(gen-tx 0 new-keys-yes-reset %marbud-key-0))
[rift.net life.keys.net]:(~(got by points.state) ~marbud)
::
%+ expect-eq
:: networking keys set incremenets life, reset=%.y
:: then zero keys and transfer, should increment rift but not life
::
!> [2 2]
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state %bat q:(gen-tx 0 new-keys-yes-reset %marbud-key-0)) :: inc life and rift
=^ f state (n state %bat q:(gen-tx 1 zero-keys-no-reset %marbud-key-0)) :: inc life
=^ f state (n state %bat q:(gen-tx 2 zero-keys-yes-reset %marbud-key-0)) :: inc rift
[rift.net life.keys.net]:(~(got by points.state) ~marbud)
::
%+ expect-eq
:: Keep the same keys while breaching via %configure-keys
::
!> [2 1]
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state %bat q:(gen-tx 0 new-keys-yes-reset %marbud-key-0)) :: inc life and rift
=^ f state (n state %bat q:(gen-tx 1 new-keys-yes-reset %marbud-key-0)) :: inc life and rift
[rift.net life.keys.net]:(~(got by points.state) ~marbud)
::
%+ expect-eq
::
!> [1 2]
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state %bat q:(gen-tx 0 new-keys-no-reset %marbud-key-0))
=^ f state (n state %bat q:(gen-tx 1 marbud-transfer-no-breach %marbud-key-0))
=^ f state (n state %bat q:(gen-tx 2 zero-keys-yes-reset %marbud-key-1))
[rift.net life.keys.net]:(~(got by points.state) ~marbud)
::
%+ expect-eq
:: set networking keys, then transfer and set networking keys with breach
::
!> [1 3]
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state %bat q:(gen-tx 0 new-keys-no-reset %marbud-key-0)) :: inc life
=^ f state (n state %bat q:(gen-tx 1 marbud-transfer-yes-breach %marbud-key-0)) :: inc life and rift
=^ f state (n state %bat q:(gen-tx 2 new-keys-no-reset %marbud-key-1)) ::inc life
[rift.net life.keys.net]:(~(got by points.state) ~marbud)
::
%+ expect-eq
:: networking keys set incremenets life, reset=%.y
:: then zero keys and transfer, should increment rift but not life
::
!> [2 2]
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state %bat q:(gen-tx 0 new-keys-yes-reset %marbud-key-0)) :: inc life and rift
=^ f state (n state %bat q:(gen-tx 1 zero-keys-no-reset %marbud-key-0)) :: inc life
=^ f state (n state %bat q:(gen-tx 2 marbud-transfer-yes-breach %marbud-key-0)) :: inc rift
[rift.net life.keys.net]:(~(got by points.state) ~marbud)
::
==
::
++ test-dopbud-l2-spawn ^- tang
=/ pp-spawn [dopbud-own %spawn ~palsep-picdun (addr %pp-key-0)]
::
%+ expect-eq
!> [`@ux`(addr %pp-key-0) 0]
::
!>
=| =^state:naive
=^ f state (init-dopbud state)
=^ f state (n state %bat q:(gen-tx 0 pp-spawn %dopbud-key-0))
transfer-proxy.own:(~(got by points.state) ~palsep-picdun)
::
++ test-dopbud-l2-spawn-after-transfer ^- tang
=/ pp-spawn [dopbud-own %spawn ~palsep-picdun (addr %pp-key-0)]
=/ lr-spawn [dopbud-own %spawn ~laclur-rachul (addr %lr-key-0)]
::
%+ expect-eq
!> [`@ux`(addr %lr-key-0) 0]
::
!>
=| =^state:naive
=^ f state (init-dopbud state)
=^ f state (n state %bat q:(gen-tx 0 pp-spawn %dopbud-key-0))
=^ f state (n state (owner-changed:l1 ~dopbud (addr %dopbud-key-1)))
=^ f state (n state %bat q:(gen-tx 1 lr-spawn %dopbud-key-1))
transfer-proxy.own:(~(got by points.state) ~laclur-rachul)
::
++ test-linnup-torsyx-l2-transfer-ownership ^- tang
=/ lt-spawn [marbud-own %spawn ~linnup-torsyx (addr %lt-key-0)]
=/ lt-transfer-yes-breach [%transfer-point (addr %lt-key-0) &]
::
%+ expect-eq
!> [`@ux`(addr %lt-key-0) 0]
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state %bat q:(gen-tx 0 lt-spawn %marbud-key-0))
=^ f state (n state %bat q:(gen-tx 0 [lt-xfr lt-transfer-yes-breach] %lt-key-0))
owner.own:(~(got by points.state) ~linnup-torsyx)
::
++ test-palsep-picdun-l2-transfer-ownership ^- tang
=/ pp-xfr [~palsep-picdun %transfer]
=/ pp-spawn [dopbud-own %spawn ~palsep-picdun (addr %pp-key-0)]
=/ pp-transfer-yes-breach [pp-xfr %transfer-point (addr %pp-key-0) &]
%+ expect-eq
!> [`@ux`(addr %pp-key-0) 0]
::
!>
=| =^state:naive
=^ f state (init-dopbud state)
=^ f state (n state %bat q:(gen-tx 0 pp-spawn %dopbud-key-0))
=^ f state (n state %bat q:(gen-tx 0 pp-transfer-yes-breach %pp-key-0))
owner.own:(~(got by points.state) ~palsep-picdun)
::
++ test-linnup-torsyx-l2-escape-request ^- tang
=/ lt-spawn [marbud-own %spawn ~linnup-torsyx (addr %lt-key-0)]
=/ lt-transfer-yes-breach [lt-xfr %transfer-point (addr %lt-key-0) &]
::
%+ expect-eq
!> [~ ~litbud]
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (init-litbud state)
=^ f state (n state %bat q:(gen-tx 0 lt-spawn %marbud-key-0))
=^ f state (n state %bat q:(gen-tx 0 lt-transfer-yes-breach %lt-key-0))
=^ f state (n state %bat q:(gen-tx 0 [lt-own [%escape ~litbud]] %lt-key-0))
escape.net:(~(got by points.state) ~linnup-torsyx)
::
++ test-linnup-torsyx-l2-cancel-escape-request ^- tang
=/ lt-spawn [marbud-own %spawn ~linnup-torsyx (addr %lt-key-0)]
=/ lt-transfer-yes-breach [lt-xfr %transfer-point (addr %lt-key-0) &]
::
%+ expect-eq
!> ~
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (init-litbud state)
=^ f state (n state %bat q:(gen-tx 0 lt-spawn %marbud-key-0))
=^ f state (n state %bat q:(gen-tx 0 lt-transfer-yes-breach %lt-key-0))
=^ f state (n state %bat q:(gen-tx 0 [lt-own [%escape ~litbud]] %lt-key-0))
=^ f state (n state %bat q:(gen-tx 1 [lt-own [%cancel-escape ~litbud]] %lt-key-0))
escape.net:(~(got by points.state) ~linnup-torsyx)
::
++ test-linnup-torsyx-l2-adopt-accept ^- tang
=/ lt-spawn [marbud-own %spawn ~linnup-torsyx (addr %lt-key-0)]
=/ lt-transfer-yes-breach [lt-xfr %transfer-point (addr %lt-key-0) &]
::
%+ expect-eq
!> [~ %.y ~litbud]
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (init-litbud state)
=^ f state (n state %bat q:(gen-tx 0 lt-spawn %marbud-key-0))
=^ f state (n state %bat q:(gen-tx 0 lt-transfer-yes-breach %lt-key-0))
=^ f state (n state %bat q:(gen-tx 0 [lt-own [%escape ~litbud]] %lt-key-0))
=^ f state (n state %bat q:(gen-tx 0 [litbud-own [%adopt ~linnup-torsyx]] %litbud-key-0))
[escape.net sponsor.net]:(~(got by points.state) ~linnup-torsyx)
::
++ test-linnup-torsyx-l2-adopt-reject ^- tang
=/ lt-spawn [marbud-own %spawn ~linnup-torsyx (addr %lt-key-0)]
=/ lt-transfer-yes-breach [lt-xfr %transfer-point (addr %lt-key-0) &]
::
%+ expect-eq
!> ~
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (init-litbud state)
=^ f state (n state %bat q:(gen-tx 0 lt-spawn %marbud-key-0))
=^ f state (n state %bat q:(gen-tx 0 lt-transfer-yes-breach %lt-key-0))
=^ f state (n state %bat q:(gen-tx 0 [lt-own [%escape ~litbud]] %lt-key-0))
=^ f state (n state %bat q:(gen-tx 0 [litbud-own [%reject ~linnup-torsyx]] %litbud-key-0))
escape.net:(~(got by points.state) ~linnup-torsyx)
::
++ test-linnup-torsyx-l2-detach ^- tang
=/ lt-spawn [marbud-own %spawn ~linnup-torsyx (addr %lt-key-0)]
=/ lt-transfer-yes-breach [lt-xfr %transfer-point (addr %lt-key-0) &]
::
%+ expect-eq
!> [~ %.n ~marbud]
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (init-litbud state)
=^ f state (n state %bat q:(gen-tx 0 lt-spawn %marbud-key-0))
=^ f state (n state %bat q:(gen-tx 0 lt-transfer-yes-breach %lt-key-0))
=^ f state (n state %bat q:(gen-tx 1 [marbud-own [%detach ~linnup-torsyx]] %marbud-key-0))
[escape.net sponsor.net]:(~(got by points.state) ~linnup-torsyx)
::
:: Fuzz tests. These just feed the L2 contract various forms of garbage. None of them
:: should alter the state of the PKI.
::
++ test-fuzz-octs
:: this test just throws completely random octs at naive.hoon
::
=+ [seed=`@`%test-fuzz-octs i=0]
=| =^state:naive
=^ f state (init-red-full state)
=/ init-state state
|- ^- tang
?: =(i 10.000) ~
%+ weld $(seed (shas `@`%versace seed), i +(i))
=/ state init-state
=/ rng ~(. og seed)
=^ proxy rng (raws:rng 8)
=^ ship rng (raws:rng 32)
=^ action rng (raws:rng 8)
=^ junk-length rng (rads:rng 200)
:: increment junk-length to prevent 0 case
=^ junk rng (raws:rng +(junk-length))
=^ nonce rng (rads:rng 999)
=^ key rng (raws:rng 256)
=/ fuzz=octs
%: cad:naive 3
1^proxy
4^ship
1^action
(met 3 junk)^junk
~
==
=/ random-tx
%^ sign-tx key nonce fuzz
::
%+ expect-eq
!> init-state
:: ::
!>
=^ f state (n state %bat q:random-tx)
state
::
++ test-fuzz-valid-ship-key
:: this test uses a valid ship and key but otherwise
:: hands the contract garbage
::
=+ [seed=`@`%test-fuzz-valid-ship-key i=0]
=| =^state:naive
=^ f state (init-red-full state)
=/ init-state state
|- ^- tang
?: =(i 100) ~
%+ weld $(seed (shas `@`%iceberg-simpson seed), i +(i))
=/ state init-state
=/ rng ~(. og seed)
=/ ship ~pinpun-pilsun
=^ proxy rng (raws:rng 8)
=^ action rng (raws:rng 8)
=^ junk-length rng (rads:rng 200)
:: increment junk-length to prevent 0 case
=^ junk rng (raws:rng +(junk-length))
=^ nonce rng (rads:rng 999)
=/ fuzz=octs
%: cad:naive 3
1^proxy
4^ship
1^action
(met 3 junk)^junk
~
==
=/ random-tx
%^ sign-tx %losrut-pp-key-0 nonce fuzz
::
%+ expect-eq
!> init-state
:: ::
!>
=^ f state (n state %bat q:random-tx)
state
::
++ test-fuzz-valid-ship-key-proxy-nonce
:: this test uses a valid ship, key, proxy, nonce but otherwise
:: hands the contract garbage
::
=+ [seed=`@`%test-fuzz-valid-ship-key-proxy-nonce i=0]
=| =^state:naive
=^ f state (init-red-full state)
=/ init-state state
|- ^- tang
?: =(i 100) ~
%+ weld $(seed (shas `@`%tiptoe seed), i +(i))
=/ state init-state
=/ rng ~(. og seed)
=/ ship=@p ~pinpun-pilsun
=^ action rng (raws:rng 8)
=^ junk-length rng (rads:rng 200)
:: increment junk-length to prevent case of 0
=^ junk rng (raws:rng +(junk-length))
=/ fuzz=octs
%: cad:naive 3
1^(can 0 3^%0 5^0 ~) :: %own proxy
4^ship
1^action
(met 3 junk)^junk
~
==
=/ random-tx
%^ sign-tx %losrut-pp-key-0 1 fuzz
::
%+ expect-eq
!> init-state
::
!>
=^ f state (n state %bat q:random-tx)
state
::
++ test-fuzz-after-tx
:: this creates a valid transaction of each type but then adds
:: random bits to the end of it
::
=+ [seed=`@`%test-fuzz-after-tx i=0]
=| =^state:naive
=^ f state (init-red-full state)
=/ init-state state
|- ^- tang
?: =(i 11) ~ :: 10 attempts for each transaction type
%+ weld $(seed (shas `@`%howmuchisfour seed), i +(i))
=+ j=0
|^ ^- tang
?: =(j 11) ~ :: there are 10 transaction types
%+ weld $(seed (shas `@`%eris seed), j +(j))
=/ rng ~(. og seed)
=^ junk-length rng (rads:rng 200)
::increment to prevent zero-length junk
=^ junk rng (raws:rng +(junk-length))
=/ tx-octs=octs
?+ j !!
%0 do-spawn
%1 do-transfer-point
%2 do-configure-keys
%3 do-escape
%4 do-cancel-escape
%5 do-adopt
%6 do-reject
%7 do-detach
%8 do-set-management-proxy
%9 do-set-spawn-proxy
%10 do-set-transfer-proxy
==
=/ fuzz (mix (lsh [3 (met 3 q:tx-octs)] junk) q:tx-octs)
=/ fuzz-octs=octs [(met 3 fuzz) fuzz]
:: the conditionals that follow are to ensure the correct key and
:: nonce are used.
=/ random-tx
?: =(j 4)
%^ sign-tx %holrut-rr-key-0 1 fuzz-octs
?: |(=(j 5) =(j 6))
%^ sign-tx %rigred-key-0 0 fuzz-octs
%^ sign-tx %losrut-key-0 2 fuzz-octs
::
=/ state init-state
%+ expect-eq
!> init-state
::
!>
=^ f state (n state %bat q:random-tx)
state
::
++ do-spawn ^- octs
=/ from [ship=~losrut proxy=%own]
=/ sptx=skim-tx:naive [%spawn ~mishus-loplus (addr %nowhere)]
=/ tx=tx:naive [from sptx]
(gen-tx-octs tx)
++ do-transfer-point ^- octs
=/ from [ship=~losrut proxy=%own]
=/ xrtx=skim-tx:naive [%transfer-point (addr %somewhere) &]
=/ tx=tx:naive [from xrtx]
(gen-tx-octs tx)
++ do-configure-keys ^- octs
=/ from [ship=~losrut proxy=%own]
=/ cftx=skim-tx:naive [%configure-keys (shax 'uno') (shax 'dos') (shax 'tres') |]
=/ tx=tx:naive [from cftx]
(gen-tx-octs tx)
++ do-escape ^- octs
=/ from [ship=~losrut proxy=%own]
=/ estx=skim-tx:naive [%escape ~red]
=/ tx=tx:naive [from estx]
(gen-tx-octs tx)
++ do-cancel-escape ^- octs
=/ from [ship=~rabsum-ravtyd proxy=%own]
=/ cetx=skim-tx:naive [%cancel-escape ~rigred]
=/ tx=tx:naive [from cetx]
(gen-tx-octs tx)
++ do-adopt ^- octs
=/ from [ship=~rigred proxy=%own]
=/ adtx=skim-tx:naive [%adopt ~rabsum-ravtyd]
=/ tx=tx:naive [from adtx]
(gen-tx-octs tx)
++ do-reject ^- octs
=/ from [ship=~rigred proxy=%own]
=/ rjtx=skim-tx:naive [%adopt ~rabsum-ravtyd]
=/ tx=tx:naive [from rjtx]
(gen-tx-octs tx)
++ do-detach
=/ from [ship=~losrut proxy=%own]
=/ dttx=skim-tx:naive [%detach ~rabsum-ravtyd]
=/ tx=tx:naive [from dttx]
(gen-tx-octs tx)
++ do-set-management-proxy
=/ from [ship=~losrut proxy=%own]
=/ mgtx=skim-tx:naive [%set-management-proxy (addr %new-mgmt)]
=/ tx=tx:naive [from mgtx]
(gen-tx-octs tx)
++ do-set-spawn-proxy
=/ from [ship=~losrut proxy=%own]
=/ sptx=skim-tx:naive [%set-spawn-proxy (addr %new-spawn)]
=/ tx=tx:naive [from sptx]
(gen-tx-octs tx)
++ do-set-transfer-proxy
=/ from [ship=~losrut proxy=%own]
=/ tftx=skim-tx:naive [%set-transfer-proxy (addr %new-xfer)]
=/ tx=tx:naive [from tftx]
(gen-tx-octs tx)
--
::
:: the following tests are to ensure that padding of zeroes creates
:: no issues
::
++ test-zod-spawn-to-zero
=/ bz-spawn [[~zod %spawn] %spawn ~binzod 0x0]
::
%+ expect-eq
!> [0x0 0]
::
!>
=| =^state:naive
=^ f state (init-zod state)
=^ f state (n state %bat q:(gen-tx 0 bz-spawn %zod-skey-0))
transfer-proxy.own:(~(got by points.state) ~binzod)
::
++ test-zod-spawn-proxy
=/ bz-spawn [[~zod %spawn] %spawn ~binzod (addr %binzod-key-0)]
::
%+ expect-eq
!> [`@ux`(addr %binzod-key-0) 0]
::
!>
=| =^state:naive
=^ f state (init-zod state)
=^ f state (n state %bat q:(gen-tx 0 bz-spawn %zod-skey-0))
transfer-proxy.own:(~(got by points.state) ~binzod)
::
++ test-dopzod-spawn
=/ tm-spawn [[~dopzod %own] %spawn ~tasben-monbur (addr %tm)]
::
%+ expect-eq
!> [`@ux`(addr %tm) 0]
::
!>
=| =^state:naive
=^ f state (init-zod state)
=^ f state (n state %bat q:(gen-tx 0 tm-spawn %dopzod-key-0))
transfer-proxy.own:(~(got by points.state) ~tasben-monbur)
::
++ test-address-padding
:: tells ~dopzod to spawn ~tasben-monbur at 0x00000000001111111111
=/ spawn-octs=octs
%: cad:naive 3
1^(can 0 3^%0 5^0 ~) :: %own proxy
4^~dopzod
1^%1 :: %spawn
4^~tasben-monbur
20^(can 3 10^0 1^1 9^0 ~)
~
==
=/ signed-tx=octs
%^ sign-tx %dopzod-key-0 0 spawn-octs
::
%+ expect-eq
!> [`@ux`(can 3 10^0 1^1 9^0 ~) 0]
::
!>
=| =^state:naive
=^ f state (init-zod state)
=^ f state (n state %bat q:signed-tx)
transfer-proxy.own:(~(got by points.state) ~tasben-monbur)
::
:: TODO: L1 tests with leading zeroes. in particular, changing
:: keys uses data.log, so keys with leading zeroes might run into
:: issues
::
++ test-batch-generation
=, l2-event-gen
=/ marbud-transfer [marbud-own %transfer-point (addr %marbud-key-0) |]
=/ marbud-transfer-2 [marbud-own %transfer-point (addr %marbud-key-1) |]
::
=/ tx-1=full-tx [0 marbud-transfer %marbud-key-0]
=/ tx-2=full-tx [1 marbud-transfer-2 %marbud-key-0]
=/ txs=tx-list (limo ~[tx-1 tx-2])
~& ['tx-1' `@ux`(tx-list-to-batch (limo ~[tx-1]))]
~& ['tx-2' `@ux`(tx-list-to-batch (limo ~[tx-2]))]
~& ['txs' `@ux`(tx-list-to-batch txs)]
%+ expect-eq
!> [(addr %marbud-key-1) 2]
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state %bat (tx-list-to-batch txs))
owner.own:(~(got by points.state) ~marbud)
::
++ test-changed-dns
:: uses actual data from ETH transaction
:: 0x51a26c3b100ad1c7aa8d593068df60465046d437edc3e939fadee4056791fd13
::
=/ data %- crip
;: weld
"0x000000000000000000000000000000"
"00000000000000000000000000000000"
"60000000000000000000000000000000"
"00000000000000000000000000000000"
"a0000000000000000000000000000000"
"00000000000000000000000000000000"
"e0000000000000000000000000000000"
"00000000000000000000000000000000"
"0975726269742e6f7267000000000000"
"00000000000000000000000000000000"
"00000000000000000000000000000000"
"00000000000000000000000000000000"
"0975726269742e6f7267000000000000"
"00000000000000000000000000000000"
"00000000000000000000000000000000"
"00000000000000000000000000000000"
"0975726269742e6f7267000000000000"
"00000000000000000000000000000000"
"00"
==
::
%+ expect-eq
!> `(list @t)`['urbit.org' 'urbit.org' 'urbit.org' ~]
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state (changed-dns:l1 (hex-to-num:ethereum data)))
dns.state
::
++ test-approval-for-all
=| operators=(jug address address)
=/ op1 (~(put ju operators) (addr %test1) (addr %test2))
=/ del1 (~(del ju op1) (addr %test1) (addr %test2))
=/ op2 (~(put ju op1) (addr %test1) (addr %test3))
=/ del2 (~(del ju op2) (addr %test1) (addr %test2))
::
;: weld
%+ expect-eq
!> op1
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state (approval-for-all:l1 (addr %test1) (addr %test2) 1))
operators.state
::
%+ expect-eq
!> del1
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state (approval-for-all:l1 (addr %test1) (addr %test2) 1))
=^ f state (n state (approval-for-all:l1 (addr %test1) (addr %test2) 0))
operators.state
::
%+ expect-eq
!> op2
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state (approval-for-all:l1 (addr %test1) (addr %test2) 1))
=^ f state (n state (approval-for-all:l1 (addr %test1) (addr %test3) 1))
operators.state
::
%+ expect-eq
!> del2
::
!>
=| =^state:naive
=^ f state (init-marbud state)
=^ f state (n state (approval-for-all:l1 (addr %test1) (addr %test2) 1))
=^ f state (n state (approval-for-all:l1 (addr %test1) (addr %test3) 1))
=^ f state (n state (approval-for-all:l1 (addr %test1) (addr %test2) 0))
operators.state
==
::
:: TODO: signature format changed; regenerate
::
:: ++ test-metamask-signature ^- tang
:: =/ meta-owner=address
:: (hex-to-num:ethereum '0xb026b0AA6e686F2386051b31A03E5fB95513e1c0')
:: =/ tx 0x123.0000.0102.0a00.0001.0200
:: =/ sig
:: %- hex-to-num:ethereum
:: :: Must reverse endianness of tx to sign in metamask
:: ::
:: %^ cat 3
:: '0x5b85936ab7b9db8d72416648e6eb1b844a4545ddb7c7c646a74bc3a4fb001a2'
:: '8583bf12ca837b289036a6cc9e6359ed07dda2b87929b5dd7189a3057a395341f1c'
:: ::
:: %+ expect-eq
:: !> [0x123 0]
:: ::
:: !>
:: =| =^state:naive
:: =^ f state (init-marbud state)
:: :: =^ f state (n state %bat q:(transfer-point:l2 0 ~marbud (key ~marbud) %own &))
:: :: =^ f state (n state %bat q:(set-transfer-proxy:l2 1 ~marbud %own 0x123))
:: =^ f state
:: %^ n state %bat
:: q:(transfer-point:l2 0 ~marbud %marbud-key-0 meta-owner %own &)
:: =^ f state (n state %bat (cat 3 sig tx))
:: transfer-proxy.own:(~(got by points.state) ~marbud)
--
Reference in New Issue View Git Blame Copy Permalink