mirror of https://github.com/Revertron/Alfis
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
461 lines
19 KiB
Rust
461 lines
19 KiB
Rust
4 years ago
|
use std::cell::RefCell;
|
||
|
use std::collections::HashSet;
|
||
|
|
||
|
use chrono::Utc;
|
||
|
#[allow(unused_imports)]
|
||
|
use log::{debug, error, info, trace, warn};
|
||
4 years ago
|
use sqlite::{Connection, State, Statement};
|
||
4 years ago
|
|
||
4 years ago
|
use crate::{Block, Bytes, Keystore, Transaction};
|
||
|
use crate::blockchain::constants::{BLOCK_DIFFICULTY, CHAIN_VERSION, LOCKER_BLOCK_COUNT, LOCKER_BLOCK_INTERVAL, LOCKER_BLOCK_START, LOCKER_DIFFICULTY};
|
||
|
use crate::blockchain::enums::BlockQuality;
|
||
|
use crate::blockchain::enums::BlockQuality::*;
|
||
|
use crate::blockchain::hash_utils::*;
|
||
4 years ago
|
use crate::settings::Settings;
|
||
4 years ago
|
|
||
|
const DB_NAME: &str = "blockchain.db";
|
||
4 years ago
|
const SQL_CREATE_TABLES: &str = "CREATE TABLE blocks (
|
||
|
'id' BIGINT NOT NULL PRIMARY KEY,
|
||
|
'timestamp' BIGINT NOT NULL,
|
||
|
'version' INT,
|
||
|
'difficulty' INTEGER,
|
||
|
'random' INTEGER,
|
||
|
'nonce' INTEGER,
|
||
|
'transaction' TEXT,
|
||
|
'prev_block_hash' BINARY,
|
||
|
'hash' BINARY,
|
||
|
'pub_key' BINARY,
|
||
|
'signature' BINARY);
|
||
|
CREATE INDEX block_index ON blocks (id);
|
||
|
CREATE TABLE transactions (id INTEGER PRIMARY KEY AUTOINCREMENT, identity BINARY, confirmation BINARY, method TEXT, data TEXT, pub_key BINARY);
|
||
|
CREATE INDEX ids ON transactions (identity);";
|
||
|
const SQL_ADD_BLOCK: &str = "INSERT INTO blocks (id, timestamp, version, difficulty, random, nonce, 'transaction',\
|
||
|
prev_block_hash, hash, pub_key, signature) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);";
|
||
|
const SQL_GET_LAST_BLOCK: &str = "SELECT * FROM blocks ORDER BY id DESC LIMIT 1;";
|
||
|
const SQL_ADD_TRANSACTION: &str = "INSERT INTO transactions (identity, confirmation, method, data, pub_key) VALUES (?, ?, ?, ?, ?)";
|
||
|
const SQL_GET_BLOCK_BY_ID: &str = "SELECT * FROM blocks WHERE id=? LIMIT 1;";
|
||
|
const SQL_GET_LAST_FULL_BLOCK: &str = "SELECT * FROM blocks WHERE `transaction`<>'' ORDER BY id DESC LIMIT 1;";
|
||
|
const SQL_GET_PUBLIC_KEY_BY_ID: &str = "SELECT pub_key FROM transactions WHERE identity = ? ORDER BY id DESC LIMIT 1;";
|
||
|
const SQL_GET_ID_BY_ID: &str = "SELECT identity FROM transactions WHERE identity = ? ORDER BY id DESC LIMIT 1;";
|
||
|
const SQL_GET_TRANSACTION_BY_ID: &str = "SELECT * FROM transactions WHERE identity = ? ORDER BY id DESC LIMIT 1;";
|
||
5 years ago
|
|
||
4 years ago
|
pub struct Chain {
|
||
4 years ago
|
origin: Bytes,
|
||
4 years ago
|
pub version: u32,
|
||
5 years ago
|
pub blocks: Vec<Block>,
|
||
4 years ago
|
last_block: Option<Block>,
|
||
4 years ago
|
last_full_block: Option<Block>,
|
||
4 years ago
|
max_height: u64,
|
||
4 years ago
|
db: Connection,
|
||
4 years ago
|
zones: RefCell<HashSet<String>>,
|
||
5 years ago
|
}
|
||
|
|
||
4 years ago
|
impl Chain {
|
||
4 years ago
|
pub fn new(settings: &Settings) -> Self {
|
||
|
let origin = settings.get_origin();
|
||
|
|
||
4 years ago
|
let db = sqlite::open(DB_NAME).expect("Unable to open blockchain DB");
|
||
4 years ago
|
let mut chain = Chain {
|
||
4 years ago
|
origin,
|
||
|
version: CHAIN_VERSION,
|
||
|
blocks: Vec::new(),
|
||
|
last_block: None,
|
||
|
last_full_block: None,
|
||
|
max_height: 0,
|
||
|
db,
|
||
|
zones: RefCell::new(HashSet::new()),
|
||
|
};
|
||
4 years ago
|
chain.init_db();
|
||
|
chain
|
||
5 years ago
|
}
|
||
|
|
||
4 years ago
|
/// Reads options from DB or initializes and writes them to DB if not found
|
||
|
fn init_db(&mut self) {
|
||
4 years ago
|
// Trying to get last block from DB to check its version
|
||
|
let block: Option<Block> = match self.db.prepare(SQL_GET_LAST_BLOCK) {
|
||
4 years ago
|
Ok(mut statement) => {
|
||
4 years ago
|
let mut result = None;
|
||
4 years ago
|
while statement.next().unwrap() == State::Row {
|
||
4 years ago
|
match Self::get_block_from_statement(&mut statement) {
|
||
4 years ago
|
None => {
|
||
|
error!("Something wrong with block in DB!");
|
||
|
panic!();
|
||
|
}
|
||
4 years ago
|
Some(block) => {
|
||
4 years ago
|
debug!("Loaded last block: {:?}", &block);
|
||
|
result = Some(block);
|
||
|
break;
|
||
4 years ago
|
}
|
||
|
}
|
||
|
}
|
||
4 years ago
|
result
|
||
4 years ago
|
}
|
||
|
Err(_) => {
|
||
4 years ago
|
info!("No blockchain database found. Creating new.");
|
||
4 years ago
|
self.db.execute(SQL_CREATE_TABLES).expect("Error creating blocks table");
|
||
|
None
|
||
|
}
|
||
|
};
|
||
|
// If some block loaded we check its version and determine if we need some migration
|
||
|
if let Some(block) = block {
|
||
|
self.max_height = block.index;
|
||
|
if self.version > block.version {
|
||
|
self.migrate_db(block.version, self.version);
|
||
|
} else if self.version < block.version {
|
||
|
error!("Version downgrade {}->{} is not supported!", block.version, self.version);
|
||
|
panic!();
|
||
|
}
|
||
|
// Cache some info
|
||
|
self.last_block = Some(block.clone());
|
||
|
if block.transaction.is_some() {
|
||
|
self.last_full_block = Some(block);
|
||
|
} else {
|
||
|
self.last_full_block = self.get_last_full_block();
|
||
4 years ago
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
4 years ago
|
fn migrate_db(&mut self, from: u32, to: u32) {
|
||
|
debug!("Migrating DB from {} to {}", from, to);
|
||
|
}
|
||
|
|
||
4 years ago
|
pub fn add_block(&mut self, block: Block) {
|
||
4 years ago
|
info!("Adding block:\n{:?}", &block);
|
||
4 years ago
|
self.blocks.push(block.clone());
|
||
|
self.last_block = Some(block.clone());
|
||
4 years ago
|
if block.transaction.is_some() {
|
||
|
self.last_full_block = Some(block.clone());
|
||
|
}
|
||
4 years ago
|
let transaction = block.transaction.clone();
|
||
4 years ago
|
if self.add_block_to_table(block).is_ok() {
|
||
|
if let Some(transaction) = transaction {
|
||
|
self.add_transaction_to_table(&transaction).expect("Error adding transaction");
|
||
4 years ago
|
}
|
||
4 years ago
|
}
|
||
4 years ago
|
}
|
||
4 years ago
|
|
||
4 years ago
|
/// Adds block to blocks table
|
||
|
fn add_block_to_table(&mut self, block: Block) -> sqlite::Result<State> {
|
||
|
let mut statement = self.db.prepare(SQL_ADD_BLOCK)?;
|
||
|
statement.bind(1, block.index as i64)?;
|
||
|
statement.bind(2, block.timestamp as i64)?;
|
||
|
statement.bind(3, block.version as i64)?;
|
||
|
statement.bind(4, block.difficulty as i64)?;
|
||
|
statement.bind(5, block.random as i64)?;
|
||
|
statement.bind(6, block.nonce as i64)?;
|
||
|
match &block.transaction {
|
||
|
None => { statement.bind(7, "")?; }
|
||
|
Some(transaction) => {
|
||
|
statement.bind(7, transaction.to_string().as_str())?;
|
||
|
}
|
||
5 years ago
|
}
|
||
4 years ago
|
statement.bind(8, block.prev_block_hash.as_slice())?;
|
||
|
statement.bind(9, block.hash.as_slice())?;
|
||
|
statement.bind(10, block.pub_key.as_slice())?;
|
||
|
statement.bind(11, block.signature.as_slice())?;
|
||
4 years ago
|
statement.next()
|
||
5 years ago
|
}
|
||
|
|
||
4 years ago
|
/// Adds transaction to transactions table
|
||
|
fn add_transaction_to_table(&mut self, t: &Transaction) -> sqlite::Result<State> {
|
||
|
let mut statement = self.db.prepare(SQL_ADD_TRANSACTION)?;
|
||
4 years ago
|
statement.bind(1, t.identity.as_slice())?;
|
||
|
statement.bind(2, t.confirmation.as_slice())?;
|
||
4 years ago
|
statement.bind(3, t.method.as_ref() as &str)?;
|
||
|
statement.bind(4, t.data.as_ref() as &str)?;
|
||
4 years ago
|
statement.bind(5, t.pub_key.as_slice())?;
|
||
4 years ago
|
statement.next()
|
||
4 years ago
|
}
|
||
|
|
||
4 years ago
|
pub fn get_block(&self, index: u64) -> Option<Block> {
|
||
4 years ago
|
match self.db.prepare(SQL_GET_BLOCK_BY_ID) {
|
||
4 years ago
|
Ok(mut statement) => {
|
||
4 years ago
|
statement.bind(1, index as i64).expect("Error in bind");
|
||
4 years ago
|
while statement.next().unwrap() == State::Row {
|
||
|
return match Self::get_block_from_statement(&mut statement) {
|
||
|
None => {
|
||
4 years ago
|
error!("Something wrong with block in DB!");
|
||
4 years ago
|
None
|
||
|
}
|
||
|
Some(block) => {
|
||
4 years ago
|
trace!("Loaded block: {:?}", &block);
|
||
4 years ago
|
Some(block)
|
||
|
}
|
||
4 years ago
|
};
|
||
4 years ago
|
}
|
||
|
None
|
||
|
}
|
||
|
Err(_) => {
|
||
4 years ago
|
warn!("Can't find requested block {}", index);
|
||
4 years ago
|
None
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
4 years ago
|
/// Gets last block that has a Transaction within
|
||
|
pub fn get_last_full_block(&self) -> Option<Block> {
|
||
|
match self.db.prepare(SQL_GET_LAST_FULL_BLOCK) {
|
||
|
Ok(mut statement) => {
|
||
|
while statement.next().unwrap() == State::Row {
|
||
|
return match Self::get_block_from_statement(&mut statement) {
|
||
|
None => {
|
||
|
error!("Something wrong with block in DB!");
|
||
|
None
|
||
|
}
|
||
|
Some(block) => {
|
||
|
trace!("Got last full block: {:?}", &block);
|
||
|
Some(block)
|
||
|
}
|
||
|
};
|
||
|
}
|
||
|
None
|
||
|
}
|
||
|
Err(e) => {
|
||
|
warn!("Can't find any full blocks: {}", e);
|
||
|
None
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/// Checks if any domain is available to mine for this client (pub_key)
|
||
4 years ago
|
pub fn is_domain_available(&self, domain: &str, keystore: &Keystore) -> bool {
|
||
|
if domain.is_empty() {
|
||
|
return false;
|
||
|
}
|
||
4 years ago
|
let identity_hash = hash_identity(domain, None);
|
||
4 years ago
|
if !self.is_id_available(&identity_hash, &keystore.get_public()) {
|
||
4 years ago
|
return false;
|
||
4 years ago
|
}
|
||
|
|
||
|
let parts: Vec<&str> = domain.rsplitn(2, ".").collect();
|
||
|
if parts.len() > 1 {
|
||
|
// We do not support third level domains
|
||
|
if parts.last().unwrap().contains(".") {
|
||
|
return false;
|
||
|
}
|
||
4 years ago
|
return self.is_zone_in_blockchain(parts.first().unwrap());
|
||
4 years ago
|
}
|
||
4 years ago
|
true
|
||
|
}
|
||
4 years ago
|
|
||
4 years ago
|
/// Checks if this identity is free or is owned by the same pub_key
|
||
|
pub fn is_id_available(&self, identity: &Bytes, public_key: &Bytes) -> bool {
|
||
|
let mut statement = self.db.prepare(SQL_GET_PUBLIC_KEY_BY_ID).unwrap();
|
||
4 years ago
|
statement.bind(1, identity.as_slice()).expect("Error in bind");
|
||
4 years ago
|
while let State::Row = statement.next().unwrap() {
|
||
|
let pub_key = Bytes::from_bytes(statement.read::<Vec<u8>>(0).unwrap().as_slice());
|
||
|
if !pub_key.eq(public_key) {
|
||
|
return false;
|
||
|
}
|
||
|
}
|
||
4 years ago
|
true
|
||
|
}
|
||
|
|
||
4 years ago
|
/// Checks if some zone exists in our blockchain
|
||
4 years ago
|
pub fn is_zone_in_blockchain(&self, zone: &str) -> bool {
|
||
|
if self.zones.borrow().contains(zone) {
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
// Checking for existing zone in DB
|
||
4 years ago
|
let identity_hash = hash_identity(zone, None);
|
||
4 years ago
|
let mut statement = self.db.prepare(SQL_GET_ID_BY_ID).unwrap();
|
||
4 years ago
|
statement.bind(1, identity_hash.as_slice()).expect("Error in bind");
|
||
4 years ago
|
while let State::Row = statement.next().unwrap() {
|
||
|
// If there is such a zone
|
||
|
self.zones.borrow_mut().insert(zone.to_owned());
|
||
|
return true;
|
||
|
}
|
||
|
false
|
||
|
}
|
||
|
|
||
4 years ago
|
/// Gets full Transaction info for any domain. Used by DNS part.
|
||
4 years ago
|
pub fn get_domain_transaction(&self, domain: &str) -> Option<Transaction> {
|
||
4 years ago
|
if domain.is_empty() {
|
||
|
return None;
|
||
|
}
|
||
4 years ago
|
let identity_hash = hash_identity(domain, None);
|
||
4 years ago
|
|
||
4 years ago
|
let mut statement = self.db.prepare(SQL_GET_TRANSACTION_BY_ID).unwrap();
|
||
4 years ago
|
statement.bind(1, identity_hash.as_slice()).expect("Error in bind");
|
||
4 years ago
|
while let State::Row = statement.next().unwrap() {
|
||
|
let identity = Bytes::from_bytes(statement.read::<Vec<u8>>(1).unwrap().as_slice());
|
||
|
let confirmation = Bytes::from_bytes(statement.read::<Vec<u8>>(2).unwrap().as_slice());
|
||
|
let method = statement.read::<String>(3).unwrap();
|
||
|
let data = statement.read::<String>(4).unwrap();
|
||
|
let pub_key = Bytes::from_bytes(statement.read::<Vec<u8>>(5).unwrap().as_slice());
|
||
4 years ago
|
let transaction = Transaction { identity, confirmation, method, data, pub_key };
|
||
4 years ago
|
debug!("Found transaction for domain {}: {:?}", domain, &transaction);
|
||
4 years ago
|
if transaction.check_identity(domain) {
|
||
4 years ago
|
return Some(transaction);
|
||
4 years ago
|
}
|
||
|
}
|
||
|
None
|
||
|
}
|
||
|
|
||
4 years ago
|
pub fn get_domain_info(&self, domain: &str) -> Option<String> {
|
||
|
match self.get_domain_transaction(domain) {
|
||
|
None => { None }
|
||
|
Some(transaction) => { Some(transaction.data) }
|
||
|
}
|
||
|
}
|
||
|
|
||
4 years ago
|
pub fn last_block(&self) -> Option<Block> {
|
||
4 years ago
|
self.last_block.clone()
|
||
|
}
|
||
|
|
||
4 years ago
|
pub fn height(&self) -> u64 {
|
||
|
match self.last_block {
|
||
|
None => { 0u64 }
|
||
|
Some(ref block) => {
|
||
4 years ago
|
block.index
|
||
4 years ago
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
4 years ago
|
pub fn last_hash(&self) -> Bytes {
|
||
|
match &self.last_block {
|
||
|
None => { Bytes::default() }
|
||
|
Some(block) => { block.hash.clone() }
|
||
|
}
|
||
|
}
|
||
|
|
||
4 years ago
|
pub fn max_height(&self) -> u64 {
|
||
|
self.max_height
|
||
|
}
|
||
|
|
||
|
pub fn update_max_height(&mut self, height: u64) {
|
||
|
if height > self.max_height {
|
||
|
self.max_height = height;
|
||
|
}
|
||
|
}
|
||
|
|
||
4 years ago
|
/// Check if this block can be added to our blockchain
|
||
4 years ago
|
pub fn check_new_block(&self, block: &Block) -> BlockQuality {
|
||
|
let timestamp = Utc::now().timestamp();
|
||
|
if block.timestamp > timestamp {
|
||
|
warn!("Ignoring block from the future:\n{:?}", &block);
|
||
|
return Bad;
|
||
5 years ago
|
}
|
||
4 years ago
|
let difficulty = match block.transaction {
|
||
|
None => { LOCKER_DIFFICULTY }
|
||
|
Some(_) => { BLOCK_DIFFICULTY }
|
||
|
};
|
||
|
if block.difficulty < difficulty {
|
||
|
warn!("Block difficulty is lower than needed");
|
||
4 years ago
|
return Bad;
|
||
5 years ago
|
}
|
||
4 years ago
|
if !hash_is_good(block.hash.as_slice(), block.difficulty as usize) {
|
||
4 years ago
|
warn!("Ignoring block with low difficulty:\n{:?}", &block);
|
||
|
return Bad;
|
||
5 years ago
|
}
|
||
4 years ago
|
if !check_block_hash(block) {
|
||
|
warn!("Block {:?} has wrong hash! Ignoring!", &block);
|
||
|
return Bad;
|
||
|
}
|
||
|
if !check_block_signature(&block) {
|
||
|
warn!("Block {:?} has wrong signature! Ignoring!", &block);
|
||
|
return Bad;
|
||
|
}
|
||
|
if let Some(transaction) = &block.transaction {
|
||
|
if !self.is_id_available(&transaction.identity, &block.pub_key) {
|
||
|
warn!("Block {:?} is trying to spoof an identity!", &block);
|
||
|
return Bad;
|
||
|
}
|
||
|
}
|
||
4 years ago
|
match &self.last_block {
|
||
4 years ago
|
None => {
|
||
4 years ago
|
if !block.is_genesis() {
|
||
4 years ago
|
warn!("Block is from the future, how is this possible?");
|
||
4 years ago
|
return Future;
|
||
4 years ago
|
}
|
||
4 years ago
|
if !self.origin.is_zero() && block.hash != self.origin {
|
||
|
warn!("Mining gave us a bad block:\n{:?}", &block);
|
||
|
return Bad;
|
||
4 years ago
|
}
|
||
|
}
|
||
4 years ago
|
Some(last_block) => {
|
||
|
if block.timestamp < last_block.timestamp && block.index > last_block.index {
|
||
|
warn!("Ignoring block with timestamp/index collision:\n{:?}", &block);
|
||
|
return Bad;
|
||
|
}
|
||
|
if last_block.index + 1 < block.index {
|
||
4 years ago
|
warn!("Block is from the future, how is this possible?");
|
||
4 years ago
|
return Future;
|
||
|
}
|
||
4 years ago
|
if block.index <= last_block.index {
|
||
|
if last_block.hash == block.hash {
|
||
|
warn!("Ignoring block {}, we already have it", block.index);
|
||
|
return Twin;
|
||
|
}
|
||
|
if let Some(my_block) = self.get_block(block.index) {
|
||
|
return if my_block.hash != block.hash {
|
||
|
warn!("Got forked block {} with hash {:?} instead of {:?}", block.index, block.hash, last_block.hash);
|
||
|
Fork
|
||
|
} else {
|
||
|
warn!("Ignoring block {}, we already have it", block.index);
|
||
|
Twin
|
||
|
};
|
||
|
}
|
||
4 years ago
|
}
|
||
4 years ago
|
if block.transaction.is_none() {
|
||
|
if let Some(locker) = self.get_block_locker(&last_block, block.timestamp) {
|
||
|
if locker != block.pub_key {
|
||
|
warn!("Ignoring block {}, as wrong locker", block.index);
|
||
|
return Bad;
|
||
|
}
|
||
|
}
|
||
4 years ago
|
}
|
||
|
}
|
||
|
}
|
||
4 years ago
|
|
||
|
Good
|
||
5 years ago
|
}
|
||
|
|
||
4 years ago
|
/// Gets a public key of a node that needs to mine "locker" block above this block
|
||
|
pub fn get_block_locker(&self, block: &Block, timestamp: i64) -> Option<Bytes> {
|
||
|
if block.hash.is_empty() || block.hash.is_zero() {
|
||
|
return None;
|
||
|
}
|
||
|
if block.index < LOCKER_BLOCK_START {
|
||
|
return None;
|
||
|
}
|
||
|
match self.get_last_full_block() {
|
||
|
Some(b) => {
|
||
|
if b.index + LOCKER_BLOCK_COUNT <= block.index {
|
||
|
trace!("Block {} is locked enough", b.index);
|
||
|
return None;
|
||
|
}
|
||
|
}
|
||
|
None => {}
|
||
|
}
|
||
|
// How many 5 min intervals have passed since this block?
|
||
|
let intervals = ((timestamp - block.timestamp) / LOCKER_BLOCK_INTERVAL) as u64;
|
||
|
let tail = block.hash.get_tail_u64();
|
||
|
let start_index = 1 + ((tail + tail * intervals) % (block.index - 2));
|
||
|
for index in start_index..block.index {
|
||
|
if let Some(b) = self.get_block(index) {
|
||
|
if b.pub_key != block.pub_key {
|
||
|
trace!("Locker block for block {} must be mined by owner of block {} block_hash: {:?}", block.index, b.index, block.hash);
|
||
|
return Some(b.pub_key);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
None
|
||
|
}
|
||
|
|
||
4 years ago
|
fn get_block_from_statement(statement: &mut Statement) -> Option<Block> {
|
||
|
let index = statement.read::<i64>(0).unwrap() as u64;
|
||
|
let timestamp = statement.read::<i64>(1).unwrap();
|
||
4 years ago
|
let version = statement.read::<i64>(2).unwrap() as u32;
|
||
4 years ago
|
let difficulty = statement.read::<i64>(3).unwrap() as u32;
|
||
4 years ago
|
let random = statement.read::<i64>(4).unwrap() as u32;
|
||
|
let nonce = statement.read::<i64>(5).unwrap() as u64;
|
||
|
let transaction = Transaction::from_json(&statement.read::<String>(6).unwrap());
|
||
|
let prev_block_hash = Bytes::from_bytes(statement.read::<Vec<u8>>(7).unwrap().as_slice());
|
||
|
let hash = Bytes::from_bytes(statement.read::<Vec<u8>>(8).unwrap().as_slice());
|
||
4 years ago
|
let pub_key = Bytes::from_bytes(statement.read::<Vec<u8>>(9).unwrap().as_slice());
|
||
|
let signature = Bytes::from_bytes(statement.read::<Vec<u8>>(10).unwrap().as_slice());
|
||
|
Some(Block::from_all_params(index, timestamp, version, difficulty, random, nonce, prev_block_hash, hash, pub_key, signature, transaction))
|
||
4 years ago
|
}
|
||
4 years ago
|
}
|