I think mainly done moving modules around

src/ability.rs

@@ -1,6 +1,7 @@
 // FIXME feature flag each?
 pub mod crud;
 pub mod msg;
+pub mod ucan;
 pub mod wasm;
 
 pub mod arguments;

src/ability/arguments.rs

@@ -11,6 +11,22 @@ impl Arguments {
     }
 }
 
+impl Arguments {
+    pub fn insert(&mut self, key: String, value: Ipld) -> Option<Ipld> {
+        self.0.insert(key, value)
+    }
+
+    pub fn get(&self, key: &str) -> Option<&Ipld> {
+        self.0.get(key)
+    }
+}
+
+impl Default for Arguments {
+    fn default() -> Self {
+        Arguments(BTreeMap::new())
+    }
+}
+
 impl TryFrom<Ipld> for Arguments {
     type Error = SerdeError;
 

src/ability/dynamic.rs

@@ -1,9 +1,7 @@
 //! This module is for dynamic abilities, especially for FFI and Wasm support
 
 use super::{arguments::Arguments, command::ToCommand};
-use crate::{
-    delegation::delegatable::Delegatable, invocation::resolvable::Resolvable, promise::Promise,
-};
+use crate::{delegate::Delegatable, invoke::Resolvable, promise::Promise};
 use serde_derive::{Deserialize, Serialize};
 use std::fmt::Debug;
 

src/ability/msg/send.rs

@@ -1,7 +1,7 @@
 use crate::{
     ability::{arguments::Arguments, command::Command},
-    delegation::delegatable::Delegatable,
-    invocation::resolvable::Resolvable,
+    delegate::Delegatable,
+    invoke::Resolvable,
     promise::Promise,
     proof::{checkable::Checkable, parentful::Parentful, parents::CheckParents, same::CheckSame},
 };

src/ability/ucan.rs

@@ -0,0 +1,82 @@
+use super::arguments::Arguments;
+use crate::{ability::command::Command, delegate::Delegatable, promise::Promise};
+use libipld_core::ipld::Ipld;
+use serde::{Deserialize, Serialize};
+use std::fmt::Debug;
+
+// NOTE This one is primarily for enabling delegated recipets
+
+// FIXME
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+struct Generic<Args> {
+    pub cmd: String,
+    pub args: Args, // FIXME Does this have specific fields?
+}
+
+pub type Resolved = Generic<Arguments>;
+pub type Builder = Generic<Option<Arguments>>;
+pub type Promised = Generic<Promise<Arguments>>;
+
+impl<Args> Command for Generic<Args> {
+    const COMMAND: &'static str = "ucan/proxy";
+}
+
+impl Delegatable for Resolved {
+    type Builder = Builder;
+}
+
+impl From<Resolved> for Builder {
+    fn from(resolved: Resolved) -> Builder {
+        Builder {
+            cmd: resolved.cmd,
+            args: Some(resolved.args),
+        }
+    }
+}
+
+impl TryFrom<Builder> for Resolved {
+    type Error = (); // FIXME
+
+    fn try_from(b: Builder) -> Result<Self, Self::Error> {
+        Ok(Resolved {
+            cmd: b.cmd,
+            args: b.args.ok_or(())?,
+        })
+    }
+}
+
+impl From<Builder> for Arguments {
+    fn from(b: Builder) -> Arguments {
+        let mut args = b.args.unwrap_or_default();
+        args.insert("cmd".into(), Ipld::String(b.cmd));
+        args
+    }
+}
+
+// // FIXME hmmm
+// #[derive(Debug, Clone, PartialEq)]
+// pub struct ProxyExecuteBuilder {
+//     pub command: Option<String>,
+//     pub args: BTreeMap<String, Ipld>,
+// }
+//
+//
+// impl From<ProxyExecute> for ProxyExecuteBuilder {
+//     fn from(proxy: ProxyExecute) -> Self {
+//         ProxyExecuteBuilder {
+//             command: Some(ProxyExecute::COMMAND.into()),
+//             args: proxy.args.clone(),
+//         }
+//     }
+// }
+//
+// impl TryFrom<ProxyExecuteBuilder> for ProxyExecute {
+//     type Error = (); // FIXME
+//
+//     fn try_from(ProxyExecuteBuilder { command, args }: ProxyExecuteBuilder) -> Result<Self, ()> {
+//         match command {
+//             None => Err(()),
+//             Some(command) => Ok(Self { command, args }),
+//         }
+//     }
+// }

src/delegation.rs → src/delegate.rs

@@ -1,14 +1,15 @@
 // FIXME rename delegate?
 
-pub mod condition;
-pub mod delegatable;
-pub mod delegate;
-pub mod payload;
+mod condition;
+mod delegatable;
+mod payload;
 
-use crate::signature;
-pub use delegate::Delegate;
+pub use condition::traits::Condition;
+pub use delegatable::Delegatable;
 pub use payload::Payload;
 
+use crate::signature;
+
 /// A [`Delegation`] is a signed delegation [`Payload`]
 ///
 /// A [`Payload`] on its own is not a valid [`Delegation`], as it must be signed by the issuer.

src/delegation/payload.rs → src/delegate/payload.rs

@@ -3,7 +3,8 @@ use crate::{
     ability::{arguments::Arguments, command::Command, dynamic},
     capsule::Capsule,
     did::Did,
-    invocation::{payload as invocation, resolvable::Resolvable},
+    invoke,
+    invoke::Resolvable,
     nonce::Nonce,
     proof::{
         checkable::Checkable,
@@ -89,14 +90,14 @@ impl<T: Delegatable, C: Condition> From<Payload<T, C>> for Ipld {
 
 impl<'a, T: Delegatable + Resolvable + Checkable + Clone, C: Condition> Payload<T, C> {
     pub fn check<U: Delegatable + Clone>(
-        invoked: &'a invocation::Payload<T>, // FIXME promisory version
+        invoked: &'a invoke::Payload<T>, // FIXME promisory version
         proofs: Vec<Payload<U, C>>,
         now: SystemTime,
     ) -> Result<(), ()>
     where
-        invocation::Payload<T>: Clone,
+        invoke::Payload<T>: Clone,
         U::Builder: Clone + Into<T::Hierarchy>,
-        T::Hierarchy: From<invocation::Payload<T>>,
+        T::Hierarchy: From<invoke::Payload<T>>,
     {
         let start: Acc<'a, T> = Acc {
             issuer: &invoked.issuer,

src/invocation.rs → src/invoke.rs

@@ -1,7 +1,10 @@
-pub mod payload;
-pub mod resolvable;
+mod payload;
+mod resolvable;
 mod serializer;
 
+pub use payload::Payload;
+pub use resolvable::Resolvable;
+
 use crate::signature;
 
 pub type Invocation<B> = signature::Envelope<payload::Payload<B>>;

src/ipld.rs

@@ -3,23 +3,23 @@ use libipld_core::ipld::Ipld;
 #[cfg(target_arch = "wasm32")]
 use wasm_bindgen::JsValue;
 
-pub struct WrappedIpld(pub Ipld);
+pub struct Newtype(pub Ipld);
 
-impl From<Ipld> for WrappedIpld {
+impl From<Ipld> for Newtype {
     fn from(ipld: Ipld) -> Self {
         Self(ipld)
     }
 }
 
-impl From<WrappedIpld> for Ipld {
-    fn from(wrapped: WrappedIpld) -> Self {
+impl From<Newtype> for Ipld {
+    fn from(wrapped: Newtype) -> Self {
         wrapped.0
     }
 }
 
 // TODO testme
 #[cfg(target_arch = "wasm32")]
-impl From<WrappedIpld> for JsValue {
+impl From<Newtype> for JsValue {
     fn from(wrapped: WrappedIpld) -> Self {
         match wrapped.0 {
             Ipld::Null => JsValue::Null,

src/lib.rs

@@ -114,14 +114,14 @@ use std::fmt::Debug;
 
 pub mod ability;
 pub mod capsule;
-pub mod delegation;
-pub mod invocation;
+pub mod delegate;
+pub mod invoke;
 pub mod ipld;
 pub mod nonce;
 pub mod number;
 pub mod promise;
 pub mod proof;
-pub mod receipt;
+pub mod respond;
 pub mod signature;
 pub mod task;
 

src/promise.rs

@@ -4,6 +4,8 @@ use libipld_core::{ipld::Ipld, serde as ipld_serde};
 use serde_derive::{Deserialize, Serialize};
 use std::fmt::Debug;
 
+// FIXME move under invoke?
+
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(untagged)]
 pub enum Promise<T> {

src/respond.rs

@@ -0,0 +1,9 @@
+mod payload;
+mod responds;
+
+pub use payload::Payload;
+pub use responds::Responds;
+
+use crate::signature;
+
+pub type Receipt<T> = signature::Envelope<Payload<T>>;

src/receipt/payload.rs → src/respond/payload.rs

@@ -1,11 +1,11 @@
-use super::runnable::Runnable;
+use super::responds::Responds;
 use crate::{capsule::Capsule, did::Did, nonce::Nonce, time::Timestamp};
 use libipld_core::{cid::Cid, ipld::Ipld, serde as ipld_serde};
-use serde::{de::DeserializeOwned, Deserialize, Serialize, Serializer};
+use serde::{de::DeserializeOwned, Deserialize, Serialize};
 use std::{collections::BTreeMap, fmt::Debug};
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct Payload<T: Runnable>
+pub struct Payload<T: Responds>
 where
     T::Success: Serialize + DeserializeOwned,
 {
@@ -22,14 +22,14 @@ where
     pub issued_at: Option<Timestamp>,
 }
 
-impl<T: Runnable> Capsule for Payload<T>
+impl<T: Responds> Capsule for Payload<T>
 where
     for<'de> T::Success: Serialize + Deserialize<'de>,
 {
     const TAG: &'static str = "ucan/r/1.0.0-rc.1"; // FIXME extract out version
 }
 
-impl<T: Runnable> TryFrom<Ipld> for Payload<T>
+impl<T: Responds> TryFrom<Ipld> for Payload<T>
 where
     for<'de> T::Success: Serialize + Deserialize<'de>,
 {
@@ -40,7 +40,7 @@ where
     }
 }
 
-impl<T: Runnable> From<Payload<T>> for Ipld
+impl<T: Responds> From<Payload<T>> for Ipld
 where
     for<'de> T::Success: Serialize + Deserialize<'de>,
 {

src/receipt/runnable.rs → src/respond/responds.rs

@@ -1,6 +1,6 @@
 use crate::{did::Did, nonce::Nonce, task, task::Task};
 
-pub trait Runnable {
+pub trait Responds {
     type Success;
 
     fn to_task(&self, subject: Did, nonce: Nonce) -> Task;