diff --git a/components/proto/src/app_server/serialize.rs b/components/proto/src/app_server/serialize.rs
index 6471037b4..b430dfe4c 100644
--- a/components/proto/src/app_server/serialize.rs
+++ b/components/proto/src/app_server/serialize.rs
@@ -1,12 +1,12 @@
 use std::io;
 
 use crate::capnp_common::{
-    read_custom_int128, read_custom_u_int128, read_invoice_id, read_named_index_server_address,
-    read_named_relay_address, read_public_key, /*read_receipt,*/ read_relay_address,
-    read_signature, read_uid, write_custom_int128, write_custom_u_int128, write_invoice_id,
-    write_named_index_server_address, write_named_relay_address,
-    write_public_key, /*write_receipt,*/
-    write_relay_address, write_signature, write_uid,
+    read_commit, read_custom_int128, read_custom_u_int128, read_invoice_id, read_multi_commit,
+    read_named_index_server_address, read_named_relay_address, read_payment_id, read_public_key,
+    read_rate, read_receipt, read_relay_address, read_signature, read_uid, write_commit,
+    write_custom_int128, write_custom_u_int128, write_invoice_id, write_multi_commit,
+    write_named_index_server_address, write_named_relay_address, write_payment_id,
+    write_public_key, write_rate, write_receipt, write_relay_address, write_signature, write_uid,
 };
 use capnp;
 use capnp::serialize_packed;
@@ -20,12 +20,15 @@ use crate::index_client::messages::{ClientResponseRoutes, ResponseRoutesResult};
 use crate::report::serialize::{
     deser_node_report, deser_node_report_mutation, ser_node_report, ser_node_report_mutation,
 };
-use index_server::serialize::{deser_request_routes, ser_request_routes};
+use index_server::serialize::{
+    deser_multi_route, deser_request_routes, ser_multi_route, ser_request_routes,
+};
 
 use crate::funder::messages::{
-    AddFriend, ReceiptAck,
-    ResetFriendChannel, /* ResponseReceived, ResponseSendFundsResult, */
-    SetFriendName, SetFriendRelays, SetFriendRemoteMaxDebt, UserRequestSendFunds,
+    AckClosePayment, AddFriend, AddInvoice, CreatePayment, CreateTransaction, PaymentStatus,
+    ReceiptAck, RequestResult, ResetFriendChannel, ResponseClosePayment, SetFriendName,
+    SetFriendRate, SetFriendRelays, SetFriendRemoteMaxDebt, TransactionResult,
+    UserRequestSendFunds,
 };
 use crate::funder::serialize::{deser_friends_route, ser_friends_route};
 
@@ -33,96 +36,6 @@ use crate::app_server::messages::{
     AppPermissions, AppRequest, AppServerToApp, AppToAppServer, ReportMutations,
 };
 
-fn ser_user_request_send_funds(
-    user_request_send_funds: &UserRequestSendFunds,
-    user_request_send_funds_builder: &mut app_server_capnp::user_request_send_funds::Builder,
-) {
-    unimplemented!();
-    /*
-    write_uid(
-        &user_request_send_funds.request_id,
-        &mut user_request_send_funds_builder.reborrow().init_request_id(),
-    );
-
-    let mut route_builder = user_request_send_funds_builder.reborrow().init_route();
-    ser_friends_route(&user_request_send_funds.route, &mut route_builder);
-
-    write_custom_u_int128(
-        user_request_send_funds.dest_payment,
-        &mut user_request_send_funds_builder
-            .reborrow()
-            .init_dest_payment(),
-    );
-
-    write_invoice_id(
-        &user_request_send_funds.invoice_id,
-        &mut user_request_send_funds_builder.reborrow().init_invoice_id(),
-    );
-    */
-}
-
-fn deser_user_request_send_funds(
-    user_request_send_funds_reader: &app_server_capnp::user_request_send_funds::Reader,
-) -> Result<UserRequestSendFunds, SerializeError> {
-    unimplemented!();
-    /*
-    Ok(UserRequestSendFunds {
-        request_id: read_uid(&user_request_send_funds_reader.get_request_id()?)?,
-        route: deser_friends_route(&user_request_send_funds_reader.get_route()?)?,
-        dest_payment: read_custom_u_int128(&user_request_send_funds_reader.get_dest_payment()?)?,
-        invoice_id: read_invoice_id(&user_request_send_funds_reader.get_invoice_id()?)?,
-    })
-    */
-}
-
-/*
-fn ser_response_received(
-    response_received: &ResponseReceived,
-    response_received_builder: &mut app_server_capnp::response_received::Builder,
-) {
-    unimplemented!();
-    write_uid(
-        &response_received.request_id,
-        &mut response_received_builder.reborrow().init_request_id(),
-    );
-
-    let result_builder = response_received_builder.reborrow().init_result();
-    match &response_received.result {
-        ResponseSendFundsResult::Success(receipt) => {
-            let mut success_builder = result_builder.init_success();
-            write_receipt(receipt, &mut success_builder);
-        }
-        ResponseSendFundsResult::Failure(public_key) => {
-            let mut failure_builder = result_builder.init_failure();
-            write_public_key(public_key, &mut failure_builder);
-        }
-    };
-}
-*/
-
-/*
-fn deser_response_received(
-    response_received_reader: &app_server_capnp::response_received::Reader,
-) -> Result<ResponseReceived, SerializeError> {
-    unimplemented!();
-    let result = match response_received_reader.get_result().which()? {
-        app_server_capnp::response_received::result::Success(receipt_reader) => {
-            let receipt_reader = receipt_reader?;
-            ResponseSendFundsResult::Success(read_receipt(&receipt_reader)?)
-        }
-        app_server_capnp::response_received::result::Failure(public_key_reader) => {
-            let public_key_reader = public_key_reader?;
-            ResponseSendFundsResult::Failure(read_public_key(&public_key_reader)?)
-        }
-    };
-
-    Ok(ResponseReceived {
-        request_id: read_uid(&response_received_reader.get_request_id()?)?,
-        result,
-    })
-}
-*/
-
 fn ser_receipt_ack(
     receipt_ack: &ReceiptAck,
     receipt_ack_builder: &mut app_server_capnp::receipt_ack::Builder,
@@ -303,42 +216,36 @@ fn ser_response_routes_result(
     response_routes_result: &ResponseRoutesResult,
     response_routes_result_builder: &mut app_server_capnp::response_routes_result::Builder,
 ) {
-    unimplemented!();
-    /*
     match response_routes_result {
-        ResponseRoutesResult::Success(routes_with_capacity) => {
-            let routes_len = usize_to_u32(routes_with_capacity.len()).unwrap();
-            let mut routes_with_capacity_builder = response_routes_result_builder
+        ResponseRoutesResult::Success(multi_routes) => {
+            let multi_routes_len = usize_to_u32(multi_routes.len()).unwrap();
+            let mut multi_routes_builder = response_routes_result_builder
                 .reborrow()
-                .init_success(routes_len);
-            for (index, route_with_capacity) in routes_with_capacity.iter().enumerate() {
-                let mut route_with_capacity_builder = routes_with_capacity_builder
+                .init_success(multi_routes_len);
+            for (index, multi_route) in multi_routes.iter().enumerate() {
+                let mut multi_route_builder = multi_routes_builder
                     .reborrow()
                     .get(usize_to_u32(index).unwrap());
-                ser_route_with_capacity(route_with_capacity, &mut route_with_capacity_builder);
+                ser_multi_route(multi_route, &mut multi_route_builder);
             }
         }
         ResponseRoutesResult::Failure => response_routes_result_builder.reborrow().set_failure(()),
     }
-    */
 }
 
 fn deser_response_routes_result(
     response_routes_result_reader: &app_server_capnp::response_routes_result::Reader,
 ) -> Result<ResponseRoutesResult, SerializeError> {
-    unimplemented!();
-    /*
     Ok(match response_routes_result_reader.which()? {
-        app_server_capnp::response_routes_result::Success(routes_with_capacity_reader) => {
-            let mut routes_with_capacity = Vec::new();
-            for route_with_capacity in routes_with_capacity_reader? {
-                routes_with_capacity.push(deser_route_with_capacity(&route_with_capacity)?);
+        app_server_capnp::response_routes_result::Success(multi_routes_reader) => {
+            let mut multi_routes = Vec::new();
+            for multi_route_reader in multi_routes_reader? {
+                multi_routes.push(deser_multi_route(&multi_route_reader)?);
             }
-            ResponseRoutesResult::Success(routes_with_capacity)
+            ResponseRoutesResult::Success(multi_routes)
         }
         app_server_capnp::response_routes_result::Failure(()) => ResponseRoutesResult::Failure,
     })
-    */
 }
 
 fn ser_client_response_routes(
@@ -388,32 +295,299 @@ fn ser_app_permissions(
     app_permissions: &AppPermissions,
     app_permissions_builder: &mut app_server_capnp::app_permissions::Builder,
 ) {
-    unimplemented!();
-    /*
     app_permissions_builder
         .reborrow()
         .set_routes(app_permissions.routes);
     app_permissions_builder
         .reborrow()
-        .set_send_funds(app_permissions.buyer);
+        .set_buyer(app_permissions.buyer);
+    app_permissions_builder
+        .reborrow()
+        .set_seller(app_permissions.seller);
     app_permissions_builder
         .reborrow()
         .set_config(app_permissions.config);
-    */
 }
 
 fn deser_app_permissions(
     app_permissions_reader: &app_server_capnp::app_permissions::Reader,
 ) -> Result<AppPermissions, SerializeError> {
-    unimplemented!();
-    /*
     Ok(AppPermissions {
         routes: app_permissions_reader.get_routes(),
-        buyer: app_permissions_reader.get_send_funds(),
-        seller: app_permissions_reader.get_send_funds(),
+        buyer: app_permissions_reader.get_buyer(),
+        seller: app_permissions_reader.get_seller(),
         config: app_permissions_reader.get_config(),
     })
-    */
+}
+
+fn ser_create_payment(
+    create_payment: &CreatePayment,
+    create_payment_builder: &mut app_server_capnp::create_payment::Builder,
+) {
+    write_payment_id(
+        &create_payment.payment_id,
+        &mut create_payment_builder.reborrow().init_payment_id(),
+    );
+
+    write_invoice_id(
+        &create_payment.invoice_id,
+        &mut create_payment_builder.reborrow().init_invoice_id(),
+    );
+
+    write_custom_u_int128(
+        create_payment.total_dest_payment,
+        &mut create_payment_builder.reborrow().init_total_dest_payment(),
+    );
+
+    write_public_key(
+        &create_payment.dest_public_key,
+        &mut create_payment_builder.reborrow().init_dest_public_key(),
+    );
+}
+
+fn deser_create_payment(
+    create_payment_reader: &app_server_capnp::create_payment::Reader,
+) -> Result<CreatePayment, SerializeError> {
+    Ok(CreatePayment {
+        payment_id: read_payment_id(&create_payment_reader.get_payment_id()?)?,
+        invoice_id: read_invoice_id(&create_payment_reader.get_invoice_id()?)?,
+        total_dest_payment: read_custom_u_int128(&create_payment_reader.get_total_dest_payment()?)?,
+        dest_public_key: read_public_key(&create_payment_reader.get_dest_public_key()?)?,
+    })
+}
+
+fn ser_create_transaction(
+    create_transaction: &CreateTransaction,
+    create_transaction_builder: &mut app_server_capnp::create_transaction::Builder,
+) {
+    write_payment_id(
+        &create_transaction.payment_id,
+        &mut create_transaction_builder.reborrow().init_payment_id(),
+    );
+
+    write_uid(
+        &create_transaction.request_id,
+        &mut create_transaction_builder.reborrow().init_request_id(),
+    );
+
+    ser_friends_route(
+        &create_transaction.route,
+        &mut create_transaction_builder.reborrow().init_route(),
+    );
+
+    write_custom_u_int128(
+        create_transaction.dest_payment,
+        &mut create_transaction_builder.reborrow().init_dest_payment(),
+    );
+
+    write_custom_u_int128(
+        create_transaction.fees,
+        &mut create_transaction_builder.reborrow().init_fees(),
+    );
+}
+
+fn deser_create_transaction(
+    create_transaction_reader: &app_server_capnp::create_transaction::Reader,
+) -> Result<CreateTransaction, SerializeError> {
+    Ok(CreateTransaction {
+        payment_id: read_payment_id(&create_transaction_reader.get_payment_id()?)?,
+        request_id: read_uid(&create_transaction_reader.get_request_id()?)?,
+        route: deser_friends_route(&create_transaction_reader.get_route()?)?,
+        dest_payment: read_custom_u_int128(&create_transaction_reader.get_dest_payment()?)?,
+        fees: read_custom_u_int128(&create_transaction_reader.get_fees()?)?,
+    })
+}
+
+fn ser_add_invoice(
+    add_invoice: &AddInvoice,
+    add_invoice_builder: &mut app_server_capnp::add_invoice::Builder,
+) {
+    write_invoice_id(
+        &add_invoice.invoice_id,
+        &mut add_invoice_builder.reborrow().init_invoice_id(),
+    );
+
+    write_custom_u_int128(
+        add_invoice.total_dest_payment,
+        &mut add_invoice_builder.reborrow().init_total_dest_payment(),
+    );
+}
+
+fn deser_add_invoice(
+    add_invoice_reader: &app_server_capnp::add_invoice::Reader,
+) -> Result<AddInvoice, SerializeError> {
+    Ok(AddInvoice {
+        invoice_id: read_invoice_id(&add_invoice_reader.get_invoice_id()?)?,
+        total_dest_payment: read_custom_u_int128(&add_invoice_reader.get_total_dest_payment()?)?,
+    })
+}
+
+fn ser_ack_close_payment(
+    ack_close_payment: &AckClosePayment,
+    ack_close_payment_builder: &mut app_server_capnp::ack_close_payment::Builder,
+) {
+    write_payment_id(
+        &ack_close_payment.payment_id,
+        &mut ack_close_payment_builder.reborrow().init_payment_id(),
+    );
+
+    write_uid(
+        &ack_close_payment.ack_uid,
+        &mut ack_close_payment_builder.reborrow().init_ack_uid(),
+    );
+}
+
+fn deser_ack_close_payment(
+    ack_close_payment_reader: &app_server_capnp::ack_close_payment::Reader,
+) -> Result<AckClosePayment, SerializeError> {
+    Ok(AckClosePayment {
+        payment_id: read_payment_id(&ack_close_payment_reader.get_payment_id()?)?,
+        ack_uid: read_uid(&ack_close_payment_reader.get_ack_uid()?)?,
+    })
+}
+
+fn ser_set_friend_rate(
+    set_friend_rate: &SetFriendRate,
+    set_friend_rate_builder: &mut app_server_capnp::set_friend_rate::Builder,
+) {
+    write_public_key(
+        &set_friend_rate.friend_public_key,
+        &mut set_friend_rate_builder.reborrow().init_friend_public_key(),
+    );
+
+    write_rate(
+        &set_friend_rate.rate,
+        &mut set_friend_rate_builder.reborrow().init_rate(),
+    );
+}
+
+fn deser_set_friend_rate(
+    set_friend_rate_reader: &app_server_capnp::set_friend_rate::Reader,
+) -> Result<SetFriendRate, SerializeError> {
+    Ok(SetFriendRate {
+        friend_public_key: read_public_key(&set_friend_rate_reader.get_friend_public_key()?)?,
+        rate: read_rate(&set_friend_rate_reader.get_rate()?)?,
+    })
+}
+
+fn ser_request_result(
+    request_result: &RequestResult,
+    request_result_builder: &mut app_server_capnp::request_result::Builder,
+) {
+    match request_result {
+        RequestResult::Success(commit) => {
+            write_commit(
+                commit,
+                &mut request_result_builder.reborrow().init_success(),
+            );
+        }
+        RequestResult::Failure => request_result_builder.reborrow().set_failure(()),
+    }
+}
+
+fn deser_request_result(
+    request_result_reader: &app_server_capnp::request_result::Reader,
+) -> Result<RequestResult, SerializeError> {
+    Ok(match request_result_reader.which()? {
+        app_server_capnp::request_result::Success(commit_reader) => {
+            RequestResult::Success(read_commit(&commit_reader?)?)
+        }
+        app_server_capnp::request_result::Failure(()) => RequestResult::Failure,
+    })
+}
+
+fn ser_transaction_result(
+    transaction_result: &TransactionResult,
+    transaction_result_builder: &mut app_server_capnp::transaction_result::Builder,
+) {
+    write_uid(
+        &transaction_result.request_id,
+        &mut transaction_result_builder.reborrow().init_request_id(),
+    );
+
+    ser_request_result(
+        &transaction_result.result,
+        &mut transaction_result_builder.reborrow().init_result(),
+    );
+}
+
+fn deser_transaction_result(
+    transaction_result_reader: &app_server_capnp::transaction_result::Reader,
+) -> Result<TransactionResult, SerializeError> {
+    Ok(TransactionResult {
+        request_id: read_uid(&transaction_result_reader.get_request_id()?)?,
+        result: deser_request_result(&transaction_result_reader.get_result()?)?,
+    })
+}
+
+fn ser_payment_status(
+    payment_status: &PaymentStatus,
+    payment_status_builder: &mut app_server_capnp::payment_status::Builder,
+) {
+    match payment_status {
+        PaymentStatus::PaymentNotFound => {
+            payment_status_builder.reborrow().set_payment_not_found(())
+        }
+        PaymentStatus::InProgress => payment_status_builder.reborrow().set_in_progress(()),
+        PaymentStatus::Success((receipt, ack_uid)) => {
+            let mut payment_success_builder = payment_status_builder.reborrow().init_success();
+            write_receipt(
+                receipt,
+                &mut payment_success_builder.reborrow().init_receipt(),
+            );
+            write_uid(
+                ack_uid,
+                &mut payment_success_builder.reborrow().init_ack_uid(),
+            );
+        }
+        PaymentStatus::Canceled(ack_uid) => {
+            let mut ack_uid_builder = payment_status_builder.reborrow().init_canceled();
+            write_uid(ack_uid, &mut ack_uid_builder);
+        }
+    }
+}
+
+fn deser_payment_status(
+    payment_status_reader: &app_server_capnp::payment_status::Reader,
+) -> Result<PaymentStatus, SerializeError> {
+    Ok(match payment_status_reader.which()? {
+        app_server_capnp::payment_status::PaymentNotFound(()) => PaymentStatus::PaymentNotFound,
+        app_server_capnp::payment_status::InProgress(()) => PaymentStatus::InProgress,
+        app_server_capnp::payment_status::Success(res_payment_success_reader) => {
+            let payment_success_reader = res_payment_success_reader?;
+            PaymentStatus::Success((
+                read_receipt(&payment_success_reader.get_receipt()?)?,
+                read_uid(&payment_success_reader.get_ack_uid()?)?,
+            ))
+        }
+        app_server_capnp::payment_status::Canceled(ack_uid_reader) => {
+            PaymentStatus::Canceled(read_uid(&ack_uid_reader?)?)
+        }
+    })
+}
+
+fn ser_response_close_payment(
+    response_close_payment: &ResponseClosePayment,
+    response_close_payment_builder: &mut app_server_capnp::response_close_payment::Builder,
+) {
+    write_payment_id(
+        &response_close_payment.payment_id,
+        &mut response_close_payment_builder.reborrow().init_payment_id(),
+    );
+
+    ser_payment_status(
+        &response_close_payment.status,
+        &mut response_close_payment_builder.reborrow().init_status(),
+    );
+}
+
+fn deser_response_close_payment(
+    response_close_payment_reader: &app_server_capnp::response_close_payment::Reader,
+) -> Result<ResponseClosePayment, SerializeError> {
+    Ok(ResponseClosePayment {
+        payment_id: read_payment_id(&response_close_payment_reader.get_payment_id()?)?,
+        status: deser_payment_status(&response_close_payment_reader.get_status()?)?,
+    })
 }
 
 fn ser_report_mutations(
@@ -470,14 +644,18 @@ fn ser_app_server_to_app(
     app_server_to_app: &AppServerToApp,
     app_server_to_app_builder: &mut app_server_capnp::app_server_to_app::Builder,
 ) {
-    unimplemented!();
-    /*
     match app_server_to_app {
-        AppServerToApp::ResponseReceived(response_received) => ser_response_received(
-            response_received,
+        AppServerToApp::TransactionResult(transaction_result) => ser_transaction_result(
+            transaction_result,
             &mut app_server_to_app_builder
                 .reborrow()
-                .init_response_received(),
+                .init_transaction_result(),
+        ),
+        AppServerToApp::ResponseClosePayment(response_close_payment) => ser_response_close_payment(
+            response_close_payment,
+            &mut app_server_to_app_builder
+                .reborrow()
+                .init_response_close_payment(),
         ),
         AppServerToApp::Report(node_report) => ser_node_report(
             node_report,
@@ -492,18 +670,22 @@ fn ser_app_server_to_app(
             &mut app_server_to_app_builder.reborrow().init_response_routes(),
         ),
     }
-    */
 }
 
 fn deser_app_server_to_app(
     app_server_to_app_reader: &app_server_capnp::app_server_to_app::Reader,
 ) -> Result<AppServerToApp, SerializeError> {
-    unimplemented!();
-    /*
     Ok(match app_server_to_app_reader.which()? {
-        app_server_capnp::app_server_to_app::ResponseReceived(response_received_reader) => {
-            AppServerToApp::ResponseReceived(deser_response_received(&response_received_reader?)?)
+        app_server_capnp::app_server_to_app::TransactionResult(transaction_result_reader) => {
+            AppServerToApp::TransactionResult(deser_transaction_result(
+                &transaction_result_reader?,
+            )?)
         }
+        app_server_capnp::app_server_to_app::ResponseClosePayment(
+            response_close_payment_reader,
+        ) => AppServerToApp::ResponseClosePayment(deser_response_close_payment(
+            &response_close_payment_reader?,
+        )?),
         app_server_capnp::app_server_to_app::Report(node_report_reader) => {
             AppServerToApp::Report(deser_node_report(&node_report_reader?)?)
         }
@@ -516,15 +698,12 @@ fn deser_app_server_to_app(
             )?)
         }
     })
-    */
 }
 
 fn ser_app_request(
     app_request: &AppRequest,
     app_request_builder: &mut app_server_capnp::app_request::Builder,
 ) {
-    unimplemented!();
-    /*
     match app_request {
         AppRequest::AddRelay(named_relay_address) => write_named_relay_address(
             named_relay_address,
@@ -534,13 +713,33 @@ fn ser_app_request(
             public_key,
             &mut app_request_builder.reborrow().init_remove_relay(),
         ),
-        AppRequest::RequestSendFunds(user_request_send_funds) => ser_user_request_send_funds(
-            user_request_send_funds,
-            &mut app_request_builder.reborrow().init_request_send_funds(),
+        AppRequest::CreatePayment(create_payment) => ser_create_payment(
+            create_payment,
+            &mut app_request_builder.reborrow().init_create_payment(),
+        ),
+        AppRequest::CreateTransaction(create_transaction) => ser_create_transaction(
+            create_transaction,
+            &mut app_request_builder.reborrow().init_create_transaction(),
+        ),
+        AppRequest::RequestClosePayment(payment_id) => write_payment_id(
+            payment_id,
+            &mut app_request_builder.reborrow().init_request_close_payment(),
+        ),
+        AppRequest::AckClosePayment(ack_close_payment) => ser_ack_close_payment(
+            ack_close_payment,
+            &mut app_request_builder.reborrow().init_ack_close_payment(),
+        ),
+        AppRequest::AddInvoice(add_invoice) => ser_add_invoice(
+            add_invoice,
+            &mut app_request_builder.reborrow().init_add_invoice(),
+        ),
+        AppRequest::CancelInvoice(invoice_id) => write_invoice_id(
+            invoice_id,
+            &mut app_request_builder.reborrow().init_cancel_invoice(),
         ),
-        AppRequest::ReceiptAck(receipt_ack) => ser_receipt_ack(
-            receipt_ack,
-            &mut app_request_builder.reborrow().init_receipt_ack(),
+        AppRequest::CommitInvoice(multi_commit) => write_multi_commit(
+            multi_commit,
+            &mut app_request_builder.reborrow().init_commit_invoice(),
         ),
         AppRequest::AddFriend(add_friend) => ser_add_friend(
             add_friend,
@@ -582,6 +781,10 @@ fn ser_app_request(
                     .init_set_friend_remote_max_debt(),
             )
         }
+        AppRequest::SetFriendRate(set_friend_rate) => ser_set_friend_rate(
+            set_friend_rate,
+            &mut app_request_builder.reborrow().init_set_friend_rate(),
+        ),
         AppRequest::ResetFriendChannel(reset_friend_channel) => ser_reset_friend_channel(
             reset_friend_channel,
             &mut app_request_builder.reborrow().init_reset_friend_channel(),
@@ -601,14 +804,11 @@ fn ser_app_request(
             &mut app_request_builder.reborrow().init_remove_index_server(),
         ),
     }
-    */
 }
 
 fn deser_app_request(
     app_request: &app_server_capnp::app_request::Reader,
 ) -> Result<AppRequest, SerializeError> {
-    unimplemented!();
-    /*
     Ok(match app_request.which()? {
         app_server_capnp::app_request::AddRelay(named_relay_address_reader) => {
             AppRequest::AddRelay(read_named_relay_address(&named_relay_address_reader?)?)
@@ -616,13 +816,26 @@ fn deser_app_request(
         app_server_capnp::app_request::RemoveRelay(public_key_reader) => {
             AppRequest::RemoveRelay(read_public_key(&public_key_reader?)?)
         }
-        app_server_capnp::app_request::RequestSendFunds(request_send_funds_reader) => {
-            AppRequest::RequestSendFunds(deser_user_request_send_funds(
-                &request_send_funds_reader?,
-            )?)
+        app_server_capnp::app_request::CreatePayment(create_payment_reader) => {
+            AppRequest::CreatePayment(deser_create_payment(&create_payment_reader?)?)
+        }
+        app_server_capnp::app_request::CreateTransaction(create_transaction_reader) => {
+            AppRequest::CreateTransaction(deser_create_transaction(&create_transaction_reader?)?)
+        }
+        app_server_capnp::app_request::RequestClosePayment(payment_id_reader) => {
+            AppRequest::RequestClosePayment(read_payment_id(&payment_id_reader?)?)
+        }
+        app_server_capnp::app_request::AckClosePayment(ack_close_payment_reader) => {
+            AppRequest::AckClosePayment(deser_ack_close_payment(&ack_close_payment_reader?)?)
         }
-        app_server_capnp::app_request::ReceiptAck(receipt_ack_reader) => {
-            AppRequest::ReceiptAck(deser_receipt_ack(&receipt_ack_reader?)?)
+        app_server_capnp::app_request::AddInvoice(add_invoice_reader) => {
+            AppRequest::AddInvoice(deser_add_invoice(&add_invoice_reader?)?)
+        }
+        app_server_capnp::app_request::CancelInvoice(invoice_id_reader) => {
+            AppRequest::CancelInvoice(read_invoice_id(&invoice_id_reader?)?)
+        }
+        app_server_capnp::app_request::CommitInvoice(multi_commit_reader) => {
+            AppRequest::CommitInvoice(read_multi_commit(&multi_commit_reader?)?)
         }
         app_server_capnp::app_request::AddFriend(add_friend_reader) => {
             AppRequest::AddFriend(deser_add_friend(&add_friend_reader?)?)
@@ -648,6 +861,9 @@ fn deser_app_request(
         app_server_capnp::app_request::CloseFriend(public_key_reader) => {
             AppRequest::CloseFriend(read_public_key(&public_key_reader?)?)
         }
+        app_server_capnp::app_request::SetFriendRate(set_friend_rate_reader) => {
+            AppRequest::SetFriendRate(deser_set_friend_rate(&set_friend_rate_reader?)?)
+        }
         app_server_capnp::app_request::SetFriendRemoteMaxDebt(
             set_friend_remote_max_debt_reader,
         ) => AppRequest::SetFriendRemoteMaxDebt(deser_set_friend_remote_max_debt(
@@ -668,7 +884,6 @@ fn deser_app_request(
             AppRequest::RemoveIndexServer(read_public_key(&public_key_reader?)?)
         }
     })
-    */
 }
 
 fn ser_app_to_app_server(
@@ -757,7 +972,6 @@ pub fn deserialize_app_to_app_server(data: &[u8]) -> Result<AppToAppServer, Seri
     deser_app_to_app_server(&app_to_app_server)
 }
 
-/*
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -772,8 +986,9 @@ mod tests {
     fn test_serialize_app_permissions() {
         let app_permissions = AppPermissions {
             routes: false,
-            send_funds: true,
-            config: false,
+            buyer: true,
+            seller: false,
+            config: true,
         };
 
         let data = serialize_app_permissions(&app_permissions);
@@ -837,4 +1052,3 @@ mod tests {
 
     // TODO: More tests are required here
 }
-*/
diff --git a/components/proto/src/capnp_common.rs b/components/proto/src/capnp_common.rs
index b7b8cb50e..094e99ef8 100644
--- a/components/proto/src/capnp_common.rs
+++ b/components/proto/src/capnp_common.rs
@@ -2,14 +2,17 @@ use byteorder::{BigEndian, ByteOrder, ReadBytesExt, WriteBytesExt};
 use std::convert::{TryFrom, TryInto};
 use std::io;
 
+use common::int_convert::usize_to_u32;
+
 use common_capnp::{
-    buffer128, buffer256, buffer512, custom_int128, custom_u_int128, dh_public_key, hash,
-    invoice_id, named_index_server_address, named_relay_address, net_address, public_key,
-    rand_nonce, receipt, relay_address, salt, signature, uid,
+    buffer128, buffer256, buffer512, commit, custom_int128, custom_u_int128, dh_public_key, hash,
+    hashed_lock, invoice_id, multi_commit, named_index_server_address, named_relay_address,
+    net_address, payment_id, plain_lock, public_key, rand_nonce, rate, receipt, relay_address,
+    salt, signature, uid,
 };
 
 use crate::app_server::messages::{NamedRelayAddress, RelayAddress};
-use crate::funder::messages::Receipt;
+use crate::funder::messages::{Commit, MultiCommit, Rate, Receipt};
 use crate::index_server::messages::NamedIndexServerAddress;
 use crate::net::messages::NetAddress;
 use crate::serialize::SerializeError;
@@ -17,8 +20,10 @@ use crate::serialize::SerializeError;
 use crypto::crypto_rand::RandValue;
 use crypto::dh::{DhPublicKey, Salt};
 use crypto::hash::HashResult;
+use crypto::hash_lock::{HashedLock, PlainLock};
 use crypto::identity::{PublicKey, Signature};
 use crypto::invoice_id::InvoiceId;
+use crypto::payment_id::PaymentId;
 use crypto::uid::Uid;
 
 /// Read the underlying bytes from given `CustomUInt128` reader.
@@ -149,6 +154,7 @@ type_capnp_serde!(
     read_buffer256,
     write_buffer256
 );
+
 type_capnp_serde!(
     invoice_id,
     InvoiceId,
@@ -158,6 +164,15 @@ type_capnp_serde!(
     write_buffer256
 );
 
+type_capnp_serde!(
+    payment_id,
+    PaymentId,
+    read_payment_id,
+    write_payment_id,
+    read_buffer128,
+    write_buffer128
+);
+
 // 512 bits:
 type_capnp_serde!(
     signature,
@@ -168,6 +183,26 @@ type_capnp_serde!(
     write_buffer512
 );
 
+// 256 bits:
+type_capnp_serde!(
+    plain_lock,
+    PlainLock,
+    read_plain_lock,
+    write_plain_lock,
+    read_buffer256,
+    write_buffer256
+);
+
+// 256 bits:
+type_capnp_serde!(
+    hashed_lock,
+    HashedLock,
+    read_hashed_lock,
+    write_hashed_lock,
+    read_buffer256,
+    write_buffer256
+);
+
 pub fn read_custom_u_int128(from: &custom_u_int128::Reader) -> Result<u128, SerializeError> {
     let inner = from.get_inner()?;
     let data_bytes = read_buffer128(&inner);
@@ -270,23 +305,98 @@ pub fn write_index_server_address(from: &IndexServerAddress, to: &mut index_serv
 */
 
 pub fn read_receipt(from: &receipt::Reader) -> Result<Receipt, SerializeError> {
-    unimplemented!();
-    /*
     Ok(Receipt {
         response_hash: read_hash(&from.get_response_hash()?)?,
         invoice_id: read_invoice_id(&from.get_invoice_id()?)?,
+        src_plain_lock: read_plain_lock(&from.get_src_plain_lock()?)?,
+        dest_plain_lock: read_plain_lock(&from.get_dest_plain_lock()?)?,
         dest_payment: read_custom_u_int128(&from.get_dest_payment()?)?,
+        total_dest_payment: read_custom_u_int128(&from.get_total_dest_payment()?)?,
         signature: read_signature(&from.get_signature()?)?,
     })
-    */
 }
 
 pub fn write_receipt(from: &Receipt, to: &mut receipt::Builder) {
-    unimplemented!();
-    /*
     write_hash(&from.response_hash, &mut to.reborrow().init_response_hash());
     write_invoice_id(&from.invoice_id, &mut to.reborrow().init_invoice_id());
+    write_plain_lock(
+        &from.src_plain_lock,
+        &mut to.reborrow().init_src_plain_lock(),
+    );
+    write_plain_lock(
+        &from.dest_plain_lock,
+        &mut to.reborrow().init_dest_plain_lock(),
+    );
     write_custom_u_int128(from.dest_payment, &mut to.reborrow().init_dest_payment());
+    write_custom_u_int128(
+        from.total_dest_payment,
+        &mut to.reborrow().init_total_dest_payment(),
+    );
     write_signature(&from.signature, &mut to.reborrow().init_signature());
-    */
+}
+
+pub fn read_commit(from: &commit::Reader) -> Result<Commit, SerializeError> {
+    Ok(Commit {
+        response_hash: read_hash(&from.get_response_hash()?)?,
+        dest_payment: read_custom_u_int128(&from.get_dest_payment()?)?,
+        src_plain_lock: read_plain_lock(&from.get_src_plain_lock()?)?,
+        dest_hashed_lock: read_hashed_lock(&from.get_dest_hashed_lock()?)?,
+        signature: read_signature(&from.get_signature()?)?,
+    })
+}
+
+pub fn write_commit(from: &Commit, to: &mut commit::Builder) {
+    write_hash(&from.response_hash, &mut to.reborrow().init_response_hash());
+    write_custom_u_int128(from.dest_payment, &mut to.reborrow().init_dest_payment());
+    write_plain_lock(
+        &from.src_plain_lock,
+        &mut to.reborrow().init_src_plain_lock(),
+    );
+    write_hashed_lock(
+        &from.dest_hashed_lock,
+        &mut to.reborrow().init_dest_hashed_lock(),
+    );
+    write_signature(&from.signature, &mut to.reborrow().init_signature());
+}
+
+pub fn read_multi_commit(from: &multi_commit::Reader) -> Result<MultiCommit, SerializeError> {
+    let mut commits = Vec::new();
+    for commit_reader in from.get_commits()? {
+        commits.push(read_commit(&commit_reader)?);
+    }
+
+    Ok(MultiCommit {
+        invoice_id: read_invoice_id(&from.get_invoice_id()?)?,
+        total_dest_payment: read_custom_u_int128(&from.get_total_dest_payment()?)?,
+        commits,
+    })
+}
+
+pub fn write_multi_commit(from: &MultiCommit, to: &mut multi_commit::Builder) {
+    write_invoice_id(&from.invoice_id, &mut to.reborrow().init_invoice_id());
+    write_custom_u_int128(
+        from.total_dest_payment,
+        &mut to.reborrow().init_total_dest_payment(),
+    );
+
+    let mut commits_builder = to
+        .reborrow()
+        .init_commits(usize_to_u32(from.commits.len()).unwrap());
+
+    for (index, commit) in from.commits.iter().enumerate() {
+        let mut commit_builder = commits_builder.reborrow().get(usize_to_u32(index).unwrap());
+        write_commit(commit, &mut commit_builder);
+    }
+}
+
+pub fn read_rate(from: &rate::Reader) -> Result<Rate, SerializeError> {
+    Ok(Rate {
+        mul: from.get_mul(),
+        add: from.get_add(),
+    })
+}
+
+pub fn write_rate(from: &Rate, to: &mut rate::Builder) {
+    to.reborrow().set_mul(from.mul);
+    to.reborrow().set_add(from.add);
 }
diff --git a/components/proto/src/funder/serialize.rs b/components/proto/src/funder/serialize.rs
index d013847ff..392f271da 100644
--- a/components/proto/src/funder/serialize.rs
+++ b/components/proto/src/funder/serialize.rs
@@ -1,8 +1,9 @@
 use crate::capnp_common::{
-    read_custom_int128, read_custom_u_int128, /*read_invoice_id,*/ read_public_key,
-    read_rand_nonce, read_relay_address, read_signature, read_uid, write_custom_int128,
-    write_custom_u_int128, write_invoice_id, write_public_key, write_rand_nonce,
-    write_relay_address, write_signature, write_uid,
+    read_custom_int128, read_custom_u_int128, read_hashed_lock, read_invoice_id, read_plain_lock,
+    read_public_key, read_rand_nonce, read_relay_address, read_signature, read_uid,
+    write_custom_int128, write_custom_u_int128, write_hashed_lock, write_invoice_id,
+    write_plain_lock, write_public_key, write_rand_nonce, write_relay_address, write_signature,
+    write_uid,
 };
 use capnp;
 use capnp::serialize_packed;
@@ -12,8 +13,8 @@ use std::io;
 use funder_capnp;
 
 use super::messages::{
-    CancelSendFundsOp, FriendMessage, FriendTcOp, FriendsRoute, MoveToken, MoveTokenRequest,
-    RequestSendFundsOp, ResetTerms, ResponseSendFundsOp,
+    CancelSendFundsOp, CollectSendFundsOp, FriendMessage, FriendTcOp, FriendsRoute, MoveToken,
+    MoveTokenRequest, RequestSendFundsOp, ResetTerms, ResponseSendFundsOp,
 };
 
 use crate::serialize::SerializeError;
@@ -44,6 +45,13 @@ fn ser_request_send_funds_op(
         &mut request_send_funds_op_builder.reborrow().init_request_id(),
     );
 
+    write_hashed_lock(
+        &request_send_funds.src_hashed_lock,
+        &mut request_send_funds_op_builder
+            .reborrow()
+            .init_src_hashed_lock(),
+    );
+
     let mut route_builder = request_send_funds_op_builder.reborrow().init_route();
     ser_friends_route(&request_send_funds.route, &mut route_builder);
 
@@ -52,10 +60,22 @@ fn ser_request_send_funds_op(
         &mut request_send_funds_op_builder.reborrow().init_dest_payment(),
     );
 
+    write_custom_u_int128(
+        request_send_funds.total_dest_payment,
+        &mut request_send_funds_op_builder
+            .reborrow()
+            .init_total_dest_payment(),
+    );
+
     write_invoice_id(
         &request_send_funds.invoice_id,
         &mut request_send_funds_op_builder.reborrow().init_invoice_id(),
     );
+
+    write_custom_u_int128(
+        request_send_funds.left_fees,
+        &mut request_send_funds_op_builder.reborrow().init_left_fees(),
+    );
 }
 
 fn ser_response_send_funds_op(
@@ -66,6 +86,14 @@ fn ser_response_send_funds_op(
         &response_send_funds.request_id,
         &mut response_send_funds_op_builder.reborrow().init_request_id(),
     );
+
+    write_hashed_lock(
+        &response_send_funds.dest_hashed_lock,
+        &mut response_send_funds_op_builder
+            .reborrow()
+            .init_dest_hashed_lock(),
+    );
+
     write_rand_nonce(
         &response_send_funds.rand_nonce,
         &mut response_send_funds_op_builder.reborrow().init_rand_nonce(),
@@ -78,37 +106,42 @@ fn ser_response_send_funds_op(
 
 fn ser_cancel_send_funds_op(
     cancel_send_funds: &CancelSendFundsOp,
-    cancel_send_funds_op_builder: &mut funder_capnp::failure_send_funds_op::Builder,
+    cancel_send_funds_op_builder: &mut funder_capnp::cancel_send_funds_op::Builder,
 ) {
-    unimplemented!();
-    /*
     write_uid(
         &cancel_send_funds.request_id,
         &mut cancel_send_funds_op_builder.reborrow().init_request_id(),
     );
-    write_public_key(
-        &cancel_send_funds.reporting_public_key,
-        &mut cancel_send_funds_op_builder
-            .reborrow()
-            .init_reporting_public_key(),
+}
+
+fn ser_collect_send_funds_op(
+    collect_send_funds: &CollectSendFundsOp,
+    collect_send_funds_op_builder: &mut funder_capnp::collect_send_funds_op::Builder,
+) {
+    write_uid(
+        &collect_send_funds.request_id,
+        &mut collect_send_funds_op_builder.reborrow().init_request_id(),
     );
-    write_rand_nonce(
-        &cancel_send_funds.rand_nonce,
-        &mut cancel_send_funds_op_builder.reborrow().init_rand_nonce(),
+
+    write_plain_lock(
+        &collect_send_funds.src_plain_lock,
+        &mut collect_send_funds_op_builder
+            .reborrow()
+            .init_src_plain_lock(),
     );
-    write_signature(
-        &cancel_send_funds.signature,
-        &mut cancel_send_funds_op_builder.reborrow().init_signature(),
+
+    write_plain_lock(
+        &collect_send_funds.dest_plain_lock,
+        &mut collect_send_funds_op_builder
+            .reborrow()
+            .init_dest_plain_lock(),
     );
-    */
 }
 
 fn ser_friend_operation(
     operation: &FriendTcOp,
     operation_builder: &mut funder_capnp::friend_operation::Builder,
 ) {
-    unimplemented!();
-    /*
     match operation {
         FriendTcOp::EnableRequests => operation_builder.set_enable_requests(()),
         FriendTcOp::DisableRequests => operation_builder.set_disable_requests(()),
@@ -132,8 +165,12 @@ fn ser_friend_operation(
                 operation_builder.reborrow().init_cancel_send_funds();
             ser_cancel_send_funds_op(cancel_send_funds, &mut cancel_send_funds_builder);
         }
+        FriendTcOp::CollectSendFunds(collect_send_funds) => {
+            let mut collect_send_funds_builder =
+                operation_builder.reborrow().init_collect_send_funds();
+            ser_collect_send_funds_op(collect_send_funds, &mut collect_send_funds_builder);
+        }
     };
-    */
 }
 
 fn ser_move_token(
@@ -284,51 +321,51 @@ pub fn deser_friends_route(
 fn deser_request_send_funds_op(
     request_send_funds_op_reader: &funder_capnp::request_send_funds_op::Reader,
 ) -> Result<RequestSendFundsOp, SerializeError> {
-    unimplemented!();
-    /*
-    Ok(RequestSendFunds {
+    Ok(RequestSendFundsOp {
         request_id: read_uid(&request_send_funds_op_reader.get_request_id()?)?,
+        src_hashed_lock: read_hashed_lock(&request_send_funds_op_reader.get_src_hashed_lock()?)?,
         route: deser_friends_route(&request_send_funds_op_reader.get_route()?)?,
         dest_payment: read_custom_u_int128(&request_send_funds_op_reader.get_dest_payment()?)?,
+        total_dest_payment: read_custom_u_int128(
+            &request_send_funds_op_reader.get_total_dest_payment()?,
+        )?,
         invoice_id: read_invoice_id(&request_send_funds_op_reader.get_invoice_id()?)?,
+        left_fees: read_custom_u_int128(&request_send_funds_op_reader.get_left_fees()?)?,
     })
-    */
 }
 
 fn deser_response_send_funds_op(
     response_send_funds_op_reader: &funder_capnp::response_send_funds_op::Reader,
 ) -> Result<ResponseSendFundsOp, SerializeError> {
-    unimplemented!();
-    /*
-    Ok(ResponseSendFunds {
+    Ok(ResponseSendFundsOp {
         request_id: read_uid(&response_send_funds_op_reader.get_request_id()?)?,
+        dest_hashed_lock: read_hashed_lock(&response_send_funds_op_reader.get_dest_hashed_lock()?)?,
         rand_nonce: read_rand_nonce(&response_send_funds_op_reader.get_rand_nonce()?)?,
         signature: read_signature(&response_send_funds_op_reader.get_signature()?)?,
     })
-    */
 }
 
 fn deser_cancel_send_funds_op(
-    cancel_send_funds_op_reader: &funder_capnp::failure_send_funds_op::Reader,
+    cancel_send_funds_op_reader: &funder_capnp::cancel_send_funds_op::Reader,
 ) -> Result<CancelSendFundsOp, SerializeError> {
-    unimplemented!();
-    /*
     Ok(CancelSendFundsOp {
         request_id: read_uid(&cancel_send_funds_op_reader.get_request_id()?)?,
-        reporting_public_key: read_public_key(
-            &cancel_send_funds_op_reader.get_reporting_public_key()?,
-        )?,
-        rand_nonce: read_rand_nonce(&cancel_send_funds_op_reader.get_rand_nonce()?)?,
-        signature: read_signature(&cancel_send_funds_op_reader.get_signature()?)?,
     })
-    */
+}
+
+fn deser_collect_send_funds_op(
+    collect_send_funds_op_reader: &funder_capnp::collect_send_funds_op::Reader,
+) -> Result<CollectSendFundsOp, SerializeError> {
+    Ok(CollectSendFundsOp {
+        request_id: read_uid(&collect_send_funds_op_reader.get_request_id()?)?,
+        src_plain_lock: read_plain_lock(&collect_send_funds_op_reader.get_src_plain_lock()?)?,
+        dest_plain_lock: read_plain_lock(&collect_send_funds_op_reader.get_dest_plain_lock()?)?,
+    })
 }
 
 fn deser_friend_operation(
     friend_operation_reader: &funder_capnp::friend_operation::Reader,
 ) -> Result<FriendTcOp, SerializeError> {
-    unimplemented!();
-    /*
     Ok(match friend_operation_reader.which()? {
         funder_capnp::friend_operation::EnableRequests(()) => FriendTcOp::EnableRequests,
         funder_capnp::friend_operation::DisableRequests(()) => FriendTcOp::DisableRequests,
@@ -346,8 +383,10 @@ fn deser_friend_operation(
         funder_capnp::friend_operation::CancelSendFunds(cancel_send_funds_reader) => {
             FriendTcOp::CancelSendFunds(deser_cancel_send_funds_op(&cancel_send_funds_reader?)?)
         }
+        funder_capnp::friend_operation::CollectSendFunds(collect_send_funds_reader) => {
+            FriendTcOp::CollectSendFunds(deser_collect_send_funds_op(&collect_send_funds_reader?)?)
+        }
     })
-    */
 }
 
 fn deser_move_token(
@@ -435,12 +474,12 @@ pub fn deserialize_friend_message(data: &[u8]) -> Result<FriendMessage, Serializ
     deser_friend_message(&friend_message_reader)
 }
 
-/*
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::app_server::messages::RelayAddress;
     use crypto::crypto_rand::{RandValue, RAND_VALUE_LEN};
+    use crypto::hash_lock::{HashedLock, PlainLock, HASHED_LOCK_LEN, PLAIN_LOCK_LEN};
     use crypto::identity::{PublicKey, Signature, PUBLIC_KEY_LEN, SIGNATURE_LEN};
     use crypto::invoice_id::{InvoiceId, INVOICE_ID_LEN};
     use crypto::uid::{Uid, UID_LEN};
@@ -459,21 +498,28 @@ mod tests {
 
         let request_send_funds = RequestSendFundsOp {
             request_id: Uid::from(&[22; UID_LEN]),
+            src_hashed_lock: HashedLock::from(&[1u8; HASHED_LOCK_LEN]),
             route,
             dest_payment: 48,
+            total_dest_payment: 60,
             invoice_id: InvoiceId::from(&[0x99; INVOICE_ID_LEN]),
+            left_fees: 14,
         };
         let response_send_funds = ResponseSendFundsOp {
             request_id: Uid::from(&[10; UID_LEN]),
+            dest_hashed_lock: HashedLock::from(&[2u8; HASHED_LOCK_LEN]),
             rand_nonce: RandValue::from(&[0xbb; RAND_VALUE_LEN]),
             signature: Signature::from(&[3; SIGNATURE_LEN]),
         };
 
         let cancel_send_funds = CancelSendFundsOp {
             request_id: Uid::from(&[10; UID_LEN]),
-            reporting_public_key: PublicKey::from(&[0x11; PUBLIC_KEY_LEN]),
-            rand_nonce: RandValue::from(&[0xbb; RAND_VALUE_LEN]),
-            signature: Signature::from(&[3; SIGNATURE_LEN]),
+        };
+
+        let collect_send_funds = CollectSendFundsOp {
+            request_id: Uid::from(&[10; UID_LEN]),
+            src_plain_lock: PlainLock::from(&[4u8; PLAIN_LOCK_LEN]),
+            dest_plain_lock: PlainLock::from(&[5u8; PLAIN_LOCK_LEN]),
         };
 
         let operations = vec![
@@ -483,6 +529,7 @@ mod tests {
             FriendTcOp::RequestSendFunds(request_send_funds),
             FriendTcOp::ResponseSendFunds(response_send_funds),
             FriendTcOp::CancelSendFunds(cancel_send_funds),
+            FriendTcOp::CollectSendFunds(collect_send_funds),
         ];
 
         let relay_address4 = RelayAddress {
@@ -543,4 +590,3 @@ mod tests {
         assert_eq!(friend_message, friend_message2);
     }
 }
-*/
diff --git a/components/proto/src/index_server/serialize.rs b/components/proto/src/index_server/serialize.rs
index 0d88248bb..9394a456b 100644
--- a/components/proto/src/index_server/serialize.rs
+++ b/components/proto/src/index_server/serialize.rs
@@ -2,17 +2,17 @@ use capnp::serialize_packed;
 use std::io;
 
 use crate::capnp_common::{
-    read_custom_u_int128, read_hash, read_public_key, read_rand_nonce, read_signature, read_uid,
-    write_custom_u_int128, write_hash, write_public_key, write_rand_nonce, write_signature,
-    write_uid,
+    read_custom_u_int128, read_hash, read_public_key, read_rand_nonce, read_rate, read_signature,
+    read_uid, write_custom_u_int128, write_hash, write_public_key, write_rand_nonce, write_rate,
+    write_signature, write_uid,
 };
 use common::int_convert::usize_to_u32;
 use index_capnp;
 
 use super::messages::{
     ForwardMutationsUpdate, IndexClientToServer, IndexMutation, IndexServerToClient,
-    IndexServerToServer, MutationsUpdate, RequestRoutes, ResponseRoutes, TimeProofLink,
-    UpdateFriend,
+    IndexServerToServer, MultiRoute, MutationsUpdate, RequestRoutes, ResponseRoutes,
+    RouteCapacityRate, TimeProofLink, UpdateFriend,
 };
 
 use crate::funder::serialize::{deser_friends_route, ser_friends_route};
@@ -81,70 +81,92 @@ pub fn deser_request_routes(
     })
 }
 
-/*
-pub fn ser_route_with_capacity(
-    route_with_capacity: &RouteWithCapacity,
-    route_with_capacity_builder: &mut index_capnp::route_with_capacity::Builder,
+pub fn ser_route_capacity_rate(
+    route_capacity_rate: &RouteCapacityRate,
+    route_capacity_rate_builder: &mut index_capnp::route_capacity_rate::Builder,
 ) {
-    unimplemented!();
-    /*
     ser_friends_route(
-        &route_with_capacity.route,
-        &mut route_with_capacity_builder.reborrow().init_route(),
+        &route_capacity_rate.route,
+        &mut route_capacity_rate_builder.reborrow().init_route(),
     );
     write_custom_u_int128(
-        route_with_capacity.capacity,
-        &mut route_with_capacity_builder.reborrow().init_capacity(),
+        route_capacity_rate.capacity,
+        &mut route_capacity_rate_builder.reborrow().init_capacity(),
+    );
+    write_rate(
+        &route_capacity_rate.rate,
+        &mut route_capacity_rate_builder.reborrow().init_rate(),
     );
-    */
 }
 
-pub fn deser_route_with_capacity(
-    route_with_capacity_reader: &index_capnp::route_with_capacity::Reader,
-) -> Result<RouteWithCapacity, SerializeError> {
-    Ok(RouteWithCapacity {
-        route: deser_friends_route(&route_with_capacity_reader.get_route()?)?,
-        capacity: read_custom_u_int128(&route_with_capacity_reader.get_capacity()?)?,
+pub fn deser_route_capacity_rate(
+    route_capacity_rate_reader: &index_capnp::route_capacity_rate::Reader,
+) -> Result<RouteCapacityRate, SerializeError> {
+    Ok(RouteCapacityRate {
+        route: deser_friends_route(&route_capacity_rate_reader.get_route()?)?,
+        capacity: read_custom_u_int128(&route_capacity_rate_reader.get_capacity()?)?,
+        rate: read_rate(&route_capacity_rate_reader.get_rate()?)?,
     })
 }
-*/
+
+pub fn ser_multi_route(
+    multi_route: &MultiRoute,
+    multi_route_builder: &mut index_capnp::multi_route::Builder,
+) {
+    let routes_len = usize_to_u32(multi_route.routes.len()).unwrap();
+    let mut routes_builder = multi_route_builder.reborrow().init_routes(routes_len);
+
+    for (index, route) in multi_route.routes.iter().enumerate() {
+        let mut route_capacity_rate_builder =
+            routes_builder.reborrow().get(usize_to_u32(index).unwrap());
+        ser_route_capacity_rate(&route, &mut route_capacity_rate_builder);
+    }
+}
+
+pub fn deser_multi_route(
+    multi_route_reader: &index_capnp::multi_route::Reader,
+) -> Result<MultiRoute, SerializeError> {
+    let mut routes = Vec::new();
+    for route_capacity_rate in multi_route_reader.get_routes()? {
+        routes.push(deser_route_capacity_rate(&route_capacity_rate)?);
+    }
+
+    Ok(MultiRoute { routes })
+}
 
 fn ser_response_routes(
     response_routes: &ResponseRoutes,
     response_routes_builder: &mut index_capnp::response_routes::Builder,
 ) {
-    unimplemented!();
-    /*
     write_uid(
         &response_routes.request_id,
         &mut response_routes_builder.reborrow().init_request_id(),
     );
-    let routes_len = usize_to_u32(response_routes.routes.len()).unwrap();
-    let mut routes_builder = response_routes_builder.reborrow().init_routes(routes_len);
+    let multi_routes_len = usize_to_u32(response_routes.multi_routes.len()).unwrap();
+    let mut multi_routes_builder = response_routes_builder
+        .reborrow()
+        .init_multi_routes(multi_routes_len);
 
-    for (index, route) in response_routes.routes.iter().enumerate() {
-        let mut route_with_capacity_builder =
-            routes_builder.reborrow().get(usize_to_u32(index).unwrap());
-        ser_route_with_capacity(&route, &mut route_with_capacity_builder);
+    for (index, multi_route) in response_routes.multi_routes.iter().enumerate() {
+        let mut multi_route_builder = multi_routes_builder
+            .reborrow()
+            .get(usize_to_u32(index).unwrap());
+        ser_multi_route(&multi_route, &mut multi_route_builder);
     }
-    */
 }
 
 fn deser_response_routes(
     response_routes_reader: &index_capnp::response_routes::Reader,
 ) -> Result<ResponseRoutes, SerializeError> {
-    unimplemented!();
-    /*
-    let mut routes = Vec::new();
-    for route_with_capacity in response_routes_reader.get_routes()? {
-        routes.push(deser_route_with_capacity(&route_with_capacity)?);
+    let mut multi_routes = Vec::new();
+    for multi_route_reader in response_routes_reader.get_multi_routes()? {
+        multi_routes.push(deser_multi_route(&multi_route_reader)?);
     }
 
     Ok(ResponseRoutes {
         request_id: read_uid(&response_routes_reader.get_request_id()?)?,
-        routes,
+        multi_routes,
     })
-    */
 }
 
 fn ser_update_friend(
@@ -163,19 +185,21 @@ fn ser_update_friend(
         update_friend.recv_capacity,
         &mut update_friend_builder.reborrow().init_recv_capacity(),
     );
+    write_rate(
+        &update_friend.rate,
+        &mut update_friend_builder.reborrow().init_rate(),
+    );
 }
 
 fn deser_update_friend(
-    _update_friend_reader: &index_capnp::update_friend::Reader,
+    update_friend_reader: &index_capnp::update_friend::Reader,
 ) -> Result<UpdateFriend, SerializeError> {
-    unimplemented!();
-    /*
     Ok(UpdateFriend {
         public_key: read_public_key(&update_friend_reader.get_public_key()?)?,
         send_capacity: read_custom_u_int128(&update_friend_reader.get_send_capacity()?)?,
         recv_capacity: read_custom_u_int128(&update_friend_reader.get_recv_capacity()?)?,
+        rate: read_rate(&update_friend_reader.get_rate()?)?,
     })
-    */
 }
 
 fn ser_index_mutation(
diff --git a/components/proto/src/report/serialize.rs b/components/proto/src/report/serialize.rs
index c44dd056f..b79bbd3e2 100644
--- a/components/proto/src/report/serialize.rs
+++ b/components/proto/src/report/serialize.rs
@@ -3,10 +3,10 @@ use im::vector::Vector as ImVec;
 
 use crate::capnp_common::{
     read_custom_int128, read_custom_u_int128, read_hash, read_named_index_server_address,
-    read_named_relay_address, read_public_key, read_rand_nonce, read_relay_address, read_signature,
-    write_custom_int128, write_custom_u_int128, write_hash, write_named_index_server_address,
-    write_named_relay_address, write_public_key, write_rand_nonce, write_relay_address,
-    write_signature,
+    read_named_relay_address, read_public_key, read_rand_nonce, read_rate, read_relay_address,
+    read_signature, write_custom_int128, write_custom_u_int128, write_hash,
+    write_named_index_server_address, write_named_relay_address, write_public_key,
+    write_rand_nonce, write_rate, write_relay_address, write_signature,
 };
 use common::int_convert::usize_to_u32;
 use crypto::identity::PublicKey;
@@ -544,13 +544,15 @@ fn ser_friend_report(
     friend_report: &FriendReport,
     friend_report_builder: &mut report_capnp::friend_report::Builder,
 ) {
-    unimplemented!();
-
-    /*
     friend_report_builder
         .reborrow()
         .set_name(&friend_report.name);
 
+    write_rate(
+        &friend_report.rate,
+        &mut friend_report_builder.reborrow().init_rate(),
+    );
+
     // remote_relays:
     let relays_len = usize_to_u32(friend_report.remote_relays.len()).unwrap();
     let mut relays_builder = friend_report_builder
@@ -598,7 +600,7 @@ fn ser_friend_report(
     );
 
     friend_report_builder.set_num_pending_requests(friend_report.num_pending_requests);
-    friend_report_builder.set_num_pending_responses(friend_report.num_pending_responses);
+    friend_report_builder.set_num_pending_backwards_ops(friend_report.num_pending_backwards_ops);
 
     ser_friend_status_report(
         &friend_report.status,
@@ -606,14 +608,11 @@ fn ser_friend_report(
     );
 
     friend_report_builder.set_num_pending_user_requests(friend_report.num_pending_user_requests);
-    */
 }
 
 fn deser_friend_report(
     friend_report_reader: &report_capnp::friend_report::Reader,
 ) -> Result<FriendReport, SerializeError> {
-    unimplemented!();
-    /*
     let mut remote_relays = Vec::new();
     for relay_address in friend_report_reader.get_remote_relays()? {
         remote_relays.push(read_relay_address(&relay_address)?);
@@ -621,6 +620,7 @@ fn deser_friend_report(
 
     Ok(FriendReport {
         name: friend_report_reader.get_name()?.to_owned(),
+        rate: read_rate(&friend_report_reader.get_rate()?)?,
         remote_relays,
         sent_local_relays: deser_sent_local_relays_report(
             &friend_report_reader.get_sent_local_relays()?,
@@ -637,11 +637,10 @@ fn deser_friend_report(
             &friend_report_reader.get_wanted_local_requests_status()?,
         )?,
         num_pending_requests: friend_report_reader.get_num_pending_requests(),
-        num_pending_responses: friend_report_reader.get_num_pending_responses(),
+        num_pending_backwards_ops: friend_report_reader.get_num_pending_backwards_ops(),
         status: deser_friend_status_report(&friend_report_reader.get_status()?)?,
         num_pending_user_requests: friend_report_reader.get_num_pending_user_requests(),
     })
-    */
 }
 
 fn ser_pk_friend_report(
@@ -672,8 +671,6 @@ fn ser_funder_report(
     funder_report: &FunderReport,
     funder_report_builder: &mut report_capnp::funder_report::Builder,
 ) {
-    unimplemented!();
-    /*
     write_public_key(
         &funder_report.local_public_key,
         &mut funder_report_builder.reborrow().init_local_public_key(),
@@ -694,15 +691,14 @@ fn ser_funder_report(
         ser_pk_friend_report(pk_friend, &mut pk_friend_builder);
     }
 
-    funder_report_builder.set_num_ready_receipts(funder_report.num_ready_receipts);
-    */
+    funder_report_builder.set_num_open_invoices(funder_report.num_open_invoices);
+    funder_report_builder.set_num_payments(funder_report.num_payments);
+    funder_report_builder.set_num_open_transactions(funder_report.num_open_transactions);
 }
 
 fn deser_funder_report(
     funder_report_reader: &report_capnp::funder_report::Reader,
 ) -> Result<FunderReport, SerializeError> {
-    unimplemented!();
-    /*
     let mut named_relays = Vec::new();
     for named_relay_address in funder_report_reader.get_relays()? {
         named_relays.push(read_named_relay_address(&named_relay_address)?);
@@ -718,9 +714,10 @@ fn deser_funder_report(
         local_public_key: read_public_key(&funder_report_reader.get_local_public_key()?)?,
         relays: named_relays.into_iter().collect(),
         friends,
-        num_ready_receipts: funder_report_reader.get_num_ready_receipts(),
+        num_open_invoices: funder_report_reader.get_num_open_invoices(),
+        num_payments: funder_report_reader.get_num_payments(),
+        num_open_transactions: funder_report_reader.get_num_open_transactions(),
     })
-    */
 }
 
 fn ser_add_friend_report(
@@ -787,8 +784,6 @@ fn ser_friend_report_mutation(
     friend_report_mutation: &FriendReportMutation,
     friend_report_mutation_builder: &mut report_capnp::friend_report_mutation::Builder,
 ) {
-    unimplemented!();
-    /*
     match friend_report_mutation {
         FriendReportMutation::SetRemoteRelays(relays) => {
             let relays_len = usize_to_u32(relays.len()).unwrap();
@@ -804,6 +799,10 @@ fn ser_friend_report_mutation(
         FriendReportMutation::SetName(name) => {
             friend_report_mutation_builder.reborrow().set_set_name(name)
         }
+        FriendReportMutation::SetRate(rate) => write_rate(
+            rate,
+            &mut friend_report_mutation_builder.reborrow().init_set_rate(),
+        ),
         FriendReportMutation::SetSentLocalRelays(sent_local_relays_report) => {
             ser_sent_local_relays_report(
                 sent_local_relays_report,
@@ -839,10 +838,10 @@ fn ser_friend_report_mutation(
                 .reborrow()
                 .set_set_num_pending_requests(*num_pending_requests)
         }
-        FriendReportMutation::SetNumPendingResponses(num_pending_responses) => {
+        FriendReportMutation::SetNumPendingBackwardsOps(num_pending_backwards_ops) => {
             friend_report_mutation_builder
                 .reborrow()
-                .set_set_num_pending_responses(*num_pending_responses)
+                .set_set_num_pending_backwards_ops(*num_pending_backwards_ops)
         }
         FriendReportMutation::SetStatus(friend_status_report) => ser_friend_status_report(
             friend_status_report,
@@ -868,15 +867,11 @@ fn ser_friend_report_mutation(
                 .init_set_liveness(),
         ),
     };
-    */
 }
 
 fn deser_friend_report_mutation(
     friend_report_mutation: &report_capnp::friend_report_mutation::Reader,
 ) -> Result<FriendReportMutation, SerializeError> {
-    unimplemented!();
-
-    /*
     Ok(match friend_report_mutation.which()? {
         report_capnp::friend_report_mutation::SetRemoteRelays(relays_reader) => {
             let mut relays = Vec::new();
@@ -888,6 +883,9 @@ fn deser_friend_report_mutation(
         report_capnp::friend_report_mutation::SetName(name) => {
             FriendReportMutation::SetName(name?.to_owned())
         }
+        report_capnp::friend_report_mutation::SetRate(rate_reader) => {
+            FriendReportMutation::SetRate(read_rate(&rate_reader?)?)
+        }
         report_capnp::friend_report_mutation::SetSentLocalRelays(
             sent_local_relays_report_reader,
         ) => FriendReportMutation::SetSentLocalRelays(deser_sent_local_relays_report(
@@ -911,9 +909,9 @@ fn deser_friend_report_mutation(
         report_capnp::friend_report_mutation::SetNumPendingRequests(num_pending_requests) => {
             FriendReportMutation::SetNumPendingRequests(num_pending_requests)
         }
-        report_capnp::friend_report_mutation::SetNumPendingResponses(num_pending_responses) => {
-            FriendReportMutation::SetNumPendingResponses(num_pending_responses)
-        }
+        report_capnp::friend_report_mutation::SetNumPendingBackwardsOps(
+            num_pending_backwards_ops,
+        ) => FriendReportMutation::SetNumPendingBackwardsOps(num_pending_backwards_ops),
         report_capnp::friend_report_mutation::SetStatus(friend_status_report_reader) => {
             FriendReportMutation::SetStatus(deser_friend_status_report(
                 &friend_status_report_reader?,
@@ -933,7 +931,6 @@ fn deser_friend_report_mutation(
             )?)
         }
     })
-    */
 }
 
 fn ser_pk_friend_report_mutation(
@@ -971,8 +968,6 @@ fn ser_funder_report_mutation(
     funder_report_mutation: &FunderReportMutation,
     funder_report_mutation_builder: &mut report_capnp::funder_report_mutation::Builder,
 ) {
-    unimplemented!();
-    /*
     match funder_report_mutation {
         FunderReportMutation::AddRelay(named_relay_address) => {
             write_named_relay_address(
@@ -1010,20 +1005,27 @@ fn ser_funder_report_mutation(
                     .init_pk_friend_report_mutation(),
             );
         }
-        FunderReportMutation::SetNumReadyReceipts(num_ready_receipts) => {
+        FunderReportMutation::SetNumOpenInvoices(num_open_invoices) => {
+            funder_report_mutation_builder
+                .reborrow()
+                .set_set_num_open_invoices(*num_open_invoices);
+        }
+        FunderReportMutation::SetNumPayments(num_payments) => {
+            funder_report_mutation_builder
+                .reborrow()
+                .set_set_num_payments(*num_payments);
+        }
+        FunderReportMutation::SetNumOpenTransactions(num_open_transactions) => {
             funder_report_mutation_builder
                 .reborrow()
-                .set_set_num_ready_receipts(*num_ready_receipts);
+                .set_set_num_open_transactions(*num_open_transactions);
         }
     }
-    */
 }
 
 fn deser_funder_report_mutation(
     funder_report_mutation_reader: &report_capnp::funder_report_mutation::Reader,
 ) -> Result<FunderReportMutation, SerializeError> {
-    unimplemented!();
-    /*
     Ok(match funder_report_mutation_reader.which()? {
         report_capnp::funder_report_mutation::AddRelay(named_relay_address_reader) => {
             FunderReportMutation::AddRelay(read_named_relay_address(&named_relay_address_reader?)?)
@@ -1042,8 +1044,16 @@ fn deser_funder_report_mutation(
         ) => FunderReportMutation::FriendReportMutation(deser_pk_friend_report_mutation(
             &pk_friend_report_mutation_reader?,
         )?),
+        report_capnp::funder_report_mutation::SetNumOpenInvoices(num_open_invoices) => {
+            FunderReportMutation::SetNumOpenInvoices(num_open_invoices)
+        }
+        report_capnp::funder_report_mutation::SetNumPayments(num_payments) => {
+            FunderReportMutation::SetNumPayments(num_payments)
+        }
+        report_capnp::funder_report_mutation::SetNumOpenTransactions(set_num_open_transactions) => {
+            FunderReportMutation::SetNumOpenTransactions(set_num_open_transactions)
+        }
     })
-    */
 }
 
 fn ser_index_client_report(
diff --git a/components/proto/src/schema/app_server.capnp b/components/proto/src/schema/app_server.capnp
index 2407fbe67..9f3e272fe 100644
--- a/components/proto/src/schema/app_server.capnp
+++ b/components/proto/src/schema/app_server.capnp
@@ -9,8 +9,12 @@ using import "common.capnp".PublicKey;
 using import "common.capnp".Hash;
 using import "common.capnp".Signature;
 using import "common.capnp".RandNonce;
+using import "common.capnp".PaymentId;
+using import "common.capnp".Rate;
 
 using import "common.capnp".Receipt;
+using import "common.capnp".Commit;
+using import "common.capnp".MultiCommit;
 using import "common.capnp".RelayAddress;
 using import "common.capnp".NamedRelayAddress;
 using import "common.capnp".NetAddress;
@@ -20,7 +24,7 @@ using import "report.capnp".NodeReport;
 using import "report.capnp".NodeReportMutation;
 
 using import "index.capnp".RequestRoutes;
-using import "index.capnp".RouteWithCapacity;
+using import "index.capnp".MultiRoute;
 
 
 # Interface between AppServer and an Application
@@ -71,6 +75,11 @@ struct SetFriendRemoteMaxDebt {
         remoteMaxDebt @1: CustomUInt128;
 }
 
+struct SetFriendRate {
+        friendPublicKey @0: PublicKey;
+        rate @1: Rate;
+}
+
 # Application -> AppServer
 struct ResetFriendChannel {
         friendPublicKey @0: PublicKey;
@@ -79,7 +88,7 @@ struct ResetFriendChannel {
 
 struct ResponseRoutesResult {
         union {
-                success @0: List(RouteWithCapacity);
+                success @0: List(MultiRoute);
                 failure @1: Void;
         }
 }
@@ -89,14 +98,41 @@ struct ClientResponseRoutes {
         result @1: ResponseRoutesResult;
 }
 
+struct CreatePayment {
+        paymentId @0: PaymentId;
+        invoiceId @1: InvoiceId;
+        totalDestPayment @2: CustomUInt128;
+        destPublicKey @3: PublicKey;
+}
+
+struct CreateTransaction {
+        paymentId @0: PaymentId;
+        requestId @1: Uid;
+        route @2: FriendsRoute;
+        destPayment @3: CustomUInt128;
+        fees @4: CustomUInt128;
+}
+
+struct AckClosePayment {
+        paymentId @0: PaymentId;
+        ackUid @1: Uid;
+}
+
+struct AddInvoice {
+        invoiceId @0: InvoiceId;
+        totalDestPayment @1: CustomUInt128;
+}
+
 #####################################################################
 
 struct AppPermissions {
         routes @0: Bool;
-        # Can request routes
-        sendFunds @1: Bool;
-        # Can send credits
-        config @2: Bool;
+        # Can request for routes
+        buyer @1: Bool;
+        # Can buy (Send credits)
+        seller @2: Bool;
+        # Can sell (Receive credits)
+        config @3: Bool;
         # Can configure friends
 }
 
@@ -112,18 +148,50 @@ struct ReportMutations {
         # A list of mutations
 }
 
+struct RequestResult {
+        union {
+                success @0: Commit;
+                failure @1: Void;
+        }
+}
+
+struct TransactionResult {
+        requestId @0: Uid;
+        result @1: RequestResult;
+}
+
+struct PaymentStatusSuccess {
+        receipt @0: Receipt;
+        ackUid @1: Uid;
+}
+
+struct PaymentStatus {
+        union {
+                paymentNotFound @0: Void;
+                inProgress @1: Void;
+                success @2: PaymentStatusSuccess;
+                canceled @3: Uid;
+        }
+}
+
+struct ResponseClosePayment {
+        paymentId @0: PaymentId;
+        status @1: PaymentStatus;
+}
+
 
 struct AppServerToApp {
     union {
         # Funds
-        responseReceived @0: ResponseReceived;
+        transactionResult @0: TransactionResult;
+        responseClosePayment @1: ResponseClosePayment;
 
         # Reports about current state:
-        report @1: NodeReport;
-        reportMutations @2: ReportMutations;
+        report @2: NodeReport;
+        reportMutations @3: ReportMutations;
 
         # Routes:
-        responseRoutes @3: ClientResponseRoutes;
+        responseRoutes @4: ClientResponseRoutes;
 
     }
 }
@@ -134,28 +202,36 @@ struct AppRequest {
         addRelay @0: NamedRelayAddress;
         removeRelay @1: PublicKey;
 
-        # Sending Funds:
-        requestSendFunds @2: UserRequestSendFunds;
-        receiptAck @3: ReceiptAck;
+        # Buyer (Sending Funds):
+        createPayment @2: CreatePayment;
+        createTransaction @3: CreateTransaction;
+        requestClosePayment @4: PaymentId;
+        ackClosePayment @5: AckClosePayment;
+
+        # Seller (Receiving funds):
+        addInvoice @6: AddInvoice;
+        cancelInvoice @7: InvoiceId;
+        commitInvoice @8: MultiCommit;
 
         # Friends management
-        addFriend @4: AddFriend;
-        setFriendRelays @5: SetFriendRelays;
-        setFriendName @6: SetFriendName;
-        removeFriend @7: PublicKey;
-        enableFriend @8: PublicKey;
-        disableFriend @9: PublicKey;
-        openFriend @10: PublicKey;
-        closeFriend @11: PublicKey;
-        setFriendRemoteMaxDebt @12: SetFriendRemoteMaxDebt;
-        resetFriendChannel @13: ResetFriendChannel;
+        addFriend @9: AddFriend;
+        setFriendRelays @10: SetFriendRelays;
+        setFriendName @11: SetFriendName;
+        removeFriend @12: PublicKey;
+        enableFriend @13: PublicKey;
+        disableFriend @14: PublicKey;
+        openFriend @15: PublicKey;
+        closeFriend @16: PublicKey;
+        setFriendRemoteMaxDebt @17: SetFriendRemoteMaxDebt;
+        setFriendRate @18: SetFriendRate;
+        resetFriendChannel @19: ResetFriendChannel;
 
         # Routes:
-        requestRoutes @14: RequestRoutes;
+        requestRoutes @20: RequestRoutes;
 
         # Index servers management:
-        addIndexServer @15: NamedIndexServerAddress;
-        removeIndexServer @16: PublicKey;
+        addIndexServer @21: NamedIndexServerAddress;
+        removeIndexServer @22: PublicKey;
     }
 }
 
diff --git a/components/proto/src/schema/common.capnp b/components/proto/src/schema/common.capnp
index 3e8824b71..bc9a8cf1e 100644
--- a/components/proto/src/schema/common.capnp
+++ b/components/proto/src/schema/common.capnp
@@ -69,22 +69,24 @@ struct Uid {
         inner @0: Buffer128;
 }
 
+struct PaymentId {
+        inner @0: Buffer128;
+}
 
-# A receipt for payment to the Funder
-struct Receipt {
-        responseHash @0: Hash;
-        # = sha512/256(requestId || sha512/256(route) || randNonce)
-        invoiceId @1: InvoiceId;
-        destPayment @2: CustomUInt128;
-        signature @3: Signature;
-        # Signature{key=recipientKey}(
-        #   sha512/256("FUND_SUCCESS") ||
-        #   sha512/256(requestId || sha512/256(route) || randNonce) ||
-        #   invoiceId ||
-        #   destPayment
-        # )
+struct PlainLock {
+        inner @0: Buffer256;
+}
+
+struct HashedLock {
+        inner @0: Buffer256;
 }
 
+struct Rate {
+        mul @0: UInt32;
+        add @1: UInt32;
+}
+
+
 # Stringly represented address.
 # For example: "127.0.0.1:1337"
 struct NetAddress {
@@ -111,3 +113,50 @@ struct NamedIndexServerAddress {
         name @2: Text;
 }
 
+
+# Common payment primitives
+############################
+
+# A single commit, commiting to a transaction along a certain route.
+struct Commit {
+        responseHash @0: Hash;
+        destPayment @1: CustomUInt128;
+        srcPlainLock @2: PlainLock;
+        destHashedLock @3: HashedLock;
+        signature @4: Signature;
+}
+
+# Multi-commit: Commiting to multiple transactions along multi routes at the
+# same time. The Buyer has to hand a MultiCommit message to the seller before
+# the seller can collect the credits.
+struct MultiCommit {
+        invoiceId @0: InvoiceId;
+        # invoice id of the invoice we are paying (Generated by the seller)
+        totalDestPayment @1: CustomUInt128;
+        # Total sum of credits paid in this multi-route payment.
+        commits @2: List(Commit);
+        # A list of commits (Each commit corresponds to a single route)
+}
+
+
+# A receipt for payment to the Funder
+struct Receipt {
+        responseHash @0: Hash;
+        # = sha512/256(requestId || sha512/256(route) || randNonce)
+        invoiceId @1: InvoiceId;
+        srcPlainLock @2: PlainLock;
+        destPlainLock @3: PlainLock;
+        destPayment @4: CustomUInt128;
+        totalDestPayment @5: CustomUInt128;
+        signature @6: Signature;
+        # Signature{key=destinationKey}(
+        #   sha512/256("FUNDS_RESPONSE") ||
+        #   sha512/256(requestId || sha512/256(route) || randNonce) ||
+        #   srcHashedLock ||
+        #   dstHashedLock ||
+        #   destPayment ||
+        #   totalDestPayment ||
+        #   invoiceId
+        # )
+}
+
diff --git a/components/proto/src/schema/funder.capnp b/components/proto/src/schema/funder.capnp
index e0f6e854e..3a980c73c 100644
--- a/components/proto/src/schema/funder.capnp
+++ b/components/proto/src/schema/funder.capnp
@@ -8,6 +8,9 @@ using import "common.capnp".Uid;
 using import "common.capnp".CustomUInt128;
 using import "common.capnp".CustomInt128;
 using import "common.capnp".RelayAddress;
+using import "common.capnp".HashedLock;
+using import "common.capnp".PlainLock;
+using import "common.capnp".Hash;
 
 
 # Token channel messages
@@ -108,19 +111,33 @@ struct Ratio128 {
 
 struct RequestSendFundsOp {
         requestId @0: Uid;
-        route @1: FriendsRoute;
-        destPayment @2: CustomUInt128;
-        invoiceId @3: InvoiceId;
+        # Id number of this request. Used to identify the whole transaction
+        # over this route.
+        srcHashedLock @1: HashedLock;
+        # A hash lock created by the originator of this request
+        route @2: FriendsRoute;
+        destPayment @3: CustomUInt128;
+        totalDestPayment @4: CustomUInt128;
+        invoiceId @5: InvoiceId;
+        # Id number of the invoice we are attempting to pay
+        leftFees @6: CustomUInt128;
+        # Amount of fees left to give to mediators
+        # Every mediator takes the amount of fees he wants and subtracts this
+        # value accordingly.
 }
 
 struct ResponseSendFundsOp {
         requestId @0: Uid;
-        randNonce @1: RandNonce;
-        signature @2: Signature;
-        # Signature{key=recipientKey}(
-        #   sha512/256("FUND_SUCCESS") ||
+        destHashedLock @1: HashedLock;
+        randNonce @2: RandNonce;
+        signature @3: Signature;
+        # Signature{key=destinationKey}(
+        #   sha512/256("FUNDS_RESPONSE") ||
         #   sha512/256(requestId || sha512/256(route) || randNonce) ||
+        #   srcHashedLock || 
+        #   destHashedLock || 
         #   destPayment ||
+        #   totalDestPayment ||
         #   invoiceId
         # )
         #
@@ -129,22 +146,14 @@ struct ResponseSendFundsOp {
         # See also the Receipt structure.
 }
 
-struct FailureSendFundsOp {
+struct CancelSendFundsOp {
         requestId @0: Uid;
-        reportingPublicKey @1: PublicKey;
-        # Index of the reporting node in the route of the corresponding request.
-        # The reporting node cannot be the destination node.
-        randNonce @2: RandNonce;
-        signature @3: Signature;
-        # Signature{key=recipientKey}(
-        #   sha512/256("FUND_FAILURE") ||
-        #   requestId ||
-        #   sha512/256(route) ||
-        #   destPayment ||
-        #   invoiceId ||
-        #   reportingPublicKey ||
-        #   randNonce
-        # )
+}
+
+struct CollectSendFundsOp {
+        requestId @0: Uid;
+        srcPlainLock @1: PlainLock;
+        destPlainLock @2: PlainLock;
 }
 
 
@@ -155,6 +164,8 @@ struct FriendOperation {
                 setRemoteMaxDebt @2: CustomUInt128;
                 requestSendFunds @3: RequestSendFundsOp;
                 responseSendFunds @4: ResponseSendFundsOp;
-                failureSendFunds @5: FailureSendFundsOp;
+                cancelSendFunds @5: CancelSendFundsOp;
+                collectSendFunds @6: CollectSendFundsOp;
         }
 }
+
diff --git a/components/proto/src/schema/index.capnp b/components/proto/src/schema/index.capnp
index b623387a9..c4c44c4f7 100644
--- a/components/proto/src/schema/index.capnp
+++ b/components/proto/src/schema/index.capnp
@@ -6,6 +6,7 @@ using import "common.capnp".Hash;
 using import "common.capnp".RandNonce;
 using import "common.capnp".Uid;
 using import "common.capnp".CustomUInt128;
+using import "common.capnp".Rate;
 
 using import "funder.capnp".FriendsRoute;
 
@@ -30,15 +31,20 @@ struct RequestRoutes {
 }
 
 
-struct RouteWithCapacity {
+struct RouteCapacityRate {
         route @0: FriendsRoute;
         capacity @1: CustomUInt128;
+        rate @2: Rate;
+}
+
+struct MultiRoute {
+        routes @0: List(RouteCapacityRate);
 }
 
 # IndexServer -> IndexClient
 struct ResponseRoutes {
         requestId @0: Uid;
-        routes @1: List(RouteWithCapacity);
+        multiRoutes @1: List(MultiRoute);
 }
 
 struct UpdateFriend {
@@ -48,6 +54,9 @@ struct UpdateFriend {
         # To denote remote requests closed, assign 0 to sendCapacity
         recvCapacity @2: CustomUInt128;
         # To denote local requests closed, assign 0 to recvCapacity
+        rate @3: Rate;
+        # Rate a node takes for forwarding messages for this friend (to another
+        # node).
 }
 
 
diff --git a/components/proto/src/schema/report.capnp b/components/proto/src/schema/report.capnp
index 8b27c36d6..b5707b489 100644
--- a/components/proto/src/schema/report.capnp
+++ b/components/proto/src/schema/report.capnp
@@ -6,6 +6,7 @@ using import "common.capnp".CustomUInt128;
 using import "common.capnp".CustomInt128;
 using import "common.capnp".Signature;
 using import "common.capnp".RandNonce;
+using import "common.capnp".Rate;
 
 using import "common.capnp".RelayAddress;
 using import "common.capnp".NamedRelayAddress;
@@ -127,17 +128,18 @@ struct SentLocalRelaysReport {
 
 struct FriendReport {
         name @0: Text;
-        remoteRelays @1: List(RelayAddress);
-        sentLocalRelays @2: SentLocalRelaysReport;
-        optLastIncomingMoveToken @3: OptLastIncomingMoveToken;
-        liveness @4: FriendLivenessReport;
-        channelStatus @5: ChannelStatusReport;
-        wantedRemoteMaxDebt @6: CustomUInt128;
-        wantedLocalRequestsStatus @7: RequestsStatusReport;
-        numPendingRequests @8: UInt64;
-        numPendingResponses @9: UInt64;
-        status @10: FriendStatusReport;
-        numPendingUserRequests @11: UInt64;
+        rate @1: Rate;
+        remoteRelays @2: List(RelayAddress);
+        sentLocalRelays @3: SentLocalRelaysReport;
+        optLastIncomingMoveToken @4: OptLastIncomingMoveToken;
+        liveness @5: FriendLivenessReport;
+        channelStatus @6: ChannelStatusReport;
+        wantedRemoteMaxDebt @7: CustomUInt128;
+        wantedLocalRequestsStatus @8: RequestsStatusReport;
+        numPendingRequests @9: UInt64;
+        numPendingBackwardsOps @10: UInt64;
+        status @11: FriendStatusReport;
+        numPendingUserRequests @12: UInt64;
 }
 
 struct PkFriendReport {
@@ -150,7 +152,9 @@ struct FunderReport {
         localPublicKey @0: PublicKey;
         relays @1: List(NamedRelayAddress);
         friends @2: List(PkFriendReport);
-        numReadyReceipts @3: UInt64;
+        numOpenInvoices @3: UInt64;
+        numPayments @4: UInt64;
+        numOpenTransactions @5: UInt64;
 }
 
 
@@ -170,16 +174,17 @@ struct FriendReportMutation {
         union {
                 setRemoteRelays @0: List(RelayAddress);
                 setName @1: Text;
-                setSentLocalRelays @2: SentLocalRelaysReport;
-                setChannelStatus @3: ChannelStatusReport;
-                setWantedRemoteMaxDebt @4: CustomUInt128;
-                setWantedLocalRequestsStatus @5: RequestsStatusReport;
-                setNumPendingRequests @6: UInt64;
-                setNumPendingResponses @7: UInt64;
-                setStatus @8: FriendStatusReport;
-                setNumPendingUserRequests @9: UInt64;
-                setOptLastIncomingMoveToken @10: OptLastIncomingMoveToken;
-                setLiveness @11: FriendLivenessReport;
+                setRate @2: Rate;
+                setSentLocalRelays @3: SentLocalRelaysReport;
+                setChannelStatus @4: ChannelStatusReport;
+                setWantedRemoteMaxDebt @5: CustomUInt128;
+                setWantedLocalRequestsStatus @6: RequestsStatusReport;
+                setNumPendingRequests @7: UInt64;
+                setNumPendingBackwardsOps @8: UInt64;
+                setStatus @9: FriendStatusReport;
+                setNumPendingUserRequests @10: UInt64;
+                setOptLastIncomingMoveToken @11: OptLastIncomingMoveToken;
+                setLiveness @12: FriendLivenessReport;
         }
 }
 
@@ -196,7 +201,9 @@ struct FunderReportMutation {
                 addFriend @2: AddFriendReport;
                 removeFriend @3: PublicKey;
                 pkFriendReportMutation @4: PkFriendReportMutation;
-                setNumReadyReceipts @5: UInt64;
+                setNumOpenInvoices @5: UInt64;
+                setNumPayments @6: UInt64;
+                setNumOpenTransactions @7: UInt64;
         }
 }