ShionCoin Virtual Currency Announcement (Public Debut - v3.1)

[shcoins]

This is the first official public announcement of the ShionCoin virtual currency.
Version: 3.1

ShionCoin has been in development for several years, and is finally making it's public debut. This currency is compatible with SCRYPT based platforms such as lite-coin. Modern features, such as seg-wit, are included.

Download
You can download pre-built binary packages from https://shcoins.com/download/shioncoin/ (windows / linux). You can obtain the source code from https://github.com/neonatura/shioncoin/ in order to build the package yourself.

The block-chain and wallet information is stored in "/var/lib/shioncoin/" on linux and "C:\programdata\shioncoin\" on windows. Several console commands are provided in order to backup and restore node peers, wallet, and block-chain information.

A online pool and wallet is available at https://shcoins.com/ that does not require downloading any software.


Quick Linux Build

_{git clone https://github.com/neonatura/shioncoin/
mkdir shioncoin/build
cd shioncoin/build
../configure}

The software is written in C and C++, and is designed for a 64-bit architecture. You can build through msys2 64-bit on windows.

Use the "./autogen.sh" script (in the base directory) to re-generate the autoconf configuration files in the event you run into an automake incompatibility.


Stratum Service

The ShionCoin Stratum Service provides full-capability gateway access for scrypt coin miner devices. In typical scenerios, a seperate program is required in order to provide this service. In addition, capabilities for creating and managing wallet accounts is provided for web/API interfacing.

Note: The stratum service utilizes supplemental methods that are not standard, and require a compatible API client for full usage.

Stratum Port: 9448

The stratum status web-page http://localhost:9448/ will display a "verification fractal" which can be compared to other sites in order to verify the integrity of their block-chain.


Fast and Affordable Transactions

ShionCoin has a 60-second block difficulty and has a smaller transaction fee than typical coin services in order to ensure sending transactions is possible for small and large fund transfers alike.

A 4mb allowance size for each blocks ensures that thousands of transactions can be stored in each block. The ShionCoin has been developed with Channel Transaction frame-work, similar to the lightning network, that allows for a series of transaction to be performed "off chain".


Coin Address Alias

Create aliases for coin addresses and store them on the global block-chain. This provides the ability for other users to directly reference your own established name without the need to remember a lengthy coin address.

Alias commands can be used in lue of a coin address by prepending a "@" character.

Creating an alias initially cost around 20 SHC, and this fee goes down in cost over time. Aliases expire after 12 years.

Example "shc" console commands:
_{alias.set test <coin addr>
alias.get test
wallet.send bank @test 10}

Context Data

Contextual data may be stored in the block-chain describing people, places, or any other arbitrary information. This functionality has aspects similar to name-coin, except that the context data content has a larger 4k limit per record.

A context record will expire after two years. The owner can update the context with a new (or original) value which will reset the expiration date.

Creating a context initially cost around 20 SHC, and this fee goes down in cost over time.

Example "shc" console commands:
_{ctx.setloc bank "Missoula, MT" "geo:46.8787,113.9966" AREA US
ctx.getloc geo:46.8787,113.9966}


Certification

Chained certificates may be created on the global block-chain which are linked to a particular coin address.

Certified fund transfers may be made by associating a transaction with a particular certificate. This allows the end-point to verify the origin of the funds. Certificates are not required to send funds, though.

A fee may also be associated with a certificate allowing for certificates derived from it to be purchased.

A certificate may also be derived into a license. Licensing can be used with SEXE scripts and also can be integrated into a application key via the libshare suite thereby requiring a license to be purchased from the ShionCoin network in order for a program to be executed.

Asset transactions may be created and optionally signed with a certificate. These transactions are meant to be used in order to provide a record for physical items such as property or equipment. An asset transaction will not expire.

Creating a certificate initially cost around 10 SHC, and this fee goes down in cost over time. Certificate transactions will expire after 48 years, and cannot be updated after creation.

Example:
_{cert.new bank "test CA"
  { .. "certhash": "d9ac92d017b790eee16e3fd46c8e376318144a81" .. }
cert.get d9ac92d017b790eee16e3fd46c8e376318144a81
cert.derive "test certificate" d9ac92d017b790eee16e3fd46c8e376318144a81 1}


Geodetic Stamping

The ShionCoin Spring Matrix contains bit-vectors derived from over 1000000 public geodetic landmark locations. Each time a geodetic stamp is performed on a particular location contained in the matrix the bit-flag representing that location is removed. As time progresses it will become more difficult to pinpoint unique locations that have not already been found.

A geodetic stamp is performed in order to "stamp" an identity derived from a coin address onto a particular geodetic location. Any valid latitude and longitude pair may be "stamped". If the location happens to be an unfound location stored in the spring matrix then the ShionCoin network will automatically reward you ONE SHC to the account which stamped the location.

Example "shc" console commands:
_{wallet.stamp bank "geo:46.8787,113.9966"
"ident":  {
    "label":  "geo:46.8787,113.9966",
    "geo":  "46.878700,113.996600",
    "addr": "SM5JyMLR2RFzPnEBd2UXUWLzsKvGvxaDQL"
}}


SEXE Scripting

Scripts associated with a particular coin server node may be created in the libshare SEXE programming language (based on LUA). These scripts allow for the tracking of information and creation of block transactions. An example script might be a simple coin faucet which collects and distributes coins, or something more complicated like a music ticket outlet.

A SEXE transaction will expire after 48 years.

Example SEXE faucet program:

Code:

function send(a, v)
  userdata.txout = { }
  userdata.txout.addr = a
  userdata.txout.value = v
  userdata.total = userdata.total - v
end
function donate(farg)
  if (farg.value >= 1) then
    userdata.total = userdata.total + farg.value
    userdata.stamp = 0
    return farg.value
  end
  return 0
end
function spigot(farg)
  local a = abs(time() / 60)
  local b = abs(userdata.stamp / 60)
  if (a == b) then
    -- 1 SHC / minute --
    return 0
  end
  if (userdata.total >= 1) then
    send(farg.sender, 1)
    userdata.stamp = time()
    return 1
  end
  return 0
end
function init(farg)
  userdata.owner = farg.sender
  userdata.total = 0
  userdata.donate = donate
  userdata.spigot = spigot
  return 0
end

Off-chain Channel

Frame-work has been provided to allow for off-chain channel transactions. Off-chain transactions are a series of transactions which are established between two peers.

The channel mechanism utilizes a HDKey set in order to generate a multi-sig transactions without having to exchange the end-result public keys destinations.


Coin Exchange Offers

Frame-work has been provided to allow for a set of transaction to be performed which exchange a set of coins from one virtual currency to another.


Client Utility Program

The ShionCoin virtual currency can be interfaced through a command-line console utility program called "shc". Type "shc help" or "shc <command> help" for additional usage information.

Examples:

Sending and receiving a funds transfer transaction.
_{shc wallet.new test
shc wallet.listaddr test}

Send 1.5 SHC to address generated.
_{shc wallet.balance test
shc wallet.new test2
shc wallet.send test S9cXrHRUoDSJdNvBANSUVPKrMxCWGxHMuH 1.5}

Wait for transaction to be committed to a block.
_{shc wallet.unspent test
shc wallet.balance test2}

Backup server data to an external file.
_{mkdir /root/.shc
shc wallet.export /root/.shc/wallet.Mar2018.json
shc peer.export /root/.shc/peer.Mar2018.json
shc block.export /root/.shc/chain.Mar2018.bin
shc wallet.exportdat /root/.shc/wallet.Mar2018.bin}

[1714639286]

1714639286

[shcoins]

The following is a brief overview of the commands provided by the "shc" utility console program.

The utility program "shc" communication with the server (shcoind) are restricted to the local host that the service is running. You must use the stratum API in order to access the server from a remote machine.

A sub-set of all the commands are provided here. This guide attempts to concentrate on commonly used commands that are useful. Run "shc help" for a full list of commands. Run "shc help <command>" for details about running that particular command.

You can enter an interactive mode by running "shc --prompt".

Run the daemon with "shcoind --debug" in order to print additional information to the log file (on linux, "/var/lib/share/shcoind.log") for diagnostic purposes.

ShionCoin "pub-key" coin addresses typically starts with "S" or "R". A "script address" will start with "1" and a seg-wit address will start with "3". Coin addresses are verified when entered on the command-line in order to ensure that the address is prudent in respect to the coin interface.

All fees for extended transactions, such as creating context and aliases, are either stored (for update purposes) in a local extended account and/or are provided as mining fees. You can use the "wallet.donate" command to intentionally create a transaction which includes a specified mining reward value.

Wallet Commands

The wallet commands provides capabilities to transfer funds and manage accounts. Each account can contain several coin addresses and has a counter-part "extended account" that is not visible.

Wallet Info: wallet.info

Display statistical and runtime information on wallet operations.


_{shc wallet.info
{
   "version":   3010000,
   "walletversion":   60000,
   "balance":   658,
   "keypoololdest":   1517000561,
   "keypoolsize":   101
}}


Create Coin Address: wallet.new


The "wallet.new" command is used to create a normal (non seg-wit) coin address and associate it with an account name. Coin addresses may be automatically generated for accounts, for example in order to return "change" in a fund transfer transaction. All change is directly returned to the associated account.

_{shc wallet.new test
S2fzfzf1SStvaMzjGpCtYKxY3t8PXus9Ci}


List Accounts: wallet.list

The "wallet.list" command provides a balance of all accounts in the coin wallet.

_{shc wallet.list
{
   "":   0,
   "bank":   658,
   "system":   0
}}


Three accounts are created by default. The "" account receives coinbase rewards which are then distributed to users based on their stratum stats. The "bank" account is a 0.1% cut of the rewards received from the stratum mining pool. The "system" account is currently reserved for a cpu-miner which attempts a single mining operation each time new task work is assigned to miners. The frequency of how often this occurs is based on tracking the "luck" of past attempts.

List Coin Addresses: wallet.listaddr

The "wallet.listaddr" command will list all of the coin addresses associated with an account.


_{shc wallet.listaddr test
["S2fzfzf1SStvaMzjGpCtYKxY3t8PXus9Ci"]}


Create Transaction: wallet.send

The "wallet.send" command is the primary method of sending funds.

All ShionCoin transactions are sent with at least the 0.0001 SHC minimum fee. Providing the minimum fee is provided, any fee can is permitted and affects the priority of the transaction.


_{shc wallet.send bank S2fzfzf1SStvaMzjGpCtYKxY3t8PXus9Ci 10
307711dace8c0583b744af8acd1df2073e36b0c7a54b8830a15ae146f8c22ddb}


Test Create Transaction: wallet.tsend

You can "test send" a transaction in order to determine the aproximate fee and size that would result.

_{shc wallet.tsend bank SLbnKamvSx8FhaBNpHUwffFDLZ16J8phdX 10
{
   "amount":   10,
   "tx-amount":   98.999900,
   "size":   300,
   "virt-size":   226,
   "fee":   0.000100,
   "inputs":   1,
   "priority":   1085539000000
}}


Create Batch Transaction(s): wallet.bsend

The "wallet.bsend" command allows you to transfer funds that are more complicated than would be permitted in a single transaction. Multiple transactions will be created, as neccessary, in order to send the specified coin value. The total value commited to be sent may be lower than the value requested under certain circumstances.

Create Certified Transaction: wallet.csend

The "wallet.csend" associated a pre-created certificate with the coin transfer. The certificate may be used to associate with the certificate, or provide a method to identity the source of the funds.


_{shc wallet.csend bank SLbnKamvSx8FhaBNpHUwffFDLZ16J8phdX 10 <cert-hash>}


Create Stamp Transaction: wallet.stamp

The "wallet.stamp" command allows you to create a short message (up to 135 characters), or reference a geodetic location, to associate with a local coin address. The stamp transaction is the exclusive method of claiming spring matix location coins. Creating a stamp in the format "geo:<latitude>,<longitude>" will result in a single SHC coin, once processed on the network, being rewarded for all locations not yet discovered in the spring matrix. A minimum transaction fee (0.0001) is applied for each stamp transaction created.  

Use the "ctx.findloc" command in order to search for locations active in the sprint matrix.




Validate Address: wallet.donate

Donated coins are added to the upcoming block reward. Donations may be optionally associated with a certificate. The maximum donation value in a single transaction is 500 coins. Donations are associated with the coin address that generates them, and may contain a geodetic stamp depending on configuration and availability.

The total cost will include the donation coin value specified plus a minimum transaction fee (0.0001 SHC).


_{{
   "version":   1,
   "flag":   1025,
   "txid":   "ace04609d0eca593b73a3f1afb1dcfeb10049c4ab4098ff9b17e01da65bf2ec6",
..
   "ident":   {
      "version":   3,
      "expire":   "                    ",
      "geo":   "46.770000,113.980000",
      "addr":   "SFrXpo9ykcSeycTdMaFu3xWwJFxN5gkUH4"
   }
}}


Validate Address: wallet.validate

The "wallet.validate" command returns general information about the coin address specified, including whether the coin address is contained in the local wallet.


_{shc wallet.validate SLbnKamvSx8FhaBNpHUwffFDLZ16J8phdX
{
   "isvalid":   true,
   "address":   "SLbnKamvSx8FhaBNpHUwffFDLZ16J8phdX",
   "ismine":   true,
   "account":   "system"
}}


Validate Address: wallet.key

Obtain a code that identifies the private key of a coin address.

Validate Address: wallet.setkey

Create a new coin address, for the specified account, with a private key code.

Validate Address: wallet.keyphrase

Obtain a set of phrases that identify the private key associated with a coin address.

Validate Address: wallet.setkeyphrase

Create a coin address in the wallet given a key phrase.

Export Wallet (json): wallet.export

Creates a JSON formatted backup of all the accounts managed.

Export Wallet (datafile): wallet.exportdat

Creates a binary backup, in the tradition bitcoin wallet format, of all the accounts in the wallet.

Import Wallet (json): wallet.import

Creates a JSON formatted backup of all the accounts managed.

Scan Wallet: wallet.rescan

Cycle through all known wallet transactions and verify their state in the block-chain.

Block Commands

BlockChain Info: block.info

Print summarized information about the block-chain.


_{shc block.info
{
   "version":   2000000,
   "blockversion":   2,
   "walletversion":   60000,
   "blocks":   77029,
   "difficulty":   0.000488,
   "pooledtx":   0,
   "currentblockhash":   "5c4e3a637d857c7df925dda1c017dd3864c0fb95c1421276619810f5b95fc8c5",
   "errors":   ""
}}


Print Block (hash): block.get

Print detailed information about the specified block hash.


_{shc block.get bc157eefd48e18152c70ad2937bd44e6bb38d218bf13c262a844a3d0ae9264d6
{
   "blockhash":   "bc157eefd48e18152c70ad2937bd44e6bb38d218bf13c262a844a3d0ae9264d6",
   "version":   536870912,
   "merkleroot":   "5bda555d945bc36806f1eb4913a47a2ecad4569133cce1d59bd82ad94e7be1c6",
   "time":   1521898215,
   "stamp":   "03/24/18 07:30:15",
   "nonce":   4422421,
   "bits":   "1e07ffff",
   "previousblockhash":   "3312abddb29aea55f44a0e3c52d397d3041b9e2deaa160f2ac415cdca05057b9",
..
}}

Print Block Hash (height): block.hash

Obtain the block hash for a specified block height.


_{shc block.hash 77022
bc157eefd48e18152c70ad2937bd44e6bb38d218bf13c262a844a3d0ae9264d6}


Export BlockChain: block.export

Export an entire block-chain to a binary file. The actual export of data is performed asynchronously (in the background), and the log file should be reviewed to determine when the operation is actually done.


<sub>shc block.export /root/.shc/block.bin
{
   "mode":   "export-block",
   "minheight":   0,
   "maxheight":   0,
   "path":   "/root/.shc/block.bin",
   "state":   "init"
}

tail /var/log/share/shcoind.log
..
[03/24/18 07:47:14] info: shc: PerformBlockChainOperation: saved 77105 blocks to path "/root/.shc/block.bin".</sub>


Import BlockChain: block.import

Import a previously exported block-chain into the live system. The imported file will only over-write block records that do not previously exist.

BlockChain Scan: block.verify

Perform an integrity check against the last X blocks in the block-chain.

Transaction Commands

Print Transaction: tx.get

Print details for a particular transaction from it's transaction hash.


_{shc tx.get 307711dace8c0583b744af8acd1df2073e36b0c7a54b8830a15ae146f8c22ddb
{
   "version":   1,
   "flag":   1,
   "txid":   "307711dace8c0583b744af8acd1df2073e36b0c7a54b8830a15ae146f8c22ddb",
..
}}


Print Transaction: tx.pool

Print details for all transaction currently pending in the active "mempool" queue. These are transactions that are actively being inserted into mined blocks.

Print Transaction: tx.validate

Validate a transaction hash associated with the local wallet. Prints summarized information about all local coin addresses associated with the transaction.


_{shc tx.validate 307711dace8c0583b744af8acd1df2073e36b0c7a54b8830a15ae146f8c22ddb
[{
   "spent":   "false",
   "ismine":   "true",
   "address":   "S7viXBKwUZKy4aPCby3oXzWFDxhZKjGipA"
}, {
   "spent":   "false",
   "ismine":   "true",
   "address":   "S2fzfzf1SStvaMzjGpCtYKxY3t8PXus9Ci"
}]}

Peer Commands

Import Peers: peer.info

Display a summary of information relating to connected peers.


_{{
   "clientversion":   3010000,
   "protocolversion":   2000000,
   "socketport":   24104,
   "connections":   3,
   "networkhashps":   11609,
   "errors":   ""
}}


Import Peers: peer.list

Display information about each node peer currently connected to the coin interface.

Export Peers: peer.export

Export all of the known peers to a JSON file.


_{./shc peer.export /root/.shc/peer.json
{
   "mode":   "peer.export",
   "path":   "/root/.shc/peer.json",
   "state":   "finished"
}}


Import Peers: pee[Suspicious link removed]port

Import a JSON file containing node peer information.

Remove Peer: peer.remove

Disconnect and remove the specified peer from the system.

Context Commands

Context Info: ctx.info

Print the current fee to create a context transaction and the total number of context records in the system.


_{{
   "fee":   25,
   "total":   1
}}



Print String Context: ctx.getstr

Prints the ASCII value associated with a particular context name.


_{shc ctx.getstr "test name"
test value}


Print Context: ctx.get

Prints detailed information about a context record given it's context hash.


_{shc ctx.get ab5b128ce3674f81f0271efbbbb191fed56e9a80
{
   "version":   3,
   "label":   "ab5b128ce3674f81f0271efbbbb191fed56e9a80 test name                (1zgfTHd5BQA)",
   "expire":   "Mar 23 08:28:39 2020",
   "flags":   10244,
   "signature":   "e0539d3ecb54c5c0a29ccd69f0b03dfdfb58bc24",
   "hash":   "ab5b128ce3674f81f0271efbbbb191fed56e9a80",
   "valuesize":   10,
   "valuecrc":   "1zgfTHd5BQA",
   "tx":   "0dbf21191091e33ad7be3b1ce1983ffffdbedeb804e3ce934021f0fad038d50e"
}}


Create String Context: ctx.findloc

Search for a location by it's name or with geodetic cordinates.

The "ctx.findloc" will scan an area and attempt to find a location within it. This area includes a span of about 100 sq. miles. The closest location with the smallest precision found will be returned. In addition, geodetic information provided by the share library is also utilized.


_{shc ctx.findloc "geo:46.9,114.2"
{
   "name":   "missoula, mt",
   "summary":   "Montana",
   "zone":   "America/Denver",
   "code":   "MUNI",
   "country":   "US",
   "geo":   "46.94000,114.04000",
   "type":   "Municipal Zone",
   "springable":   "false"
}
shc ctx.findloc "Missoula, MT"
{
   "name":   "missoula, mt",
   "summary":   "Montana",
   "zone":   "America/Denver",
   "code":   "MUNI",
   "country":   "US",
   "geo":   "46.94000,114.04000",
   "type":   "Municipal Zone",
   "springable":   "false"
}}


Note: The "springable" value denotes whether the geodetic location can be claimed in the SHC spring matrix (see "wallet.stamp").

Create String Context: ctx.getloc

Print detailed information about a particular location by it's name or geodetic cordinates.

The "ctx.getloc" command requires specific cordinates to be specified when a latitude and longitude is specified.


_{ctx.getloc "Missoula Creek"
ctx.getloc geo:46.9846,114.1213}


Note: The "springable" value denotes whether the geodetic location can be claimed in the SHC spring matrix (see "wallet.stamp").

Create String Context: ctx.setstr

Create a text format context value. This establishes a simple name=value relationship.

Context names are stored as hash keys. Therefore, the string name of the context key must be known before-hand in order to perform the lookup. A small label is also provided as part of the context record which includes a snippet (or all of) the context name.

Context records are signed against the coin address that paid to generate the transaction. Context transaction typically cost about 25 SHC or less to create. A context will expire two years after the date at which it is either created or updated. The owner can update a context by creating a new one with the same name as a pre-existing one. The "context hash" that identifies a context is also the key hash of it's label. The context is shown as part of the transaction details.


_{shc ctx.setstr test "test name" "test value"
{
   "version":   3,
   "label":   "ab5b128ce3674f81f0271efbbbb191fed56e9a80 test name                (1zgfTHd5BQA)",
   "expire":   "Mar 23 08:28:39 2020",
   "flags":   10244,
   "signature":   "e0539d3ecb54c5c0a29ccd69f0b03dfdfb58bc24",
   "hash":   "ab5b128ce3674f81f0271efbbbb191fed56e9a80",
   "valuesize":   10,
   "valuecrc":   "1zgfTHd5BQA",
   "tx":   "0dbf21191091e33ad7be3b1ce1983ffffdbedeb804e3ce934021f0fad038d50e"
}}


Create Geodetic Context: ctx.setloc

The "ctx.setloc" command creates contextual information about a specific place.

The command includes information about a location zipcode, name, and description. In addition, an optional place type code, country code, and web-url can be specified.

The place type corrosponds to one of the codes returned from the "ctx.loctypes" command.

This command has two different modes. One corrosponds to giving a name to a particular geodetic latitude and longitude corindate, and the other includes providing details about that particular location. A single location (as specified by latitude and longitude) may have multiple names, but it limited to a single set of details. Although some common places may be reserved from use (such as common city names), the application of detailed information to a geodetic location comes on a first-come-first-serve basis. Note that context information expires after two years.

The size of the area being referenced is dependent on the place type specified. For example, "AREA" spans roughly 30 sq. miles, while "SPOT" only spans 8 sq. feet. This precision is used in relation to geodetic lookups performed.  


_{shc ctx.setloc test geo:46.9846,114.1213 "Bitterroot Creek" STM US
shc ctx.setloc test "Missoula Creek" geo:46.9846,114.1213}


Create Identity Context: ctx.setid

Create a binary context from the raw command-line argument specified.

Create Binary Context (raw): ctx.setbin

Create a binary context from the raw command-line argument specified.

Create Binary Context (file): ctx.setfile

Create a binary context from the absolute path specified.

Print Location Types: ctx.loctypes

Print out all suported location type codes for use with the "ctx.setloc" command.


_{[{
      "name":   "AREA",
      "desc":   "General Area",
      "prec":   1
   }, {
      "name":   "MT",
      "desc":   "Mountain",
      "prec":   1
   },
..
}}

Address Alias Commands

Alias Info: alias.info

Print the current fee to create an alias transaction and the total number of alias records in the system.


_{shc alias.info
{
   "fee":   31.250000,
   "total":   1
}}


Create Address Alias: alias.pubaddr

Create a persistent public association with a name and a coin address. Once confirmed, the coin address can be referenced as "@<name>" in command-line operations.

When a coin address is specified the alias label will be published onto the block chain in reference. If the alias label already exists, then a transfer will occur providing you are the original owner.

A coin address will be automatically created if none is specified. Only "pub-key" coin addresses are currently supported. An alias will expire after 12 years.

An alias cost around 30 SHC to create and will decrease over time.


<sub>shc alias.pubaddr test S2fzfzf1SStvaMzjGpCtYKxY3t8PXus9Ci
{
..
   "alias":   {
      "version":   1,
      "label":   "test",
      "expire":   "Mar 21 09:37:40 2030",
      "type":   30,
      "addr":   "S2fzfzf1SStvaMzjGpCtYKxY3t8PXus9Ci",
      "type-name":   "pubkey"
   }
}

./shc wallet.send bank @test 2
d438fea502b7113f155617fc1b400161bb3045645094df5423ce7e484fadf7f2</sub>


List Address Alias: alias.list

Print all aliases that match the keyword provided.


_{shc alias.list
{
   "test":   {
      "block":   "79b04f63fe5602f40bc559b1c5b39b730a2d6ea2d6b4ab491904d6054b1add71",
      "tx":   "abb12ed2f4a74c58432afa9e19c08afad1d3dd84052f23be534e96ed53e11d4f",
      "alias":   "77135966b271a06928cdff5548dbbaed61ee7250",
      "addr":   "S2fzfzf1SStvaMzjGpCtYKxY3t8PXus9Ci"
   }
}}


Print Address Alias: alias.getaddr

Print details about a particular coin address alias given it's name.


_{shc alias.getaddr test
{
   "version":   1,
   "label":   "test",
   "expire":   "Mar 21 09:37:40 2030",
   "type":   30,
   "addr":   "S2fzfzf1SStvaMzjGpCtYKxY3t8PXus9Ci",
   "type-name":   "pubkey"
}}

Certificate Commands

Certificate Info: cert.info

Prints the current certificate transaction fee and the total number of certificates created on the block-chain.


_{shc cert.info
{
   "fee":   14.750000,
   "total":   1
}}


Certificate Info: cert.list

Search for a certificate given the provided keyword.


_{shc cert.list test
{
   "test certificate":   "8069f1bbfb435cfa1efdb454684446528343b809"
}}


Certificate Info: cert.new

The "cert.new" command is used to create a new certificate on the block-chain. The certificate than may be used to derive other certificates or dispense licences. The certificate may have an optional fee specified that will be required to derive or license it.

A certificate can either be designated for issueing other certificates or granting licenses, but not both. Either form of the certificate may be used in order to donate or send a certified coin transfer.

A certificate is signed against a private key that is generated from the associated extended account coin address. You may optionally specify a hexadecimal seed to use for generating the private key. The certificate's private key is not stored in a database or a transaction, and requires the original coin address to be present in the local wallet to be determined. The public key is provided as part of the certificate transaction, and can be used in order to verify the integrity of the associated signature.

The average fee for registering a new certificate is initially about 15 SHC and will decrease over time. The details of the certificate are visible in the underlying transaction that it was generated in.

The frame-work of the certificate is designed to be compatible with the x509 format. See the "shcert" share library utility program for more information on exporting x509 certificate created on the ShionCoin block-chain. Certificates may also be used to provide licensing authentication to run or provide features to programs using the share library "esig" functionality (see the "shesig_verify()" function).

Note that the certificate may contain identifying information such as the originating coin address and, when available, the geodetic location.


_{shc cert.new test "test certificate"
{
   "version":   1,
   "flag":   17,
   "txid":   "18d0a73c96af3dd211f27e4ada898e13b4cf25223da2591289edb8a1e86f1129",
..
   "certificate":   {
      "version":   3,
      "label":   "test certificate",
      "expire":   "Mar 24 04:13:46 2066",
      "geo":   "46.770000,113.980000",
      "addr":   "SC2j6kxbrKzfpxsGqBQSrxeDh2CdPn1TLJ",
      "certhash":   "8069f1bbfb435cfa1efdb454684446528343b809",
      "issuer":   "0000000000000000000000000000000000000000",
      "serialno":   "0c96a132d74df2522f38babf0733224c",
      "flags":   10244,
      "signature":   "0d5a4e6c7d4975ee443cfc2e057d3d76070bd2f5",
      "sigpubkey":   "0334d9f89253fa0837a1524266414509bdce478368"
   }
}}


Certificate Info: cert.get

Print the details of a certificate record given the certificate hash.


_{{
   "version":   3,
   "label":   "test certificate",
   "expire":   "Mar 24 04:13:46 2066",
   "geo":   "46.770000,113.980000",
   "addr":   "SC2j6kxbrKzfpxsGqBQSrxeDh2CdPn1TLJ",
   "certhash":   "8069f1bbfb435cfa1efdb454684446528343b809",
   "issuer":   "0000000000000000000000000000000000000000",
   "serialno":   "0c96a132d74df2522f38babf0733224c",
   "flags":   10244,
   "signature":   "0d5a4e6c7d4975ee443cfc2e057d3d76070bd2f5",
   "sigpubkey":   "0334d9f89253fa0837a1524266414509bdce478368",
   "txid":   "18d0a73c96af3dd211f27e4ada898e13b4cf25223da2591289edb8a1e86f1129"
}}


Certificate Info: cert.derive

Derive a certificate from another certificate. You can optionally specify a fee to be associated with the new certificate, and a fee may be required if one is associated with the parent certificate.

Certificate Info: cert.license

Generate a license from a certificate. A license represents authorization to use a particular product and typically requires a fee to be paid. You can optionally specify a hexadecimal seed to be used when creating the certificate's private key.

Certificate Info: cert.export

Exports the private key information from the extended account that is used to claim ownership over a particular certificate.

Ownership and management of a certificate depends on having specific coin address key(s) in the coin wallet. Exporting a certificate provides JSON formatted content which can be used with "wallet.import" command to attain ownership of a certificate.

[vanobe]

The website's not working.

[shcoins]

The website's not working.

For reference, the url is: https://shcoins.com/ (173.230.134.6). Please note that this site requires that javascript be enabled.

I have found a problem with rendering javascript on Internet Explorer. The problem has been fixed. Note that I was not able to reproduce the problem in firefox, chrome, or edge. The symptoms included being able to see the main page's main content, but not having access to the navigation bars which let you login or go to the block explorer, etc.

You may have to reload the page (ctrl-r) in order to see the changes (due to browser caching).

Can you please try again and let me know if the problem is resolved. If not, can you elaborate? Is the entire site not accessible? Is "http://shcoins.com/" also not accessible to you (i.e. "http" vs "https")? Or does this relate to a specific portion of the web site (such as block explorer).  Also, what browser are you using?

[vanobe]

Can you please try again and let me know if the problem is resolved

It's working for me now thanks.

[shcoins]

Version: 3.1
Platform: Linux
Source: https://github.com/neonatura/shioncoin/

Two release programs are built; the "shcoind" daemon which provides coin interface functionality, and the "shc" utility program which provides RPC communication for performing operations against the server.

The "shc" utility program must have permission to read the "/var/lib/shioncoin/blockchain/rpc.dat" file in order to communicate to the server. The utility program must be ran on the same machine that the "shcoind" daemon is running on.

All commands below assume you are logged in as the "root" user. Installation packages are generally referred to for the CentOS distribution, and are typically fairly similar for Ubuntu.

Package Dependencies

The "shcoind" daemon has a few dependencies that will need to be installed before it can be compiled.

In order to setup your system for normal development you can run the following:

_{yum install gcc make automake cpp}


C++ Database Library

The "C++ Database" is used in order to store wallet information. The wallet is compatible with the legacy bitcoin format.

_{yum install libdb-cxx}


Boost Runtime Library

The "shcoind" daemon utilizes the "system", "filesystem", and "thread" modules.

_{yum install boost-system boost-filesystem boost-thread}


GMP Math Library

The "GMP" library provides complex math functionality.

_{yum install gmp-devel
apt-get install libgmp-dev}


Share Runtime Library

Installation of the share runtime library is optional, in that, a local copy will automatically be downloaded and compiled by the "shioncoin" package if it is not already installed. It is recommended to install the share runtime library independantly in order to take full advantage of all the ShionCoin virtual currency features available.

_{cd /tmp
git clone https://github.com/neonatura/share
cd share
./autogen.sh
mkdir build
cd build}

On CentOS:
_{../configure --libdir=/usr/lib64
make
make install
ldconfig}

On Ubuntu:
_{../configure
make
make install}

You can test that the installation has properly been installed by running a test of one of the utility programs provided:

_{shgeo "Missoula, MT"}

You can optionally perform a "make check" in order to run the full unit-testing against the underlying functionality provided by the library. Note that this can take some time to perform.

Compiling the Main Package

Run the following in order to download and compile the ShionCoin package:

_{cd /tmp
git clone https://github.com/neonatura/shioncoin/
cd shioncoin
./autogen.sh
mkdir build
cd build
../configure
make
make install}

The "make install" command above is optional. Once a "make" has been performed a sym-link of the executables are available in the "/tmp/shioncoin/build/bin/" directory.

_{cd bin
mkdir -p /root/shc
cp shcoind /root/shc
cp shc /root/shc}

You can optionally run a "make check" in order to perform unit-testing against the underlying ShionCoin interface functionality. It may be neccessary to remove the files "/var/lib/share/blockchain/test_*" if this program is ran more than once. The test program uses a seperate block-chain, and does not otherwise affect the main ShareCoin block-chain. No "test net" is currently being provided.

Service Running and Installing

If you installed the libshare runtime library, then run "shpref shcoind.debug true" in order to print verbose information to the log file.

The current method used to install the "shcoind" service to start upon boot pre-dates the newly introduced "systemctl" standard, and there-fore you will likely need to install the service manually.

Paste the following into a new file "/etc/systemd/system/shcoind.service".

Code:

[Unit]
Description = ShareCoin
After = network.target

[Service]
ExecStart = /usr/local/bin/shcoind

[Install]
WantedBy = multi-user.target

Run the "shcoind" program in order to manually start the service. You can run "shcoind -nf" in order to start the program in the foreground. A log file is written at "/var/log/share/shcoind.log".

Troubleshooting

In the event that the block-chain becomes corrupted or un-usable, you can restore from an automatically generated backup. The backup will only contain a majority of the original block-chain. Restoring a backup chain does not affect the wallet.

Ensure the "shcoind" daemon is not running and follow the instructions below:

_{cd /var/lib/shioncoin/blockchain/
mkdir arch
cp shc_* arch
rm shc_block.* shc_tx.* shc_coin.*
shcoind --shc-rebuild-chain}

Once the "shcoind --shc-rebuild-chain" command has finished you can start up the "shcoind" daemon.

If the block-chain enters into a fault state where no new blocks are accepted, it is possible to "purge" recent block-chain records in an attempt to resolve the issue. The "shc_*.arch" files contain orphan blocks and tx's, and are removed to prevent a block from being re-introduced that could cause the original symptoms to re-appear.

The "XX" below is the current block height reported by "shc block.info" minus about 1000 blocks. The "XX" references the desired height of the block chain. You will need to restart the "shcoind" daemon in order to trigger a new block download from the truncated block height.

Start up the "shcoind" service and run:

_{shc block.info
shc block.purge XX
shc sys.shutdown
<wait for shcoind to stop running>
rm /var/lib/shioncoin/blockchain/shc_*.arch
<start up shcoind service>
shc block.info}

You can generate binary backups, or restore them, using the "shc block.export" and "shc block.import" commands. See the ShareCoin Command Guide for more information.

[shcoins]

ShionCoin version 3.2.2 has been released at https://shcoins.com/download/shioncoin/.

This version is part of the "Iris" phase for 2019.

•    Colored coin alternate block-chains.
•    Offer extended transactions for decentralized coin exchange.
•    Certified Asset extended transaction.
•    Notarized validation transactions.
•    BIP68 (sequence locks) consensus ends.
•    Testnet support for smart-contract "SEXE" executable classes.
•    Testnet segwit consensus period begins.
•    ARM64 (aarch64) compiler support (for raspberry PI).

Recent enhancements also include introducing a console UI (linux only: shc --prompt), numerous BIP compatibility implementations, and final segwit integration.


Some enhancement that will be introduced for ShionCoin in 2020:

The public release of 'SEXE' smart contracts; a lua based scripting platform used to create classes that users can execute and extend. This includes tokens, ticketable events, and, of course, whatever else you can imagine that fits in a block-chain transaction.

Version 2.2 introduced the ability to notorize matrix transactions (which is basically a checksum of past blocks). This concept will be extended further by introducing "BOLO Notorization"; which provides the ability to create notorized transactions on the litecoin block-chain, signed by active ShionCoin participants, which can reference the block where a notorized matrix transaction is stored. A dynamic checkpoint is created in response to the litecoin external notorized transactions which adds a 3rd layer of integrity to the underlying ShionCoin blockchain.

The upcoming "Acacia" phase also introduces the ability to manipulate the underlying block-chain parameters by consensus. This includes being able to change the default 4meg block size currently used by ShionCoin. The concensus is provided as a part of individual transactions. By tagging individual transactions all general users are permitted a vote in changes to the architecture of the block-chain.

The beginning of 2020 also denotes the start of the ShionCoin segwit consensus period. Work has also started on setting up a ShionCoin lightning network based on the c-lightning implementation. Based on when this is completed, a ShionCoin testnet lightning network may be available before the end of the year.

[BusWay18]

still confused..is this new crypto? i download the package what's use for? how to get coin or virtual currency?

[shcoins]

The name has recently changed from "ShareCoin" to "ShionCoin". All references and links related to this thread have been changed to reflect this. Apologies for any confusion this may have caused. The ticker symbol is still "SHC".

You can download the MSI package on windows in order to install the service and access a console window. A new v3.2.3 version is available, and it is recommended to download and install this version if you have a prior version.

On linux, a more sophisticated textual UI client can be used by running "shc --prompt".

A service is started (shcoind) which will act as a node to connect to other ShionCoin servers. You can review services on windows by running "services.msc" at a command-line prompt.

No graphical wallet is currently supplied. A GUI wallet is in development, though. The intention is to supply all features though both shcoins.com and a stand-alone graphical interface. This includes features likes public address aliases, context info, certificates, alt-coins, and smart contracts.

You can currently mine with a scrypt (litecoin) based miner. Access your wallet on shcoins.com for details or point your miner to stratum+tcp://localhost:9448/ if you have installed a local ShionCoin node. Access to your private key information is also available through a shcoins.com wallet account.

An implementation has recently been introduced into the developmental repository which expands the available PoW algorthms beyond Scrypt. This means, soon after 2020, the main-net blockchain will also support mining through the SHA256D, Keccak, X11, Blake2s, Qubit, Groestl, and Skein algorythms.


Here are some basic instructions for cpu-mining ShionCoin on the windows platform:

Download the MSI at shcoins.com and install the service. The service will start running and downloading the blockchain as soon as you have installed the software.

Run the 'ShionCoin Console' program from the start bar. Use "help" to see all commands.

Type "block.info" to see the current state of the block-chain. Once the height stops incrementing continuously you have downloaded the block-chain. You can type "sys.info" to see the last time a block was downloaded.

ShionCoin comes with a built in stratum service. This means you can point your miner directly at the shcoind service in order to mine new coins.

Install "cpuminer" and from a command-line type:
cpuminer -u bank.x -p x -o stratum+tcp://127.0.0.1:9448/ -a scrypt

Type "wallet.list" in order to see the balance of all the local accounts.

[shcoins]

ShionCoin merges traditional bitcoin/litecoin principles with the ability to embed "extended information" into the block-chain.

The extra information is principly included as supplements to individual transactions. ShionCoin utilizes the "nVersion" of a transaction as a bitvector which determines specific strutures of information to append to the transaction. In addition, specializied output scripts are used to prove the integrity of the "extended transaction" information. Otherwise, the core format of both the block and transaction are identical to bitcoin/litecoin.

By embracing traditional principles, while still allowing for extended functionality, a balance is sought between introducing stable new technology while still allowing it to evolve. This concept is, of course, even more important for a decentralized network.

A good example is the base maximum block size and the "param" extended transaction. The maximum is 4 megs with ShionCoin under the belief that the initial 1 meg was insufficient. As a larger, or potentially even smaller, maximum block size is preferred in the future, the "param" extended transaction allows transactions generated to optionally include a vote on how parameters, like the maximum block size, should be set. This allows for a gradual change based on consensus while still supplying a larger than typical initial size.

A lot is put into the emphasis of being able to scale a tradition PoW blockchain. Beyond the max block size mentioned above, the difficulty time-span is based on 60 seconds (similar to litecoin) and transactions fees are low. Support for additional PoW algorthms has been developed which will further reduce the commit block-time of each block. The node uses a set of mapped files to store most all database information in order to provide the speed neccessary to access large amounts of information.

The actual function peformed by each type of extended transaction is fairly varied. The alias extended transaction allows for a pubkey (coin) address to be referenced by a public name. Many are centered are storing different auxilliary forms of data. This ranges from simple name=value context to more complicated chains of certificates and licenses. The more specialized transactions include the "SEXE" programming language and the "colored" alt-chains.

In order to deal with some of the "woes" of being based on a traditional PoW blockchain, multiple layers of additional integrity is woven in. The ShionCoin requires, in certain circumstances, that a "validation matrix" extended transaction be written containing a checksum of past blocks. In addition, a "BOLO" offchain notary system, which allows anyone to participate (as opposed to centralized nodes), has been developed in order to create dynamic checkpoints based on transaction data written to the litecoin blockchain.

The "SEXE" programming language is part of the libshare library, and is based on LUA. The intent is to provide compiled classes which may then be referenced by method calls. This allows for traditional smart contract tokens by allowing for stored persistent (and publically synchronized) scripts to be called, and other custom apps which are published to the block-chain.

The "Colored Alt Chain" extended transaction contains a structure which is similar to a block and set of transactions. It is essentially an "alt-chain" block stored inside a ShionCoin transaction. Each alt-chain is associated with a 128-bit color which identifies it's hierarchial chain. Colors are independant of each other (i.e. has its own genesis block and sub-sequent chain), and are assigned their own custom parameters upon genesis creation. These parameters range from minimum difficulty to reward rate.

Colored alt-chain blocks are meant, although not required, to be accessible to a cpu-miner. In addition, setting the transaction version higher than "1" will allow for a custom-sized payload to be appended to the transaction. This is intended to help accomodate specialized information particular to the color of the chain.

ShionCoin is similar, but different, to several popular coins.

Primarily based on litecoin's own standards, the project seeks to be compatible with new BIP implementations while still allowing custom behaviour. Similar to litecoin, the currency employs a fast block-commit time with reduced transaction fees. New implementations such as segwit and bech32 are considered improvements that should be embraced by the general community.

Similar to syscoin or namecoin, the ShionCoin extended transactions allow for specialized payloads to be attached to transactions. Unlike sys/nmc, the project attempts to find useful specific purposes for this data that can inter-weave with other transactions or affect the coin service itself.

Like etherium, the project seeks to provide useful real-life solutions through the form of custom specialized applications accessible in a public environment. Unlike eth, this projects attempts to concentrate on scaling and compatibility with traditional virtual currency protocols.

And like digicoin, the project attempts to provide flexible software that removes restrictions on accessibility.

[SwiggHeart]

ShionCoin for me is more even better me, wish you had more luck to expect to happen.