mirror of
https://github.com/ilyakooo0/urbit.git
synced 2024-12-17 11:51:32 +03:00
1536 lines
53 KiB
Plaintext
1536 lines
53 KiB
Plaintext
!: :: /van/jael
|
|
:: :: %reference
|
|
!? 150
|
|
:: ::::
|
|
:::: # 0 :: public structures
|
|
:: ::::
|
|
|= pit/vase
|
|
:: ::::
|
|
:::: # 1 :: private structures
|
|
:: ::::
|
|
=> |%
|
|
++ jael-state :: all crypto state
|
|
$: ver/$0 :: %jael version
|
|
yen/(set duct) :: raw observers
|
|
urb/jael-objective :: all objective state
|
|
sub/jael-subjective :: all subjective state
|
|
== ::
|
|
++ jael-subjective :: urbit metadata
|
|
$: $= car :: secure channels
|
|
%+ map ship :: partner
|
|
$: yen/(set duct) :: trackers
|
|
det/pipe :: channel state
|
|
== ::
|
|
$= rel :: neighborhood
|
|
$: dad/_our :: parent
|
|
cod/farm :: cousins
|
|
pyr/(set ship) :: peers
|
|
kyz/(set ship) :: children
|
|
== ::
|
|
$= bal :: balance sheet
|
|
$: yen/(set duct) :: trackers
|
|
== ::
|
|
$= own :: vault
|
|
$: yen/(set duct) :: trackers
|
|
lyf/life :: version
|
|
jaw/(map life ring) :: private keys
|
|
== ::
|
|
== ::
|
|
++ jael-objective :: objective urbit
|
|
$: pug/farm :: keys
|
|
pry/(map ship (map ship jael-purse)) :: promises
|
|
== ::
|
|
++ jael-remote :: remote notification
|
|
%+ each jael-purse :: addition
|
|
jael-purse :: replacement
|
|
:: ::
|
|
++ jael-balance :: balance sheet
|
|
%+ pair ::
|
|
(map ship jael-purse) :: liabilities
|
|
(map ship jael-purse) :: assets
|
|
:: ::
|
|
++ jael-tally :: balance update
|
|
%+ each jael-balance :: complete
|
|
jael-action :: change
|
|
:: ::
|
|
++ jael-action :: balance change
|
|
%+ pair ship :: partner
|
|
%+ each jael-delta :: %&/liability change
|
|
jael-delta :: %|/asset change
|
|
:: ::
|
|
++ jael-gift :: report
|
|
$? {$veil p/pipe} :: secure channel
|
|
{$vest p/jael-tally} :: balance update
|
|
{$vein p/life q/(map life ring)} :: private keys
|
|
{$vine p/(list jael-edit)} :: raw actions
|
|
== ::
|
|
++ jael-right :: urbit commitment
|
|
$% {$apple p/(map site @)} :: web api key
|
|
{$block $~} :: banned
|
|
{$email p/(set @ta)} :: email addresses
|
|
{$final p/(map ship @pG)} :: ticketed ships
|
|
{$fungi p/(map term @ud)} :: fungibles
|
|
{$guest $~} :: refugee visa
|
|
{$hotel p/pile} :: reserved block
|
|
{$jewel p/(map life ring)} :: private keyring
|
|
{$login p/(set @pG)} :: login secret
|
|
{$pword p/(map site (map @t @t))} :: web passwd by user
|
|
{$token p/(map site (map @t @t))} :: app tokens by user
|
|
{$urban p/(map hand bill)} :: urbit symmetric keys
|
|
== ::
|
|
++ jael-purse :: rights set
|
|
(tree jael-right) ::
|
|
:: ::
|
|
++ jael-delta :: rights change
|
|
$: mor/jael-purse :: grow rights
|
|
les/jael-purse :: lose rights
|
|
== ::
|
|
++ jael-task :: operations on
|
|
$% {$burn p/ship q/jael-purse} :: destroy rights
|
|
{$hail p/ship q/jael-remote} :: remote update
|
|
{$init p/@pG q/arms} :: initialize urbit
|
|
{$meet p/(unit (unit ship)) q/farm} :: integrate pki from
|
|
{$mint p/ship q/jael-purse} :: create rights
|
|
{$move p/ship q/ship r/jael-purse} :: transfer from/to
|
|
{$next p/bull} :: update private key
|
|
{$nuke $~} :: cancel tracker
|
|
{$veil p/ship} :: view secret channel
|
|
{$vein $~} :: view signing keys
|
|
{$vest $~} :: view public balance
|
|
{$vine $~} :: view secret history
|
|
{$west p/ship q/path r/*} :: remote request
|
|
== ::
|
|
++ jael-report-them :: report on neighbor
|
|
$: gur/wyll :: certificate
|
|
lab/jael-purse :: our promises to
|
|
own/jael-purse :: our promises from
|
|
== ::
|
|
++ jael-report-self :: report on self
|
|
$: gur/wyll :: certificate
|
|
war/(map life ring) :: private keys
|
|
== ::
|
|
++ jael-report-cash :: neighbors/assets
|
|
$: has/(map ship jael-purse) ::
|
|
== ::
|
|
++ jael-report-paid :: asset diff
|
|
$: dif/(list (trel ship ? jael-purse)) :: who, +/-, what
|
|
== ::
|
|
++ jael-note :: out request $->
|
|
$% {$x $mess p/ship q/path r/*} :: send message
|
|
== ::
|
|
++ jael-message :: p2p message
|
|
$% {$hail p/jael-purse} :: reset rights
|
|
{$meet p/farm} :: propagate pki
|
|
== ::
|
|
++ jael-grow :: unit of learning
|
|
$% {$sign p/mind q/@} :: add/update signature
|
|
{$step p/cert} :: add whole deed
|
|
== ::
|
|
++ jael-edit :: urbit change
|
|
$% $: $fact :: certificate change
|
|
rex/ship :: owner
|
|
vie/(unit (unit ship)) :: made/heard from
|
|
lyf/life :: deed added/modified
|
|
gan/jael-grow :: info gained
|
|
== ::
|
|
$: $rite :: rights change
|
|
rex/ship :: issuer
|
|
pal/ship :: issued to
|
|
del/jael-delta :: change
|
|
== ::
|
|
== ::
|
|
++ jael-card :: i/o action
|
|
(wind jael-note jael-gift) ::
|
|
:: ::
|
|
++ jael-move :: output
|
|
{p/duct q/jael-card}
|
|
--
|
|
:: ::::
|
|
:::: # 2 :: static data
|
|
:: ::::
|
|
=> |%
|
|
:: :: zeno
|
|
++ zeno :: boot fingerprints
|
|
|= :: who: galaxy (0-255)
|
|
::
|
|
who/ship
|
|
^- pass
|
|
!!
|
|
--
|
|
:: ::::
|
|
:::: # 3 :: stateless functions
|
|
:: ::::
|
|
=> |%
|
|
:: :: ++py
|
|
++ py :: sparse ship set
|
|
|_ pyl/pile
|
|
:: :: ++dif:py
|
|
++ dif :: pyl->lyp, add rem
|
|
|= lyp/pile
|
|
^- (pair pile pile)
|
|
!!
|
|
:: :: ++uni:py
|
|
++ uni :: unify ship sets
|
|
|= lyp/pile
|
|
^- pile
|
|
!!
|
|
--
|
|
:: :: ++ry
|
|
++ ry :: rights algebra
|
|
|_ {lef/jael-right ryt/jael-right}
|
|
::
|
|
:: ++ry: rights algebra
|
|
::
|
|
:: ++ry must always crash when you try to make it
|
|
:: do something that makes no sense.
|
|
::
|
|
:: language compromises: the type system can't enforce
|
|
:: that lef and ryt match, hence the asserts.
|
|
::
|
|
:: :: ++add:ry
|
|
++ add :: lef new, ryt old
|
|
^- jael-right
|
|
?- -.lef
|
|
::
|
|
:: web api key
|
|
:: {$apple p/(map site @)}
|
|
::
|
|
$apple ?> ?=($apple -.ryt)
|
|
:- %apple
|
|
%- (~(uno by p.ryt) p.lef)
|
|
|= (trel site @ @)
|
|
?>(=(q r) r)
|
|
::
|
|
:: banned
|
|
:: {$block $~}
|
|
::
|
|
$block ?> ?=($block -.ryt)
|
|
:- %block
|
|
~
|
|
::
|
|
:: verified email address
|
|
:: {$email p/(set @ta)}
|
|
::
|
|
$email ?> ?=($email -.ryt)
|
|
:- %email
|
|
(~(uni in p.ryt) p.lef)
|
|
::
|
|
:: final ticket
|
|
:: {$final p/(map ship @pG)}
|
|
::
|
|
$final ?> ?=($final -.ryt)
|
|
:- %final
|
|
%- (~(uno by p.ryt) p.lef)
|
|
|= (trel ship @pG @pG)
|
|
?>(=(q r) r)
|
|
::
|
|
:: fungible resources
|
|
:: {$fungi p/(map term @ud)}
|
|
::
|
|
$fungi ?> ?=($fungi -.ryt)
|
|
:- %fungi
|
|
%- (~(uno by p.ryt) p.lef)
|
|
|= (trel term @ud @ud)
|
|
(^add q r)
|
|
::
|
|
:: invited refugee
|
|
:: {$guest $~}
|
|
::
|
|
$guest ?> ?=($guest -.ryt)
|
|
:- %guest
|
|
~
|
|
::
|
|
:: reserved block
|
|
:: {$hotel p/pile}
|
|
::
|
|
$hotel ?> ?=($hotel -.ryt)
|
|
:- %hotel
|
|
(~(uni py p.ryt) p.lef)
|
|
::
|
|
:: private keys
|
|
:: {$jewel p/(map life ring)}
|
|
::
|
|
$jewel ?> ?=($jewel -.ryt)
|
|
:- %jewel
|
|
%- (~(uno by p.ryt) p.lef)
|
|
|= (trel life @ @)
|
|
?>(=(q r) r)
|
|
::
|
|
:: login passcodes
|
|
:: {$login p/(set @pG)}
|
|
::
|
|
$login ?> ?=($login -.ryt)
|
|
:- %login
|
|
(~(uni in p.ryt) p.lef)
|
|
::
|
|
:: web service passwords
|
|
:: {$pword p/(map site (map @t @t))
|
|
::
|
|
$pword ?> ?=($pword -.ryt)
|
|
:- %pword
|
|
%- (~(uno by p.ryt) p.lef)
|
|
|= (trel site (map @t @t) (map @t @t))
|
|
%- (~(uno by q) r)
|
|
|= (trel @t @t @t)
|
|
?>(=(q r) r)
|
|
::
|
|
:: app tokens
|
|
:: {$token p/(map site (map @t @t))}
|
|
::
|
|
$token ?> ?=($token -.ryt)
|
|
:- %token
|
|
%- (~(uno by p.ryt) p.lef)
|
|
|= (trel site (map @t @t) (map @t @t))
|
|
%- (~(uno by q) r)
|
|
|= (trel @t @t @t)
|
|
?>(=(q r) r)
|
|
::
|
|
:: urbit symmetric keys
|
|
:: {$urban p/(map hand bill)}
|
|
::
|
|
$urban ?> ?=($urban -.ryt)
|
|
:- %urban
|
|
%- (~(uno by p.ryt) p.lef)
|
|
|= (trel hand bill bill)
|
|
?>(=(q r) r)
|
|
==
|
|
:: :: ++dif:ry
|
|
++ dif :: r->l: {add remove}
|
|
^- (pair (unit jael-right) (unit jael-right))
|
|
?- -.lef
|
|
::
|
|
:: web api key
|
|
:: {$apple p/(map site @)}
|
|
::
|
|
$apple ?> ?=($apple -.ryt)
|
|
!!
|
|
::
|
|
:: banned
|
|
:: {$block $~}
|
|
::
|
|
$block ?> ?=($block -.ryt)
|
|
!!
|
|
::
|
|
:: verified email address
|
|
:: {$email p/(set @ta)}
|
|
::
|
|
$email ?> ?=($email -.ryt)
|
|
!!
|
|
::
|
|
:: final ticket
|
|
:: {$final p/(map ship @pG)}
|
|
::
|
|
$final ?> ?=($final -.ryt)
|
|
!!
|
|
::
|
|
:: fungible resources
|
|
:: {$fungi p/(map term @ud)}
|
|
::
|
|
$fungi ?> ?=($fungi -.ryt)
|
|
!!
|
|
::
|
|
:: invited refugee
|
|
:: {$guest $~}
|
|
::
|
|
$guest ?> ?=($guest -.ryt)
|
|
!!
|
|
::
|
|
:: reserved block
|
|
:: {$hotel p/pile}
|
|
::
|
|
$hotel ?> ?=($hotel -.ryt)
|
|
!!
|
|
::
|
|
:: private keys
|
|
:: {$jewel p/(map life ring)}
|
|
::
|
|
$jewel ?> ?=($jewel -.ryt)
|
|
!!
|
|
::
|
|
:: login passcodes
|
|
:: {$login p/(set @pG)}
|
|
::
|
|
$login ?> ?=($login -.ryt)
|
|
!!
|
|
::
|
|
:: web service passwords
|
|
:: {$pword p/(map site (map @t @t))
|
|
::
|
|
$pword ?> ?=($pword -.ryt)
|
|
!!
|
|
::
|
|
:: app tokens
|
|
:: {$token p/(map site (map @t @t))}
|
|
::
|
|
$token ?> ?=($token -.ryt)
|
|
!!
|
|
::
|
|
:: urbit symmetric keys
|
|
:: {$urban p/(map hand bill)}
|
|
::
|
|
$urban ?> ?=($urban -.ryt)
|
|
!!
|
|
==
|
|
--
|
|
:: :: ++up
|
|
++ up :: rights wallet
|
|
|_ pig/jael-purse
|
|
::
|
|
:: ++up: wallet algebra
|
|
::
|
|
:: we store the various kinds of ++jael-right in
|
|
:: a binary tree, sorted by ++gor on the tag,
|
|
:: balanced by ++vor on the tag. this tree, a
|
|
:: ++jael-purse, is also a valid ++map. but
|
|
:: unlike a ++map, it has heterogeneous type.
|
|
::
|
|
:: this design is pretty generalized and should
|
|
:: probably be promoted deeper in the stack. its
|
|
:: goal is to make it super easy to add new
|
|
:: forms of ++jael-right, without invalidating
|
|
:: existing purse nouns.
|
|
::
|
|
:: rights operations always crash if impossible;
|
|
:: the algebra has no concept of negative rights.
|
|
::
|
|
:: external issues: our map difference and union
|
|
:: operators need some work.
|
|
::
|
|
:: :: ++differ:up
|
|
++ differ :: delta pig->gob
|
|
|= gob/jael-purse
|
|
^- jael-delta
|
|
!!
|
|
:: :: ++exists:up
|
|
++ exists :: test presence
|
|
|= tag/@tas
|
|
!=(~ (expose tag))
|
|
:: :: ++expose:up
|
|
++ expose :: typed extract
|
|
|= tag/@tas
|
|
::
|
|
:: if hoon had an equality test that informed
|
|
:: inference, this could be a |*, and its
|
|
:: product would be properly inferred.
|
|
::
|
|
^- (unit jael-right)
|
|
?~ pig ~
|
|
?: =(tag -.n.pig)
|
|
[~ u=n.pig]
|
|
?:((gor tag -.n.pig) $(pig l.pig) $(pig r.pig))
|
|
:: :: ++insert:up
|
|
++ insert :: insert item
|
|
|= ryt/jael-right
|
|
^- jael-purse
|
|
!!
|
|
:: :: ++intern:up
|
|
++ intern :: insert list
|
|
|= lin/(list jael-right)
|
|
^- jael-purse
|
|
?~ lin pig
|
|
=. pig $(lin t.lin)
|
|
(insert i.lin)
|
|
:: :: ++linear:up
|
|
++ linear :: convert to list
|
|
=| lin/(list jael-right)
|
|
|- ^+ lin
|
|
?~ pig ~
|
|
$(pig r.pig, lin [n.pig $(pig l.pig)])
|
|
:: :: ++redact:up
|
|
++ redact :: conceal secrets
|
|
|- ^- jael-purse
|
|
?~ pig ~
|
|
:_ [$(pig l.pig) $(pig r.pig)]
|
|
=* rys n.pig
|
|
^- jael-right
|
|
?+ -.rys rys
|
|
$apple
|
|
[%apple (~(run by p.rys) |=(@ (mug +<)))]
|
|
::
|
|
$final
|
|
[%final (~(run by p.rys) |=(@ (mug +<)))]
|
|
::
|
|
$login
|
|
[%login ~]
|
|
::
|
|
$pword
|
|
:- %pword
|
|
%- ~(run by p.rys)
|
|
|= (map @ta @t)
|
|
(~(run by +<) |=(@t (crip (runt [(met 3 +<) '*'] ~))))
|
|
::
|
|
$jewel
|
|
[%jewel (~(run by p.rys) |=(@ (mug +<)))]
|
|
::
|
|
$token
|
|
:- %token
|
|
%- ~(run by p.rys)
|
|
|=((map @ta @) (~(run by +<) |=(@ (mug +<))))
|
|
::
|
|
$urban
|
|
[%urban (~(run by p.rys) |=({@da code} [+<- (mug +<+)]))]
|
|
==
|
|
:: :: ++remove:up
|
|
++ remove :: pig minus gob
|
|
|= gob/jael-purse
|
|
^- jael-purse
|
|
!!
|
|
:: :: ++splice:up
|
|
++ splice :: pig plus gob
|
|
|= gob/jael-purse
|
|
^- jael-purse
|
|
!!
|
|
:: :: ++update:up
|
|
++ update :: arbitrary change
|
|
|= del/jael-delta
|
|
^- jael-purse
|
|
(remove(pig (splice mor.del)) les.del)
|
|
--
|
|
:: :: ++we
|
|
++ we :: wyll tool
|
|
|_ pub/wyll
|
|
:: :: ++collate:we
|
|
++ collate :: sort by version
|
|
|= com/$-({{life cert} {life cert}} ?)
|
|
^- (list (pair life cert))
|
|
(sort (~(tap by pub)) com)
|
|
:: :: ++current:we
|
|
++ current :: current number
|
|
^- (unit life)
|
|
(bind instant |=((pair life cert) p))
|
|
:: :: ++forward:we
|
|
++ forward :: sort oldest first
|
|
(collate |=({a/{life *} b/{life *}} (lth -.a -.b)))
|
|
:: :: ++instant:we
|
|
++ instant :: current cert
|
|
^- (unit (pair life cert))
|
|
=+ reverse
|
|
?~(- ~ `i)
|
|
:: :: ++reverse:we
|
|
++ reverse :: sort latest first
|
|
(collate |=({a/{life *} b/{life *}} (gth -.a -.b)))
|
|
--
|
|
--
|
|
:: ::::
|
|
:::: # 4 :: engines
|
|
:: ::::
|
|
=> |%
|
|
:: ## 4.a :: of
|
|
++ of :: main engine
|
|
=| moz/(list jael-move) ::::
|
|
=| $: :: sys: system context
|
|
::
|
|
$= sys
|
|
$: :: now: current time
|
|
:: eny: unique entropy
|
|
::
|
|
now/@da
|
|
eny/@e
|
|
==
|
|
:: all vane state
|
|
::
|
|
jael-state
|
|
==
|
|
:: lex: all durable state
|
|
:: moz: pending actions
|
|
::
|
|
=* lex ->
|
|
|%
|
|
:: :: abet:of
|
|
++ abet :: resolve
|
|
[(flop moz) lex]
|
|
:: :: burb:of
|
|
++ burb :: per ship
|
|
|= who/ship
|
|
~(able ~(ex ur urb) who)
|
|
:: :: call:of
|
|
++ call :: invoke
|
|
|= $: :: hen: event cause
|
|
:: tac: event data
|
|
::
|
|
hen/duct
|
|
tac/jael-task
|
|
==
|
|
^+ +>
|
|
?- -.tac
|
|
::
|
|
:: destroy promises
|
|
:: {$burn p/ship q/jael-purse)}
|
|
::
|
|
$burn
|
|
(cure abet:abet:(deal:(burb our) p.tac [~ q.tac]))
|
|
::
|
|
:: remote update
|
|
:: {$hail p/ship q/jael-remote}
|
|
::
|
|
$hail
|
|
(cure abet:abet:(hail:(burb p.tac) our q.tac))
|
|
::
|
|
:: initialize vane
|
|
:: {$init p/code q/arms}
|
|
::
|
|
$init
|
|
(cure abet:(~(make ur urb) now.sys eny.sys p.tac q.tac))
|
|
::
|
|
:: create promises
|
|
:: {$mint p/ship q/jael-purse}
|
|
::
|
|
$mint
|
|
(cure abet:abet:(deal:(burb our) p.tac [q.tac ~]))
|
|
|
|
::
|
|
:: move promises
|
|
:: {$move p/ship q/ship r/jael-purse}
|
|
::
|
|
$move
|
|
=. +> (cure abet:abet:(deal:(burb our) p.tac [~ r.tac]))
|
|
=. +> (cure abet:abet:(deal:(burb our) q.tac [r.tac ~]))
|
|
+>
|
|
::
|
|
:: public-key update
|
|
:: {$meet p/(unit (unit ship)) q/farm}
|
|
::
|
|
$meet
|
|
(cure abet:(~(meet ur urb) p.tac q.tac))
|
|
::
|
|
:: cancel all trackers from duct
|
|
:: {$nuke $~}
|
|
::
|
|
$nuke
|
|
%_ +>
|
|
yen (~(del in yen) hen)
|
|
yen.bal.sub (~(del in yen.bal.sub) hen)
|
|
yen.own.sub (~(del in yen.own.sub) hen)
|
|
car.sub %- ~(run by car.sub)
|
|
|= {yen/(set duct) det/pipe}
|
|
[(~(del in yen) hen) det]
|
|
==
|
|
::
|
|
:: extend our certificate with a new private key
|
|
:: {$next p/bull}
|
|
::
|
|
$next
|
|
(cure abet:abet:(next:(burb our) eny.sys p.tac))
|
|
::
|
|
:: open secure channel
|
|
:: {$veil p/ship}
|
|
::
|
|
$veil
|
|
(curd abet:(~(veil ~(feed su urb sub) hen) p.tac))
|
|
::
|
|
:: watch private keys
|
|
:: {$vein $~}
|
|
::
|
|
$vein
|
|
(curd abet:~(vein ~(feed su urb sub) hen))
|
|
::
|
|
:: monitor assets
|
|
:: {$vest $~}
|
|
::
|
|
$vest
|
|
(curd abet:~(vest ~(feed su urb sub) hen))
|
|
::
|
|
:: monitor all
|
|
:: {$vine $~}
|
|
::
|
|
$vine
|
|
+>(yen (~(put in yen) hen))
|
|
::
|
|
:: authenticated remote request
|
|
:: {$west p/ship q/path r/*}
|
|
::
|
|
$west
|
|
?> =(~ q.tac)
|
|
=+ mes=((hard jael-message) r.tac)
|
|
?- -.mes
|
|
::
|
|
:: reset remote rights
|
|
:: {$hail p/jael-purse}
|
|
::
|
|
$hail
|
|
(cure abet:abet:(hail:(burb p.tac) our [%| p.mes]))
|
|
::
|
|
:: share certificates
|
|
:: {$meet p/farm}
|
|
::
|
|
$meet
|
|
(cure abet:(~(meet ur urb) ``p.tac p.mes))
|
|
==
|
|
==
|
|
:: :: ++curd:of
|
|
++ curd :: subjective moves
|
|
|= {moz/(list jael-move) sub/jael-subjective}
|
|
+>(sub sub, moz (weld (flop moz) ^moz))
|
|
:: :: ++cure:of
|
|
++ cure :: objective edits
|
|
|= {hab/(list jael-edit) urb/jael-objective}
|
|
^+ +>
|
|
(curd(urb urb) abet:(~(apex su urb sub) hab))
|
|
--
|
|
:: ## 4.b :: ++su
|
|
++ su :: subjective engine
|
|
=| moz/(list jael-move) ::::
|
|
=| $: jael-objective
|
|
jael-subjective
|
|
==
|
|
:: moz: moves in reverse order
|
|
:: urb: objective urbit state
|
|
:: sub: subjective urbit state
|
|
::
|
|
=* urb -<
|
|
=* sub ->
|
|
|%
|
|
:: :: ++abet:su
|
|
++ abet :: resolve
|
|
[(flop moz) sub]
|
|
:: :: ++apex:su
|
|
++ apex :: apply changes
|
|
|= hab/(list jael-edit)
|
|
^+ +>
|
|
?~ hab +>
|
|
%= $
|
|
hab t.hab
|
|
+>
|
|
?- -.i.hab
|
|
$rite (paid +.i.hab)
|
|
$fact (said +.i.hab)
|
|
==
|
|
==
|
|
:: :: ++exec:su
|
|
++ exec :: mass gift
|
|
|= {yen/(set duct) cad/jael-card}
|
|
=/ noy (~(tap in yen))
|
|
|- ^+ ..exec
|
|
?~ noy ..exec
|
|
$(noy t.noy, moz [[i.noy cad] moz])
|
|
:: :: ++feed:su
|
|
++ feed :: subscribe to view
|
|
|_ :: hen: subscription source
|
|
::
|
|
hen/duct
|
|
:: :: ++veil:feed:su
|
|
++ veil :: secure channel
|
|
|= who/ship
|
|
^+ ..feed
|
|
::
|
|
:: send initial pki sync as needed
|
|
::
|
|
=. ..feed (open hen who)
|
|
=/ ruc (~(get by car) who)
|
|
=/ rec
|
|
?~ ruc
|
|
[`yen/(set duct)`[hen ~ ~] det=(veil:form who)]
|
|
u.ruc(yen (~(put in yen.u.ruc) hen))
|
|
%_ ..feed
|
|
moz [[hen %give %veil det.rec] moz]
|
|
car (~(put by car) who rec)
|
|
==
|
|
:: :: ++vein:feed:su
|
|
++ vein :: private keys
|
|
%_ ..feed
|
|
moz [[hen %give %vein [lyf jaw]:own] moz]
|
|
yen.own (~(put in yen.own) hen)
|
|
==
|
|
:: :: ++vest:feed:su
|
|
++ vest :: balance
|
|
%_ ..feed
|
|
moz [[hen %give %vest %& vest:form] moz]
|
|
yen.bal (~(put in yen.bal) hen)
|
|
==
|
|
--
|
|
:: :: ++feel:su
|
|
++ feel :: update tracker
|
|
|%
|
|
:: :: ++veal:feel:su
|
|
++ veal :: kick subfarm
|
|
^+ ..feel
|
|
=/ cod veal:form
|
|
?:(=(cod.rel cod) ..feel ..feel(cod.rel cod))
|
|
:: :: ++veil:feel:su
|
|
++ veil :: kick secure channel
|
|
|= who/ship
|
|
^+ ..feel
|
|
=/ ruc (~(get by car) who)
|
|
?~ ruc ..feel
|
|
=/ det (veil:form who)
|
|
?: =(det det.u.ruc) ..feel
|
|
=. car (~(put by car) who [yen.u.ruc det])
|
|
(exec yen.u.ruc [%give %veil det])
|
|
:: :: ++vein:feel:su
|
|
++ vein :: kick private keys
|
|
^+ ..feel
|
|
=/ yam vein:form
|
|
?: =(yam +.own) ..feel
|
|
(exec(+.own yam) yen.own [%give %vein +.own])
|
|
:: :: ++vest:feel:su
|
|
++ vest :: kick balance
|
|
|= hug/jael-action
|
|
^+ ..feel
|
|
?: =([~ ~] +.q.hug) ..feel
|
|
::
|
|
:: notify all local listeners
|
|
::
|
|
=. ..feel (exec yen.bal [%give %vest %| p.hug q.hug])
|
|
::
|
|
:: pig: purse report for partner
|
|
::
|
|
?. ?=($| -.q.hug) ..feel
|
|
=* pig (~(lawn ur urb) our p.hug)
|
|
%_ ..feel
|
|
moz :_ moz
|
|
[*duct %pass /vest/(scot %p p.hug) %x %mess p.hug /j %hail pig]
|
|
==
|
|
--
|
|
:: :: ++fire:su
|
|
++ fire :: propagate keys
|
|
|_ hec/farm
|
|
++ home :: ++home:su
|
|
|= who/ship :: to ship
|
|
%_ ..fire
|
|
moz
|
|
:_ moz
|
|
[*duct %pass /meet/(scot %p who) %x %mess who /j [%meet hec]]
|
|
==
|
|
:: :: ++flow:su
|
|
++ flow :: to set of ships
|
|
|= tar/(set ship)
|
|
=+ rot=(~(tap in (~(del in tar) our)))
|
|
|- ^+ ..fire
|
|
?~ rot ..fire
|
|
$(rot t.rot, ..fire (home i.rot))
|
|
:: :: ++spam:su
|
|
++ spam :: to list of sets
|
|
|= {via/(unit ship) jax/(list (set ship))}
|
|
^+ ..fire
|
|
=- (flow ?~(via - (~(del in -) u.via)))
|
|
|- ^- (set ship)
|
|
?~(jax ~ (~(uni in i.jax) $(jax t.jax)))
|
|
--
|
|
:: :: ++form:su
|
|
++ form :: generate reports
|
|
|%
|
|
:: :: ++veal:form:su
|
|
++ veal :: public dependencies
|
|
=| mor/(set ship)
|
|
^- farm
|
|
!!
|
|
:: :: ++veil:form:su
|
|
++ veil :: channel report
|
|
|= who/ship
|
|
^- pipe
|
|
::
|
|
:: pub: will of who
|
|
:: exp: promises from our to who
|
|
:: imp: promises from who to our
|
|
:: out: symmetric key from our to who
|
|
:: inn: symmetric keys from who to our
|
|
::
|
|
=/ pub
|
|
^- wyll
|
|
=- ?~(- ~ u.-)
|
|
(~(get by pug.urb) who)
|
|
::
|
|
=/ exp
|
|
^- jael-purse
|
|
=- ?~(- ~ u.-)
|
|
(~(get by (~(got by pry.urb) our)) who)
|
|
::
|
|
=/ imp
|
|
^- jael-purse
|
|
=- ?~(- ~ u.-)
|
|
%. our
|
|
~(get by (fall (~(get by pry.urb) who) *(map ship jael-purse)))
|
|
::
|
|
=* out
|
|
^- (unit (pair hand bill))
|
|
=+ (~(expose up exp) %urban)
|
|
?~ - ~
|
|
?> ?=($urban -.u.-)
|
|
=* pam p.u.-
|
|
?~ pam ~
|
|
:: arbitrarily select root node of the map
|
|
::
|
|
`n.pam
|
|
::
|
|
=* inn
|
|
=+ (~(expose up imp) %urban)
|
|
^- (map hand bill)
|
|
?~ - ~
|
|
?> ?=($urban -.u.-)
|
|
p.u.-
|
|
::
|
|
^- pipe
|
|
[out inn ~(current we pub) (~(dads ur urb) who) pub]
|
|
:: :: ++vein:form:su
|
|
++ vein :: private key report
|
|
^- (pair life (map life ring))
|
|
(~(lean ur urb) our)
|
|
:: :: ++vest:form:su
|
|
++ vest :: balance report
|
|
^- jael-balance
|
|
:- ::
|
|
:: raw: all our liabilities by ship
|
|
:: dud: delete liabilities to self
|
|
:: cul: mask secrets
|
|
::
|
|
=* raw =-(?~(- ~ u.-) (~(get by pry.urb) our))
|
|
=* dud (~(del by raw) our)
|
|
=* cul (~(run by dud) |=(jael-purse ~(redact up +<)))
|
|
cul
|
|
::
|
|
:: fub: all assets by ship
|
|
:: veg: all nontrivial assets, secrets masked
|
|
::
|
|
=/ fub
|
|
^- (list (pair ship (unit jael-purse)))
|
|
%+ turn
|
|
(~(tap by pry.urb))
|
|
|= (pair ship (map ship jael-purse))
|
|
[p (~(get by q) our)]
|
|
=* veg
|
|
|- ^- (list (pair ship jael-purse))
|
|
?~ fub ~
|
|
=+ $(fub t.fub)
|
|
?~(q.i.fub - [[p.i.fub ~(redact up u.q.i.fub)] -])
|
|
::
|
|
(~(gas by *(map ship jael-purse)) veg)
|
|
--
|
|
:: :: ++open:su
|
|
++ open :: make secure channel
|
|
|= $: hen/duct
|
|
who/ship
|
|
==
|
|
^+ +>
|
|
::
|
|
:: a one-time operation to create a secure channel
|
|
::
|
|
?: (~(has by car) who) +>
|
|
::
|
|
:: initial propagation: ourself and dependencies, plus
|
|
:: all capital ships if meeting a child.
|
|
::
|
|
=* hec ^- farm
|
|
?. (~(has in kyz.rel) who) cod.rel
|
|
=- (~(uni by cod.rel) -)
|
|
%- ~(gas by *farm)
|
|
%+ skim (~(tap by pug.urb))
|
|
|=({who/ship *} (lth who 65.536))
|
|
::
|
|
(~(home fire hec) who)
|
|
:: :: ++paid:su
|
|
++ paid :: track asset change
|
|
|= $: :: rex: promise from
|
|
:: pal: promise to
|
|
:: del: change to existing
|
|
:: bur: changes to symmetric keys
|
|
::
|
|
rex/ship
|
|
pal/ship
|
|
del/jael-delta
|
|
==
|
|
^+ +>
|
|
=* bur ?| (~(exists up mor.del) %urban)
|
|
(~(exists up les.del) %urban)
|
|
==
|
|
:: ignore empty delta; keep secrets out of metadata
|
|
::
|
|
?: =([~ ~] del) +>
|
|
=. del [~(redact up mor.del) ~(redact up les.del)]
|
|
?. =(our pal)
|
|
::
|
|
:: track promises we made to others
|
|
::
|
|
?. =(our rex) +>
|
|
::
|
|
:: track liabilities
|
|
::
|
|
=. +> (vest:feel pal %& del)
|
|
::
|
|
:: track secure channels
|
|
::
|
|
?. bur +>
|
|
(veil:feel pal)
|
|
::
|
|
:: track private keys
|
|
::
|
|
=. +> ?. (~(exists up mor.del) %jewel)
|
|
+>
|
|
vein:feel
|
|
::
|
|
:: track changes in secure channels
|
|
::
|
|
?. bur +>
|
|
(veil:feel rex)
|
|
:: :: ++said:su
|
|
++ said :: track certificates
|
|
|= $: :: rex: ship whose will has changed
|
|
:: vie: change authorized by
|
|
:: lyf: modified/created version
|
|
:: gan: modification
|
|
::
|
|
rex/ship
|
|
vie/(unit (unit ship))
|
|
lyf/life
|
|
gan/jael-grow
|
|
==
|
|
:: lip: this change as its own farm
|
|
::
|
|
=/ lip ^- farm
|
|
=- [[rex -] ~ ~]
|
|
^- wyll
|
|
=- [[lyf -] ~ ~]
|
|
^- cert
|
|
?- -.gan
|
|
::
|
|
:: add a new certificate to this will
|
|
:: {$step p/cert}
|
|
::
|
|
$step p.gan
|
|
::
|
|
:: add a new signature to this certificate
|
|
:: {$sign p/mind q/@}
|
|
::
|
|
$sign
|
|
:- dat:(~(got by (~(got by pug.urb) rex)) lyf)
|
|
=- [- ~ ~]
|
|
[who.p.gan lyf.p.gan q.gan]
|
|
==
|
|
::
|
|
:: if our subfarm may have changed, reset it
|
|
::
|
|
=. +>.$ ?. |(=(our rex) (~(has by cod.rel) rex)) +>.$
|
|
veal:feel
|
|
::
|
|
:: if a new deed, reset parent
|
|
::
|
|
=. dad.rel ?. &(=(our rex) ?=($step -.gan))
|
|
dad.rel
|
|
dad.doc.dat.p.gan
|
|
::
|
|
:: kick secure channels
|
|
::
|
|
=. +>.$ (veil:feel rex)
|
|
::
|
|
:: if we signed a will for someone else, send it home
|
|
::
|
|
?: &(=([~ ~] vie) !=(our rex))
|
|
(~(home fire lip) rex)
|
|
::
|
|
:: if first certificate, add to neighbor lists
|
|
::
|
|
=. +>.$ ?. &(?=($step -.gan) =(1 lyf)) +>.$
|
|
=. kyz.rel ?. =(our dad.doc.dat.p.gan) kyz.rel
|
|
(~(put in kyz.rel) rex)
|
|
=. pyr.rel ?. =((clan rex) (clan our)) pyr.rel
|
|
(~(put in pyr.rel) rex)
|
|
+>.$
|
|
::
|
|
:: propagate new data as appropriate
|
|
::
|
|
%+ ~(spam fire lip)
|
|
?~(vie ~ ?~(u.vie ~ `u.u.vie))
|
|
^- (list (set ship))
|
|
::
|
|
:: if our will has changed, send to parents and kids;
|
|
:: if a new deed has been added, also to pals
|
|
::
|
|
?: =(our rex)
|
|
:* [dad.rel ~ ~]
|
|
kyz.rel
|
|
?.(=(%step -.gan) ~ [pyr.rel ~])
|
|
==
|
|
::
|
|
:: forward star and galaxy updates to parents and kids
|
|
::
|
|
?. (lth rex 65.536)
|
|
~
|
|
:* [dad.rel ~ ~]
|
|
kyz.rel
|
|
~
|
|
==
|
|
--
|
|
:: ## 4.c :: ++ur
|
|
++ ur :: urbit engine
|
|
=| hab/(list jael-edit) ::::
|
|
=| jael-objective
|
|
::
|
|
:: hab: side effects, reversed
|
|
:: urb: all urbit state
|
|
::
|
|
=* urb -
|
|
|%
|
|
:: :: ++abet:ur
|
|
++ abet :: resolve
|
|
[(flop hab) `jael-objective`urb]
|
|
:: :: ++boss:ur
|
|
++ boss :: parent
|
|
|= who/ship
|
|
^- ship
|
|
-:(dads who)
|
|
::
|
|
++ dads :: ++dads:ur
|
|
|= who/ship :: lineage
|
|
^- (list ship)
|
|
=/ ryg (~(get by pug) who)
|
|
?~ ryg (saxo who)
|
|
=/ dad dad.doc.dat.q:(need ~(instant we u.ryg))
|
|
[who ?:(=(who dad) ~ $(who dad))]
|
|
::
|
|
++ lawn :: ++lawn:ur
|
|
|= {rex/ship pal/ship} :: debts, rex to pal
|
|
^- jael-purse
|
|
(lawn:~(able ex rex) pal)
|
|
:: :: ++leak:ur
|
|
++ leak :: private key
|
|
|= rex/ship
|
|
^- (pair life ring)
|
|
=/ lyn lean:~(able ex rex)
|
|
[p.lyn (~(got by q.lyn) p.lyn)]
|
|
:: :: ++lean:ur
|
|
++ lean :: private keys
|
|
|= rex/ship
|
|
^- (pair life (map life ring))
|
|
lean:~(able ex rex)
|
|
:: :: ++make:ur
|
|
++ make :: initialize urbit
|
|
|= $: :: now: date
|
|
:: eny: entropy
|
|
:: gen: bootstrap ticket
|
|
:: nym: self-description
|
|
::
|
|
now/@da
|
|
eny/@e
|
|
gen/@pG
|
|
nym/arms
|
|
==
|
|
^+ +>
|
|
:: key: generated key
|
|
:: bul: initial bull
|
|
::
|
|
=/ key (ypt:scr (mix our %jael-make) gen)
|
|
=* doc `bull`[(sein our) & nym]
|
|
::
|
|
:: register generator as login secret
|
|
::
|
|
=. +>.$ abet:(deal:~(able ex our) our [[[%login [gen ~ ~]] ~ ~] ~])
|
|
::
|
|
:: create galaxy with generator as seed
|
|
::
|
|
?: (lth our 256)
|
|
abet:(next:~(able ex our) key doc)
|
|
::
|
|
:: had: key handle
|
|
:: ryt: initial right
|
|
::
|
|
=/ key (ypt:scr (mix our %jael-make) gen)
|
|
=* had (shaf %hand key)
|
|
=* ryt `jael-right`[%urban [had (add ~m1 now) key] ~ ~]
|
|
::
|
|
:: register initial symmetric key from ticket
|
|
::
|
|
=. +>.$ abet:(hail:~(able ex (sein our)) our %& [ryt ~ ~])
|
|
::
|
|
:: create initial private key and certificate
|
|
::
|
|
abet:(next:~(able ex our) (mix eny key) doc)
|
|
:: :: ++meet:ur
|
|
++ meet :: calculate merge
|
|
|= $: :: vie: authenticated source
|
|
:: cod: transmitted certificates
|
|
::
|
|
vie/(unit (unit ship))
|
|
cod/farm
|
|
==
|
|
^+ +>
|
|
=+ lec=(~(tap by cod))
|
|
|- ^+ ..meet
|
|
?~ lec ..meet
|
|
%= $
|
|
lec t.lec
|
|
..meet abet:(grow:~(able ex p.i.lec) vie cod q.i.lec)
|
|
==
|
|
:: :: ++ex:ur
|
|
++ ex :: server engine
|
|
:: shy: private state
|
|
:: rug: domestic will
|
|
::
|
|
=| $: shy/(map ship jael-purse)
|
|
rug/wyll
|
|
==
|
|
=| :: rex: server ship
|
|
::
|
|
rex/ship
|
|
|%
|
|
:: :: ++abet:ex:ur
|
|
++ abet :: resolve
|
|
%_ ..ex
|
|
pry (~(put by pry) rex shy)
|
|
pug (~(put by pug) rex rug)
|
|
==
|
|
:: :: ++able:ex:ur
|
|
++ able :: initialize
|
|
%_ .
|
|
shy (fall (~(get by pry) rex) *(map ship jael-purse))
|
|
rug (fall (~(get by pug) rex) *wyll)
|
|
==
|
|
:: :: ++deal:ex:ur
|
|
++ deal :: alter rights
|
|
|= {pal/ship del/jael-delta}
|
|
^+ +>
|
|
=/ gob (fall (~(get by shy) pal) *jael-purse)
|
|
=* hep (~(update up gob) del)
|
|
%_ +>.$
|
|
shy (~(put by shy) pal hep)
|
|
hab [[%rite rex pal del] hab]
|
|
==
|
|
::
|
|
++ hail :: ++hail:ex:ur
|
|
|= {pal/ship rem/jael-remote} :: report rights
|
|
^+ +>
|
|
=/ gob (fall (~(get by shy) pal) *jael-purse)
|
|
=/ yer ^- (pair jael-delta jael-purse)
|
|
?- -.rem
|
|
$& [[p.rem ~] (~(splice up gob) p.rem)]
|
|
$| [(~(differ up gob) p.rem) p.rem]
|
|
==
|
|
%_ +>.$
|
|
shy (~(put by shy) pal q.yer)
|
|
hab [[%rite rex pal p.yer] hab]
|
|
==
|
|
:: :: ++lean:ex:ur
|
|
++ lean :: private keys
|
|
^- (pair life (map life ring))
|
|
::
|
|
:: lyf: latest life of
|
|
:: lab: promises by rex
|
|
:: par: promises by rex, to rex
|
|
:: jel: %jewel rights
|
|
::
|
|
=/ lyf `life`(need ~(current we (~(got by pug) rex)))
|
|
=* lab (~(got by pry) rex)
|
|
=* par (~(got by lab) rex)
|
|
=/ jel `jael-right`(need (~(expose up par) %jewel))
|
|
?> ?=($jewel -.jel)
|
|
[lyf p.jel]
|
|
:: :: ++lawn:ex:ur
|
|
++ lawn :: liabilities to pal
|
|
|= pal/ship
|
|
^- jael-purse
|
|
=-(?~(- ~ u.-) (~(get by shy) pal))
|
|
:: :: ++next:ex:ur
|
|
++ next :: advance private key
|
|
|= {eny/@e doc/bull}
|
|
^+ +>
|
|
:: loy: live keypair
|
|
:: rig: private key
|
|
:: ryt: private key as right
|
|
:: pub: public key
|
|
:: cet: unsigned certificate
|
|
:: wyl: initial will
|
|
:: hec: initial will as farm
|
|
::
|
|
=/ loy (pit:nu:crub 512 eny)
|
|
=* rig sec:ex:loy
|
|
=* ryt `jael-right`[%jewel [1 rig] ~ ~]
|
|
=* pub pub:ex:loy
|
|
=* cet `cert`[[doc pub] ~]
|
|
=* wyl `wyll`[[1 cet] ~ ~]
|
|
=* hec `farm`[[rex wyl] ~ ~]
|
|
=. +>.$ (deal rex [[ryt ~ ~] ~])
|
|
=. ..ex (meet [~ ~] hec)
|
|
+>.$
|
|
:: :: grow:ex:ur
|
|
++ grow :: merge wills
|
|
|= $: :: vie: data source
|
|
:: cod: merge context
|
|
:: gur: input will
|
|
::
|
|
vie/(unit (unit ship))
|
|
cod/farm
|
|
gur/wyll
|
|
==
|
|
?: |(=(~ gur) =(gur rug)) ..grow
|
|
|^ ^+ ..grow
|
|
::
|
|
:: wap: ascending list of new certs
|
|
:: nem: previous life
|
|
:: pre: previous deed
|
|
::
|
|
=/ wap
|
|
^- (list (pair life cert))
|
|
%+ sort (~(tap by gur))
|
|
|= {a/{life *} b/{life *}}
|
|
(lth -.a -.b)
|
|
=/ nem
|
|
^- (unit life)
|
|
?~(wap ~ ?:(=(1 p.i.wap) ~ `(dec p.i.wap)))
|
|
=/ pre
|
|
^- (unit deyd)
|
|
(bind nem |=(life dat:(~(got by rug) +<)))
|
|
::
|
|
:: merge each life
|
|
::
|
|
|- ^+ ..grow
|
|
?~ wap ..grow
|
|
?> |(?=($~ nem) =(p.i.wap +(u.nem)))
|
|
::
|
|
:: lub: merged deed and changes
|
|
::
|
|
=+ lub=(grow-mate p.i.wap q.i.wap pre)
|
|
%= $
|
|
wap t.wap
|
|
nem `p.i.wap
|
|
pre `dat.q.lub
|
|
rug (~(put by rug) p.i.wap q.lub)
|
|
hab (weld (flop p.lub) hab)
|
|
==
|
|
:: :: grow-lick/ex:ur
|
|
++ grow-lick :: check signature
|
|
|= {pub/pass ash/@ val/@}
|
|
^- ?
|
|
=+ ver=(sure:as:(com:nu:crub pub) *code val)
|
|
?~ ver |
|
|
=(ash u.ver)
|
|
:: :: grow-like/ex:ur
|
|
++ grow-like :: verify signature
|
|
|= {myn/mind ash/@ val/@}
|
|
^- ?
|
|
=: ..able able(rex who.myn)
|
|
gur (fall (~(get by cod) who.myn) *wyll)
|
|
==
|
|
(grow-lick (grow-look lyf.myn) ash val)
|
|
:: :: grow-look/ex:ur
|
|
++ grow-look :: load public key
|
|
|= lyf/life
|
|
^- @
|
|
::
|
|
:: cascade search over old and new, new first
|
|
::
|
|
|^ %- (bond |.((need grow-look-find)))
|
|
grow-look-find(rug gur)
|
|
:: :: grow-look-find:ex:ur
|
|
++ grow-look-find ::
|
|
^- (unit @)
|
|
::
|
|
:: crash if this life is revoked
|
|
::
|
|
?< (~(has by rug) +(lyf))
|
|
%+ biff (~(get by rug) lyf)
|
|
|=(cert `pub.dat)
|
|
--
|
|
:: :: grow-mate/ex:ur
|
|
++ grow-mate :: merge lives
|
|
|= $: :: num: life we're merging
|
|
:: new: new deed
|
|
:: pre: previous deed
|
|
:: eld: old deed
|
|
::
|
|
num/@ud
|
|
new/cert
|
|
pre/(unit deyd)
|
|
==
|
|
=+ :* eld=`(unit cert)`(~(get by rug) num)
|
|
==
|
|
^- (pair (list jael-edit) cert)
|
|
::
|
|
:: enforce artificial scarcity in lives
|
|
::
|
|
?> (lte num 9)
|
|
::
|
|
:: if no new information, do nothing
|
|
::
|
|
?: |(=(eld `new))
|
|
?> ?=(^ eld)
|
|
[~ u.eld]
|
|
::
|
|
:: ash: hash of deed content
|
|
:: def: our default parent
|
|
:: dad: our declared parent
|
|
:: mir: our rank
|
|
::
|
|
=/ ash (sham %urbit rex num dat.new)
|
|
=/ def (sein rex)
|
|
=* dad dad.doc.dat.new
|
|
=/ mir (clan rex)
|
|
?> ?: |(=(num 1) =(%earl mir) =(%pawn mir))
|
|
::
|
|
:: first parent must be default;
|
|
:: comets and moons may not migrate
|
|
::
|
|
=(def dad)
|
|
::
|
|
:: all others may migrate to parent of same rank
|
|
::
|
|
=((clan def) (clan dad))
|
|
::
|
|
:: if we have an old deed at this life, merge new signatures
|
|
::
|
|
?: ?=(^ eld)
|
|
::
|
|
:: deed data must be identical
|
|
::
|
|
?> =(dat.new dat.u.eld)
|
|
::
|
|
:: sow: all new signatures
|
|
::
|
|
=+ sow=`(list (trel ship life @))`(~(tap by syg.new))
|
|
|- ^- (pair (list jael-edit) cert)
|
|
?~ sow [~ u.eld]
|
|
::
|
|
:: mor: all further edits
|
|
:: och: old signature for this signer
|
|
::
|
|
=+ mor=$(sow t.sow)
|
|
=+ och=(~(get by syg.q.mor) p.i.sow)
|
|
::
|
|
:: ignore obsolete/equivalent signature
|
|
::
|
|
?. |(?=($~ och) (gth q.i.sow p.u.och))
|
|
mor
|
|
::
|
|
:: verify and merge added signature
|
|
::
|
|
?> (grow-like [p q]:i.sow ash r.i.sow)
|
|
:_ q.mor(syg (~(put by syg.q.mor) p.i.sow [q r]:i.sow))
|
|
:_ p.mor
|
|
`jael-edit`[%fact rex vie num `jael-grow`[%sign [[p q] r]:i.sow]]
|
|
::
|
|
:: non-initial deeds must be signed by previous
|
|
::
|
|
?> ?| ?=($~ pre)
|
|
=+ laz=(~(got by syg.new) rex)
|
|
?> =(p.laz (dec num))
|
|
(grow-lick pub.u.pre ash q.laz)
|
|
==
|
|
::
|
|
:: check the parent has signed, if necessary
|
|
::
|
|
?> ?| ::
|
|
:: no parent signature for existing, non-moon urbits
|
|
::
|
|
?& ?=(^ pre)
|
|
=(dad.doc.u.pre dad)
|
|
!=(%earl mir)
|
|
==
|
|
::
|
|
:: initial fingerprint for galaxy is hardcoded
|
|
::
|
|
?& =(%czar mir)
|
|
?=($~ pre)
|
|
=((shaf %zeno pub.dat.new) (zeno rex))
|
|
==
|
|
::
|
|
:: the deed is homemade or sent by owner
|
|
::
|
|
&(?=(^ vie) |(?=($~ u.vie) =(u.u.vie rex)))
|
|
::
|
|
:: check valid parent signature
|
|
::
|
|
=+ par=(~(got by syg.new) dad)
|
|
(grow-like [dad p.par] ash q.par)
|
|
==
|
|
=- [[%fact rex p.- num %step q.-]~ q.-]
|
|
^- (pair (unit (unit ship)) cert)
|
|
::
|
|
:: the new deed is complete; report it
|
|
::
|
|
?: (~(has by syg.new) dad)
|
|
[vie new]
|
|
::
|
|
:: the new deed needs a parent signature; try to add it
|
|
::
|
|
:- [~ ~]
|
|
::
|
|
:: pev: life and ring of parent
|
|
:: val: new signature
|
|
::
|
|
=/ pev (leak dad)
|
|
=* val (sign:as:(nol:nu:crub q.pev) *@ ash)
|
|
new(syg (~(put by syg.new) dad [p.pev val]))
|
|
-- --
|
|
-- --
|
|
:: ::::
|
|
:::: :: preamble
|
|
:: ::::
|
|
::
|
|
:: lex: all durable %jael state
|
|
::
|
|
=| lex/jael-state
|
|
|= $: ::
|
|
:: now: current time
|
|
:: eny: unique entropy
|
|
:: ski: namespace resolver
|
|
::
|
|
now/@da
|
|
eny/@e
|
|
ski/sley
|
|
==
|
|
:: ::::
|
|
:::: :: interface
|
|
:: ::::
|
|
|%
|
|
:: :: ++call
|
|
++ call :: request
|
|
|= $: :: hen: cause of this event
|
|
:: hic: event data
|
|
::
|
|
hen/duct
|
|
hic/(hypo (hobo jael-task))
|
|
==
|
|
=> .(q.hic ?.(?=($soft -.q.hic) q.hic ((hard jael-task) p.q.hic)))
|
|
^- {p/(list jael-move) q/_..^$}
|
|
=^ did lex abet:~(call of [now eny] lex)
|
|
[did ..^$]
|
|
:: :: ++doze
|
|
++ doze :: await
|
|
|= $: :: now: current time
|
|
:: hen: cause (XX why we need this?)
|
|
::
|
|
now/@da
|
|
hen/duct
|
|
==
|
|
^- (unit @da)
|
|
~
|
|
:: :: ++load
|
|
++ load :: upgrade
|
|
|= $: :: old: previous state
|
|
::
|
|
old/jael-state
|
|
==
|
|
^+ ..^$
|
|
..^$(lex old)
|
|
:: :: ++scry
|
|
++ scry :: inspect
|
|
|= $: :: fur: event security
|
|
:: ren: access mode
|
|
:: why: owner
|
|
:: syd: desk (branch)
|
|
:: lot: case (version)
|
|
:: tyl: rest of path
|
|
::
|
|
fur/(unit (set monk))
|
|
ren/@tas
|
|
why/shop
|
|
syd/desk
|
|
lot/coin
|
|
tyl/spur
|
|
==
|
|
^- (unit (unit cage))
|
|
~
|
|
:: :: ++stay
|
|
++ stay :: preserve
|
|
lex
|
|
:: :: ++take
|
|
++ take :: accept
|
|
|= $: :: tea: order
|
|
:: hen: cause
|
|
:: hin: result
|
|
::
|
|
tea/wire
|
|
hen/duct
|
|
hin/(hypo sign-arvo)
|
|
==
|
|
^- {p/(list jael-move) q/_..^$}
|
|
[~ ..^$]
|
|
--
|