use crate::layer0::vocabulary::{HANDLE_MCARD_TOKEN_CREDITS, HANDLE_MCARD_TOKEN_DCA, HANDLE_MCARD_TOKEN_EDITION, HANDLE_MCARD_TOKEN_NFT, HANDLE_MCARD_TOKEN_SBT};
use rusqlite::Connection;
use serde::{Deserialize, Serialize};
use std::path::PathBuf;
use rand::RngCore;
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct DcaRecord {
pub asset_id: String,
pub token_id: String,
pub content_hash: String,
pub owner_did: String,
pub token_policy: String,
pub timestamp: String,
pub handle: String,
pub content_hash_mcard: String,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct NftTransferRecord {
pub token_id: String,
pub previous_owner_did: String,
pub new_owner_did: String,
pub timestamp: String,
pub handle: String,
pub content_hash: String,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct SbtRecord {
pub credential_id: String,
pub recipient_did: String,
pub role_name: String,
pub is_transferable: bool,
pub timestamp: String,
pub handle: String,
pub content_hash: String,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct CommunityCreditsRecord {
pub did: String,
pub balance: f64,
pub timestamp: String,
pub handle: String,
pub content_hash: String,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct EditionRecord {
pub edition_id: String,
pub asset_id: String,
pub owner_did: String,
pub edition_number: u32,
pub max_editions: u32,
pub timestamp: String,
pub handle: String,
pub content_hash: String,
}
fn resolve_db_path(db_name_or_path: &str, clm_root: Option<&str>) -> PathBuf {
if db_name_or_path.contains('/') || db_name_or_path.contains('\\') {
PathBuf::from(db_name_or_path)
} else {
let root = clm_root.map(PathBuf::from).unwrap_or_else(|| {
std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."))
});
root.join("data").join("execution_logs").join(db_name_or_path)
}
}
fn init_db_tables(conn: &Connection) -> Result<(), String> {
let _ = conn.busy_timeout(std::time::Duration::from_millis(u64::from(crate::layer0::runtime_contract::SQLITE_BUSY_TIMEOUT_MS)));
conn.execute_batch(crate::layer0::runtime_contract::SQLITE_DDL_V3_1).map_err(|e| e.to_string())?;
let has_hash: bool = conn
.query_row(
"SELECT count(*) > 0 FROM pragma_table_info('handle_registry') WHERE name = 'hash'",
[],
|r| r.get(0),
)
.unwrap_or(false);
if has_hash {
let has_curr: bool = conn
.query_row(
"SELECT count(*) > 0 FROM pragma_table_info('handle_registry') WHERE name = 'current_hash'",
[],
|r| r.get(0),
)
.unwrap_or(false);
if !has_curr {
let _ = conn.execute_batch("ALTER TABLE handle_registry RENAME COLUMN hash TO current_hash;");
}
}
let has_updated_at: bool = conn
.query_row(
"SELECT count(*) > 0 FROM pragma_table_info('handle_registry') WHERE name = 'updated_at'",
[],
|r| r.get(0),
)
.unwrap_or(false);
if !has_updated_at {
let _ = conn.execute_batch("ALTER TABLE handle_registry ADD COLUMN updated_at TEXT NOT NULL DEFAULT '';");
}
Ok(())
}
fn generate_sha256(content: &str) -> String {
use sha2::{Digest, Sha256};
let mut hasher = Sha256::new();
hasher.update(content.as_bytes());
hex::encode(hasher.finalize())
}
pub fn mint_dca_nft(
db_name_or_path: &str,
clm_root: Option<&str>,
content_hash: &str,
owner_did: &str,
) -> Result<DcaRecord, String> {
let db_path = resolve_db_path(db_name_or_path, clm_root);
if let Some(parent) = db_path.parent() {
std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
}
let conn = Connection::open(&db_path).map_err(|e| e.to_string())?;
init_db_tables(&conn)?;
let mut asset_bytes = [0u8; 8];
rand::thread_rng().fill_bytes(&mut asset_bytes);
let asset_id = format!("dca_{}", hex::encode(asset_bytes));
let token_id = format!("nft_{}", hex::encode(asset_bytes));
let handle = format!("{HANDLE_MCARD_TOKEN_DCA}{}", asset_id);
let timestamp = chrono::Utc::now().to_rfc3339();
let token_policy = "transferable_nft".to_string();
let json_val = serde_json::json!({
"type": "digital_content_asset",
"asset_id": asset_id,
"token_id": token_id,
"content_hash": content_hash,
"owner_did": owner_did,
"token_policy": token_policy,
"timestamp": timestamp
});
let content_json = json_val.to_string();
let content_hash_mcard = generate_sha256(&content_json);
crate::layer2::record_store::insert_new_content(&conn, &content_hash_mcard, content_json.as_bytes(), crate::layer0::vocabulary::HASH_ALGORITHM_SHA256).map_err(|e| e.to_string())?;
conn.execute(
"INSERT INTO handle_registry (handle, current_hash, updated_at) VALUES (?1, ?2, ?3) \
ON CONFLICT(handle) DO UPDATE SET current_hash=excluded.current_hash, updated_at=excluded.updated_at;",
rusqlite::params![handle, content_hash_mcard, timestamp],
).map_err(|e| e.to_string())?;
let nft_handle = format!("{HANDLE_MCARD_TOKEN_NFT}{}", token_id);
conn.execute(
"INSERT INTO handle_registry (handle, current_hash, updated_at) VALUES (?1, ?2, ?3) \
ON CONFLICT(handle) DO UPDATE SET current_hash=excluded.current_hash, updated_at=excluded.updated_at;",
rusqlite::params![nft_handle, content_hash_mcard, timestamp],
).map_err(|e| e.to_string())?;
Ok(DcaRecord {
asset_id,
token_id,
content_hash: content_hash.to_string(),
owner_did: owner_did.to_string(),
token_policy,
timestamp,
handle,
content_hash_mcard,
})
}
pub fn transfer_nft(
db_name_or_path: &str,
clm_root: Option<&str>,
token_id: &str,
current_owner_did: &str,
new_owner_did: &str,
) -> Result<NftTransferRecord, String> {
let db_path = resolve_db_path(db_name_or_path, clm_root);
if !db_path.exists() {
return Err(format!("Database not found for token {}", token_id));
}
let conn = Connection::open(&db_path).map_err(|e| e.to_string())?;
let nft_handle = format!("{HANDLE_MCARD_TOKEN_NFT}{}", token_id);
let content = crate::layer2::record_store::read_handle_text(&conn, &nft_handle)
.map_err(|error| error.to_string())?.ok_or("NFT token is missing")?;
let mut v: serde_json::Value = serde_json::from_str(&content).map_err(|e| e.to_string())?;
let policy = v.get("token_policy").and_then(|x| x.as_str()).unwrap_or("");
if policy == "soulbound" {
return Err("Cannot transfer Soulbound Credential".to_string());
}
let existing_owner = v.get("owner_did").and_then(|x| x.as_str()).unwrap_or("");
if existing_owner != current_owner_did {
return Err(format!("Current owner mismatch: expected {}, found {}", current_owner_did, existing_owner));
}
v["owner_did"] = serde_json::Value::String(new_owner_did.to_string());
let timestamp = chrono::Utc::now().to_rfc3339();
v["timestamp"] = serde_json::Value::String(timestamp.clone());
let updated_json = v.to_string();
let updated_hash = generate_sha256(&updated_json);
crate::layer2::record_store::insert_new_content(&conn, &updated_hash, updated_json.as_bytes(), crate::layer0::vocabulary::HASH_ALGORITHM_SHA256).map_err(|e| e.to_string())?;
conn.execute(
"INSERT INTO handle_registry (handle, current_hash, updated_at) VALUES (?1, ?2, ?3) \
ON CONFLICT(handle) DO UPDATE SET current_hash=excluded.current_hash, updated_at=excluded.updated_at;",
rusqlite::params![nft_handle, updated_hash, timestamp],
).map_err(|e| e.to_string())?;
Ok(NftTransferRecord {
token_id: token_id.to_string(),
previous_owner_did: current_owner_did.to_string(),
new_owner_did: new_owner_did.to_string(),
timestamp,
handle: nft_handle,
content_hash: updated_hash,
})
}
pub fn mint_soulbound_credential(
db_name_or_path: &str,
clm_root: Option<&str>,
recipient_did: &str,
role_name: &str,
) -> Result<SbtRecord, String> {
let db_path = resolve_db_path(db_name_or_path, clm_root);
if let Some(parent) = db_path.parent() {
std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
}
let conn = Connection::open(&db_path).map_err(|e| e.to_string())?;
init_db_tables(&conn)?;
let mut sbt_bytes = [0u8; 8];
rand::thread_rng().fill_bytes(&mut sbt_bytes);
let credential_id = format!("sbt_{}", hex::encode(sbt_bytes));
let handle = format!("{HANDLE_MCARD_TOKEN_SBT}{}", credential_id);
let timestamp = chrono::Utc::now().to_rfc3339();
let json_val = serde_json::json!({
"type": "soulbound_credential",
"credential_id": credential_id,
"token_policy": "soulbound",
"recipient_did": recipient_did,
"owner_did": recipient_did,
"role_name": role_name,
"is_transferable": false,
"timestamp": timestamp
});
let content_json = json_val.to_string();
let content_hash = generate_sha256(&content_json);
crate::layer2::record_store::insert_new_content(&conn, &content_hash, content_json.as_bytes(), crate::layer0::vocabulary::HASH_ALGORITHM_SHA256).map_err(|e| e.to_string())?;
conn.execute(
"INSERT INTO handle_registry (handle, current_hash, updated_at) VALUES (?1, ?2, ?3) \
ON CONFLICT(handle) DO UPDATE SET current_hash=excluded.current_hash, updated_at=excluded.updated_at;",
rusqlite::params![handle, content_hash, timestamp],
).map_err(|e| e.to_string())?;
let nft_handle = format!("{HANDLE_MCARD_TOKEN_NFT}{}", credential_id);
conn.execute(
"INSERT INTO handle_registry (handle, current_hash, updated_at) VALUES (?1, ?2, ?3) \
ON CONFLICT(handle) DO UPDATE SET current_hash=excluded.current_hash, updated_at=excluded.updated_at;",
rusqlite::params![nft_handle, content_hash, timestamp],
).map_err(|e| e.to_string())?;
Ok(SbtRecord {
credential_id,
recipient_did: recipient_did.to_string(),
role_name: role_name.to_string(),
is_transferable: false,
timestamp,
handle,
content_hash,
})
}
pub fn mint_community_credits(
db_name_or_path: &str,
clm_root: Option<&str>,
recipient_did: &str,
amount: f64,
) -> Result<CommunityCreditsRecord, String> {
let db_path = resolve_db_path(db_name_or_path, clm_root);
if let Some(parent) = db_path.parent() {
std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
}
let conn = Connection::open(&db_path).map_err(|e| e.to_string())?;
init_db_tables(&conn)?;
let handle = format!("{HANDLE_MCARD_TOKEN_CREDITS}{}", recipient_did);
let existing_balance = crate::layer2::record_store::read_handle_text(&conn, &handle)
.map_err(|error| error.to_string())?.map(|content| {
let value: serde_json::Value = serde_json::from_str(&content).unwrap_or_default();
value.get("balance").and_then(|value| value.as_f64()).unwrap_or(0.0)
}).unwrap_or(0.0);
let new_balance = existing_balance + amount;
let timestamp = chrono::Utc::now().to_rfc3339();
let json_val = serde_json::json!({
"type": "community_credits",
"did": recipient_did,
"balance": new_balance,
"token_policy": "fungible",
"timestamp": timestamp
});
let content_json = json_val.to_string();
let content_hash = generate_sha256(&content_json);
crate::layer2::record_store::insert_new_content(&conn, &content_hash, content_json.as_bytes(), crate::layer0::vocabulary::HASH_ALGORITHM_SHA256).map_err(|e| e.to_string())?;
conn.execute(
"INSERT INTO handle_registry (handle, current_hash, updated_at) VALUES (?1, ?2, ?3) \
ON CONFLICT(handle) DO UPDATE SET current_hash=excluded.current_hash, updated_at=excluded.updated_at;",
rusqlite::params![handle, content_hash, timestamp],
).map_err(|e| e.to_string())?;
Ok(CommunityCreditsRecord {
did: recipient_did.to_string(),
balance: new_balance,
timestamp,
handle,
content_hash,
})
}
pub fn mint_edition_token(
db_name_or_path: &str,
clm_root: Option<&str>,
asset_id: &str,
owner_did: &str,
edition_number: u32,
max_editions: u32,
) -> Result<EditionRecord, String> {
if edition_number > max_editions || edition_number == 0 {
return Err(format!("Edition number {} exceeds maximum edition limit {}", edition_number, max_editions));
}
let db_path = resolve_db_path(db_name_or_path, clm_root);
if let Some(parent) = db_path.parent() {
std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
}
let conn = Connection::open(&db_path).map_err(|e| e.to_string())?;
init_db_tables(&conn)?;
let edition_id = format!("ed_{}_{}", asset_id, edition_number);
let handle = format!("{HANDLE_MCARD_TOKEN_EDITION}{}", edition_id);
let timestamp = chrono::Utc::now().to_rfc3339();
let json_val = serde_json::json!({
"type": "edition_token",
"edition_id": edition_id,
"asset_id": asset_id,
"owner_did": owner_did,
"edition_number": edition_number,
"max_editions": max_editions,
"token_policy": "semi_fungible",
"timestamp": timestamp
});
let content_json = json_val.to_string();
let content_hash = generate_sha256(&content_json);
crate::layer2::record_store::insert_new_content(&conn, &content_hash, content_json.as_bytes(), crate::layer0::vocabulary::HASH_ALGORITHM_SHA256).map_err(|e| e.to_string())?;
conn.execute(
"INSERT INTO handle_registry (handle, current_hash, updated_at) VALUES (?1, ?2, ?3) \
ON CONFLICT(handle) DO UPDATE SET current_hash=excluded.current_hash, updated_at=excluded.updated_at;",
rusqlite::params![handle, content_hash, timestamp],
).map_err(|e| e.to_string())?;
Ok(EditionRecord {
edition_id,
asset_id: asset_id.to_string(),
owner_did: owner_did.to_string(),
edition_number,
max_editions,
timestamp,
handle,
content_hash,
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_token_economics_pipeline() {
let db_path = "/tmp/test_tokens.db";
let _ = std::fs::remove_file(db_path);
let dca = mint_dca_nft(db_path, None, "0xcontent_hash_123", "did:key:z6MkCreator").unwrap();
assert_eq!(dca.owner_did, "did:key:z6MkCreator");
let tx = transfer_nft(db_path, None, &dca.token_id, "did:key:z6MkCreator", "did:key:z6MkBuyer").unwrap();
assert_eq!(tx.new_owner_did, "did:key:z6MkBuyer");
let sbt = mint_soulbound_credential(db_path, None, "did:key:z6MkMember", "Core Contributor").unwrap();
assert_eq!(sbt.role_name, "Core Contributor");
let sbt_err = transfer_nft(db_path, None, &sbt.credential_id, "did:key:z6MkMember", "did:key:z6MkOther");
assert!(sbt_err.is_err());
let credits = mint_community_credits(db_path, None, "did:key:z6MkContributor", 50.0).unwrap();
assert_eq!(credits.balance, 50.0);
let credits2 = mint_community_credits(db_path, None, "did:key:z6MkContributor", 25.0).unwrap();
assert_eq!(credits2.balance, 75.0);
let ed1 = mint_edition_token(db_path, None, "dca_001", "did:key:z6MkCollector", 1, 10).unwrap();
assert_eq!(ed1.edition_number, 1);
let ed_err = mint_edition_token(db_path, None, "dca_001", "did:key:z6MkCollector", 11, 10);
assert!(ed_err.is_err());
let _ = std::fs::remove_file(db_path);
}
}