github/darkfi
1
1
Fork 0
mirror of https://github.com/darkrenaissance/darkfi.git synced 2026-04-28 03:00:18 -04:00
Code Issues Packages Projects Releases Wiki Activity

darkotc: Restore proper source file.

Browse Source
This commit is contained in:
Luther Blissett
2022-09-23 12:18:19 +02:00
parent 5cf661d815
commit 5184c2a720
1 changed files with 1 additions and 349 deletions
Download Patch File Download Diff File Expand all files Collapse all files

350
bin/darkotc/src/main.rs
View File

@@ -1,50 +1,16 @@
use std::{
io::{stdin, Read},
process::exit,
/*
<<<<<<< HEAD
str::FromStr,
};
use clap::{Parser, Subcommand};
use darkfi::crypto::proof::VerifyingKey;
use halo2_proofs::{arithmetic::Field, pasta::group::ff::PrimeField};
use rand::rngs::OsRng;
use serde_json::json;
use termion::color;
=======
*/
};
use clap::{Parser, Subcommand};
use halo2_proofs::{arithmetic::Field, pasta::group::ff::PrimeField};
use rand::rngs::OsRng;
use url::Url;
use darkfi::{
cli_desc,
crypto::{
/*
<<<<<<< HEAD
address::Address,
burn_proof::{create_burn_proof, verify_burn_proof},
keypair::{PublicKey, SecretKey},
merkle_node::MerkleNode,
mint_proof::{create_mint_proof, verify_mint_proof},
proof::ProvingKey,
token_id,
types::{DrkCoinBlind, DrkSerial, DrkTokenId, DrkValueBlind},
util::{pedersen_commitment_base, pedersen_commitment_u64},
BurnRevealedValues, MintRevealedValues, OwnCoin, Proof,
},
rpc::{client::RpcClient, jsonrpc::JsonRequest},
util::{
cli::progress_bar,
encode_base10,
serial::{deserialize, serialize, SerialDecodable, SerialEncodable},
=======
*/
burn_proof::{create_burn_proof, verify_burn_proof},
keypair::{PublicKey, SecretKey},
mint_proof::{create_mint_proof, verify_mint_proof},
@@ -76,7 +42,6 @@ use darkfi::{
mod cli_util;
use cli_util::{parse_token_pair, parse_value_pair};
mod rpc;
use rpc::Rpc;
@@ -101,145 +66,6 @@ enum Subcmd {
/// Initialize an atomic swap
Init {
#[clap(short, long)]
/*
<<<<<<< HEAD
/// Pair of token IDs to swap: e.g. token_to_send:token_to_recv
token_pair: String,
#[clap(short, long)]
/// Pair of values to swap: e.g. value_to_send:value_to_recv
value_pair: String,
},
/// Inspect swap data from stdin or file.
Inspect,
}
struct Rpc {
pub rpc_client: RpcClient,
}
impl Rpc {
async fn balance_of(&self, token_id: &str) -> Result<u64> {
let req = JsonRequest::new("wallet.get_balances", json!([]));
let rep = self.rpc_client.request(req).await?;
if !rep.is_object() {
eprintln!("Error: Invalid balance data received from darkfid RPC endpoint.");
exit(1);
}
for i in rep.as_object().unwrap().keys() {
if i == &token_id {
if let Some(balance) = rep[i].as_u64() {
return Ok(balance)
}
eprintln!("Error: Invalid balance data received from darkfid RPC endpoint.");
exit(1);
}
}
Ok(0)
}
async fn wallet_address(&self) -> Result<Address> {
let req = JsonRequest::new("wallet.get_addrs", json!([0_i64]));
let rep = self.rpc_client.request(req).await?;
if !rep.is_array() || !rep.as_array().unwrap()[0].is_string() {
eprintln!("Error: Invalid wallet address received from darkfid RPC endpoint.");
exit(1);
}
Address::from_str(rep[0].as_str().unwrap())
}
async fn get_coins_valtok(&self, value: u64, token_id: &str) -> Result<Vec<OwnCoin>> {
let req = JsonRequest::new("wallet.get_coins_valtok", json!([value, token_id, true]));
let rep = self.rpc_client.request(req).await?;
if !rep.is_array() {
eprintln!("Error: Invalid coin data received from darkfid RPC endpoint.");
exit(1);
}
let mut ret = vec![];
let rep = rep.as_array().unwrap();
for i in rep {
if !i.is_string() {
eprintln!("Error: Invalid base58 data for OwnCoin");
exit(1);
}
let data = match bs58::decode(i.as_str().unwrap()).into_vec() {
Ok(v) => v,
Err(e) => {
eprintln!("Error: Failed decoding base58 for OwnCoin: {}", e);
exit(1);
}
};
let oc = match deserialize(&data) {
Ok(v) => v,
Err(e) => {
eprintln!("Error: Failed deserializing OwnCoin: {}", e);
exit(1);
}
};
ret.push(oc);
}
Ok(ret)
}
async fn get_merkle_path(&self, leaf_pos: usize) -> Result<Vec<MerkleNode>> {
let req = JsonRequest::new("wallet.get_merkle_path", json!([leaf_pos as u64]));
let rep = self.rpc_client.request(req).await?;
if !rep.is_array() {
eprintln!("Error: Invalid merkle path data received from darkfid RPC endpoint.");
exit(1);
}
let mut ret = vec![];
let rep = rep.as_array().unwrap();
for i in rep {
if !i.is_string() {
eprintln!("Error: Invalid base58 data for MerkleNode");
exit(1);
}
let n = i.as_str().unwrap();
let n = match bs58::decode(n).into_vec() {
Ok(v) => v,
Err(e) => {
eprintln!("Error: Failed decoding base58 for MerkleNode: {}", e);
exit(1);
}
};
if n.len() != 32 {
eprintln!("Error: MerkleNode byte length is not 32");
exit(1);
}
let n = MerkleNode::from_bytes(&n.try_into().unwrap());
if n.is_some().unwrap_u8() == 0 {
eprintln!("Error: Noncanonical bytes of MerkleNode");
exit(1);
}
ret.push(n.unwrap());
}
Ok(ret)
}
=======
*/
/// Pair of token IDs to swap: token_to_send:token_to_recv
token_pair: String,
@@ -302,18 +128,6 @@ async fn init_swap(
endpoint: Url,
token_pair: (String, String),
value_pair: (u64, u64),
/*
<<<<<<< HEAD
) -> Result<()> {
let rpc_client = RpcClient::new(endpoint).await?;
let rpc = Rpc { rpc_client };
// TODO: Think about decimals, there has to be some metadata to keep track.
let tp = (token_id::parse_b58(&token_pair.0)?, token_id::parse_b58(&token_pair.1)?);
let vp: (u64, u64) =
(value_pair.0.clone().try_into().unwrap(), value_pair.1.clone().try_into().unwrap());
=======
*/
) -> Result<PartialSwapData> {
let rpc_client = RpcClient::new(endpoint).await?;
let rpc = Rpc { rpc_client };
@@ -333,20 +147,6 @@ async fn init_swap(
exit(1);
}
/*
<<<<<<< HEAD
// If not enough funds in a single coin, mint a single new coin
// with the funds. We do this to minimize the size of the swap
// transaction, i.e. 2 inputs and 2 outputs.
// TODO: Implement ^
// TODO: Maybe this should be done by the user beforehand?
// Find a coin to spend
let coins = rpc.get_coins_valtok(vp.0, &token_pair.0).await?;
if coins.is_empty() {
eprintln!("Error: Did not manage to find a coin with enough value to spend");
=======
*/
// If there's not enough funds in a single coin, mint a single new coin
// with the funds. We do this to minimize the size of the swap transaction.
// i.e. 2 inputs and 2 outputs.
@@ -361,16 +161,6 @@ async fn init_swap(
}
eprintln!("Initializing swap data for:");
/*
<<<<<<< HEAD
eprintln!("Send: {} {} tokens", encode_base10(value_pair.0, 8), token_pair.0);
eprintln!("Recv: {} {} tokens", encode_base10(value_pair.1, 8), token_pair.1);
// Fetch our default address
let our_address = rpc.wallet_address().await?;
let our_publickey = match PublicKey::try_from(our_address) {
=======
*/
eprintln!("Send: {} {} tokens", encode_base10(vp.0, 8), token_pair.0);
eprintln!("Recv: {} {} tokens", encode_base10(vp.1, 8), token_pair.1);
@@ -384,20 +174,6 @@ async fn init_swap(
}
};
/*
<<<<<<< HEAD
// Build proving keys
let pb = progress_bar("Building proving key for the mint contract");
let mint_pk = ProvingKey::build(8, &MintContract::default());
pb.finish();
let pb = progress_bar("Building proving key for the burn contract");
let burn_pk = ProvingKey::build(11, &BurnContract::default());
pb.finish();
// The coin we want to receive.
=======
*/
// Build ZK proving keys
let pb = progress_bar("Building proving key for the Mint contract");
let mint_pk = ProvingKey::build(11, &MintContract::default());
@@ -408,22 +184,16 @@ async fn init_swap(
pb.finish();
// The coin we want to receive
let recv_value_blind = DrkValueBlind::random(&mut OsRng);
let recv_token_blind = DrkValueBlind::random(&mut OsRng);
let recv_coin_blind = DrkCoinBlind::random(&mut OsRng);
let recv_serial = DrkSerial::random(&mut OsRng);
/*
<<<<<<< HEAD
let pb = progress_bar("Building mint proof for receiving coin");
=======
*/
// Spend hook and user data disabled
let spend_hook = DrkSpendHook::from(0);
let user_data = DrkUserData::from(0);
let pb = progress_bar("Building Mint proof for the receiving coin");
let (mint_proof, mint_revealed) = create_mint_proof(
&mint_pk,
vp.1,
@@ -431,12 +201,6 @@ async fn init_swap(
recv_value_blind,
recv_token_blind,
recv_serial,
/*
<<<<<<< HEAD
recv_coin_blind,
our_publickey,
=======
*/
spend_hook,
user_data,
recv_coin_blind,
@@ -445,18 +209,9 @@ async fn init_swap(
pb.finish();
// The coin we are spending.
/*
<<<<<<< HEAD
// We'll spend the first one we've found.
let coin = coins[0];
let pb = progress_bar("Building burn proof for spending coin");
=======
*/
let coin = coins[0].clone();
let pb = progress_bar("Building Burn proof for the spending coin");
let signature_secret = SecretKey::random(&mut OsRng);
let merkle_path = match rpc.get_merkle_path(usize::from(coin.leaf_position)).await {
Ok(v) => v,
@@ -489,13 +244,6 @@ async fn init_swap(
)?;
pb.finish();
/*
<<<<<<< HEAD
// Pack proofs together with pedersen commitment openings so
// counterparty can verify correctness.
let swap_data = SwapData {
=======
*/
// Create encrypted note
let note = Note {
serial: recv_serial,
@@ -524,19 +272,6 @@ async fn init_swap(
burn_revealed,
burn_value_blind: coin.note.value_blind,
burn_token_blind: coin.note.token_blind,
/*
<<<<<<< HEAD
};
// Print encoded data.
println!("{}", bs58::encode(serialize(&swap_data)).into_string());
Ok(())
}
fn inspect(data: &str) -> Result<()> {
=======
*/
encrypted_note,
};
@@ -559,39 +294,14 @@ fn inspect_partial(data: &str) -> Result<()> {
}
};
/*
<<<<<<< HEAD
let sd: SwapData = match deserialize(&bytes) {
Ok(v) => v,
Err(e) => {
eprintln!("Error: Failed to deserialize swap data into struct: {}", e);
=======
*/
let sd: PartialSwapData = match deserialize(&bytes) {
Ok(v) => v,
Err(e) => {
eprintln!("Error deserializing partial swap data into struct: {}", e);
exit(1);
}
};
/*
<<<<<<< HEAD
eprintln!("Successfully decoded data into SwapData struct");
// Build verifying keys
let pb = progress_bar("Building verifying key for the mint contract");
let mint_vk = VerifyingKey::build(8, &MintContract::default());
pb.finish();
let pb = progress_bar("Building verifying key for the burn contract");
let burn_vk = VerifyingKey::build(11, &BurnContract::default());
pb.finish();
let pb = progress_bar("Verifying burn proof");
=======
*/
eprintln!("Successfully decoded partial swap data");
// Build ZK verifying keys
@@ -604,29 +314,17 @@ fn inspect_partial(data: &str) -> Result<()> {
pb.finish();
let pb = progress_bar("Verifying Burn proof");
if verify_burn_proof(&burn_vk, &sd.burn_proof, &sd.burn_revealed).is_ok() {
burn_valid = true;
}
pb.finish();
/*
<<<<<<< HEAD
let pb = progress_bar("Verifying mint proof");
=======
*/
let pb = progress_bar("Verifying Mint proof");
if verify_mint_proof(&mint_vk, &sd.mint_proof, &sd.mint_revealed).is_ok() {
mint_valid = true;
}
pb.finish();
/*
<<<<<<< HEAD
eprintln!(" Verifying pedersen commitments");
=======
*/
eprintln!(" Verifying Pedersen commitments");
if pedersen_commitment_u64(sd.burn_value, sd.burn_value_blind) == sd.burn_revealed.value_commit
@@ -713,23 +411,6 @@ fn inspect_partial(data: &str) -> Result<()> {
bs58::encode(sd.burn_token.to_repr()).into_string()
);
/*
<<<<<<< HEAD
if !valid {
eprintln!(
"\nThe ZK proofs and commitments inspected are {}NOT VALID{}",
color::Fg(color::Red),
color::Fg(color::Reset)
);
exit(1);
} else {
eprintln!(
"\nThe ZK proofs and commitments inspected are {}VALID{}",
color::Fg(color::Green),
color::Fg(color::Reset)
);
=======
*/
eprint!("\nThe ZK proofs and commitments inspected are ");
if !valid {
println!("{}", fg_red("NOT VALID"));
@@ -741,24 +422,6 @@ fn inspect_partial(data: &str) -> Result<()> {
Ok(())
}
/*
<<<<<<< HEAD
#[derive(SerialEncodable, SerialDecodable)]
struct SwapData {
mint_proof: Proof,
mint_revealed: MintRevealedValues,
mint_value: u64,
mint_token: DrkTokenId,
mint_value_blind: DrkValueBlind,
mint_token_blind: DrkValueBlind,
burn_proof: Proof,
burn_revealed: BurnRevealedValues,
burn_value: u64,
burn_token: DrkTokenId,
burn_value_blind: DrkValueBlind,
burn_token_blind: DrkValueBlind,
=======
*/
async fn join(endpoint: Url, d0: PartialSwapData, d1: PartialSwapData) -> Result<Transaction> {
eprintln!("Joining data into a transaction");
@@ -931,17 +594,6 @@ async fn main() -> Result<()> {
Subcmd::Init { token_pair, value_pair } => {
let token_pair = parse_token_pair(&token_pair)?;
let value_pair = parse_value_pair(&value_pair)?;
/*
<<<<<<< HEAD
init_swap(args.endpoint, token_pair, value_pair).await
}
Subcmd::Inspect => {
let mut buf = String::new();
stdin().read_to_string(&mut buf)?;
inspect(&buf.trim())
=======
*/
let swap_data = init_swap(args.endpoint, token_pair, value_pair).await?;
println!("{}", bs58::encode(serialize(&swap_data)).into_string());