UnsafeMath is a Solidity library used to perform unchecked, or “unsafe”, math operations. Prior to version 0.8.0 all math was unchecked meaning that subtracting 1 from 0 would underflow and result in the max uint256 value. This behavior led many contracts to use the OpenZeppelin SafeMath library to performed checked math – using the prior example subtracting 1 from 0 would throw an exception as a uint256 is unsigned and therefore cannot be negative. In Solidity 0.8.0+ all math operations became checked, but at a cost of more gas used per operation.

Unchecked Math Library

The UnsafeMath library allows you to perform unchecked math operations where you are confident the result will not be an underflow or an overflow of the uint256 space – saving gas in your contracts where checked math is not needed.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

// solhint-disable func-name-mixedcase

library UnsafeMath {
    function unsafe_add(uint256 a, uint256 b) internal pure returns (uint256) {
        unchecked {
            return a + b;
        }
    }

    function unsafe_sub(uint256 a, uint256 b) internal pure returns (uint256) {
        unchecked {
            return a - b;
        }
    }

    function unsafe_div(uint256 a, uint256 b) internal pure returns (uint256) {
        unchecked {
            uint256 result;
            // solhint-disable-next-line no-inline-assembly
            assembly {
                result := div(a, b)
            }
            return result;
        }
    }

    function unsafe_mul(uint256 a, uint256 b) internal pure returns (uint256) {
        unchecked {
            return a * b;
        }
    }

    function unsafe_increment(uint256 a) internal pure returns (uint256) {
        unchecked {
            return ++a;
        }
    }

    function unsafe_decrement(uint256 a) internal pure returns (uint256) {
        unchecked {
            return --a;
        }
    }
}

Gas Usage Tests

This test contract uses the UnsafeMath.unsafe_decrement() and Unsafe.unsafe_decrement() functions alongside their checked counterparts to test the difference in gas used between the different methods.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;

import './UnsafeMath.sol';

contract TestUnsafeMath {
    using UnsafeMath for uint256;

    uint256 private _s_foobar;

    function safeDecrement(uint256 count) public {
        for (uint256 i = count; i > 0; --i) {
            _s_foobar = i;
        }
    }

    function safeIncrement(uint256 count) public {
        for (uint256 i = 0; i < count; ++i) {
            _s_foobar = i;
        }
    }

    function unsafeDecrement(uint256 count) public {
        for (uint256 i = count; i > 0; i = i.unsafe_decrement()) {
            _s_foobar = i;
        }
    }

    function unsafeIncrement(uint256 count) public {
        for (uint256 i = 0; i < count; i = i.unsafe_increment()) {
            _s_foobar = i;
        }
    }
}

Using a simple Mocha setup, our tests will call each of the contract functions with an argument for 100 iterations.

import { ethers } from 'hardhat';
import { ContractFactory } from '@ethersproject/contracts';
import { TestUnsafeMath } from '../sdk/types';

describe('UnsafeMath', () => {
  let testUnsafeMathDeploy: ContractFactory, testUnsafeMathContract: TestUnsafeMath;

  beforeEach(async () => {
    testUnsafeMathDeploy = await ethers.getContractFactory('TestUnsafeMath', {});
    testUnsafeMathContract = (await testUnsafeMathDeploy.deploy()) as TestUnsafeMath;
  });

  describe('Gas Used', async () => {
    it('safeDecrement gas used', async () => {
      const tx = await testUnsafeMathContract.safeDecrement(100);
      // const receipt = await tx.wait();
      // console.log(receipt.gasUsed.toString(), 'gasUsed');
    });
    
    it('safeIncrement gas used', async () => {
      const tx = await testUnsafeMathContract.safeIncrement(100);
      // const receipt = await tx.wait();
      // console.log(receipt.gasUsed.toString(), 'gasUsed');
    });
    
    it('unsafeDecrement gas used', async () => {
      const tx = await testUnsafeMathContract.unsafeDecrement(100);
      // const receipt = await tx.wait();
      // console.log(receipt.gasUsed.toString(), 'gasUsed');
    });
    
    it('unsafeIncrement gas used', async () => {
      const tx = await testUnsafeMathContract.unsafeIncrement(100);
      // const receipt = await tx.wait();
      // console.log(receipt.gasUsed.toString(), 'gasUsed');
    });
  });
});

The results show that a checked incrementing loop used 60276 gas, checked decrementing used 59424 gas, unchecked incrementing used 58117 gas, and unchecked decrementing came in at 57473 gas. That’s a savings of 2803 gas on a 100 iteration loop, or 4.55% of the total gas used.

  UnsafeMath
    Gas Used
      ✓ safeDecrement gas used
      ✓ safeIncrement gas used
      ✓ unsafeDecrement gas used
      ✓ unsafeIncrement gas used

·--------------------------------------|---------------------------|----------------|-----------------------------·
|         Solc version: 0.8.15         ·  Optimizer enabled: true  ·  Runs: 999999  ·  Block limit: 30000000 gas  │
·······································|···························|················|······························
|  Methods                                                                                                        │
···················|···················|·············|·············|················|···············|··············
|  Contract        ·  Method           ·  Min        ·  Max        ·  Avg           ·  # calls      ·  usd (avg)  │
···················|···················|·············|·············|················|···············|··············
|  TestUnsafeMath  ·  safeDecrement    ·          -  ·          -  ·         59424  ·            1  ·          -  │
···················|···················|·············|·············|················|···············|··············
|  TestUnsafeMath  ·  safeIncrement    ·          -  ·          -  ·         60276  ·            1  ·          -  │
···················|···················|·············|·············|················|···············|··············
|  TestUnsafeMath  ·  unsafeDecrement  ·          -  ·          -  ·         57473  ·            1  ·          -  │
···················|···················|·············|·············|················|···············|··············
|  TestUnsafeMath  ·  unsafeIncrement  ·          -  ·          -  ·         58117  ·            1  ·          -  │
···················|···················|·············|·············|················|···············|··············
|  Deployments                         ·                                            ·  % of limit   ·             │
·······································|·············|·············|················|···············|··············
|  TestUnsafeMath                      ·          -  ·          -  ·        188806  ·        0.6 %  ·          -  │
·--------------------------------------|-------------|-------------|----------------|---------------|-------------·

  4 passing (2s)

The post UnsafeMath for Solidity 0.8.0+ appeared first on Justin Silver.

These example contracts demonstrate a gas effective way to deploy counterfactual contracts using CREATE2. Using minimal proxy instances that are destroyed between transactions is a secure way to isolate assets in a way that only the key holder can access, Using the token ID of a known NFT contract allows this access to be transferred based on the permissions associated with that NFT.

This is an example of a simple “smart wallet” implementation. In practice allowing it to execute arbitrary calls will mean no other methods are needed, however additional security can be added by implementing explicit calls followed by selfdestruct().

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;

contract Implementation {
    /// @notice A structure to define arbitrary contract calls
    struct Call {
        address to;
        uint256 value;
        bytes data;
    }

    /// @dev reference back to the factory
    address private immutable _owner;

    // called in the factory constructor - when immutable!
    constructor() {
        _owner = msg.sender;
    }

    // only the factory can call functions on the instance
    modifier onlyFactory() {
        require(_owner == msg.sender, 'factory only');
        _;
    }

    /// @dev make call without a return value
    function doSomething() external payable onlyFactory {
        // make a call without a return value, maybe payable
        // ...then selfdestruct the contract
        selfdestruct(payable(address(0)));
    }

    /// @notice Executes calls on behalf of this instance.
    /// @param calls The array of calls to be executed.
    /// @return An array of the return values for each of the calls
    function executeCalls(Call[] calldata calls) external onlyFactory returns (bytes[] memory) {
        // handle the calls
        bytes[] memory results = new bytes[](calls.length);
        for (uint256 i = 0; i < calls.length; i++) {
            // solhint-disable-next-line avoid-low-level-calls
            (bool success, bytes memory result) = calls[i].to.call{value: calls[i].value}(calls[i].data);
            require(success, string(result));
            results[i] = result;
        }

        // NOTE: cleanup() must be called from the factory!
        return results;
    }

    /// @notice Destroys this contract
    function cleanup() external onlyFactory {
        // remove the bytecode - mayble handle balances on the factory?
        selfdestruct(payable(address(0)));
    }
}

This factory contract will create new minimal proxy instances using the token ID as the salt. Only the token owner is allowed to call the function to create the contract, so any assets in the contracts storage location will be safe between calls.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;

import '@openzeppelin/contracts/interfaces/IERC721Enumerable.sol';
import '@openzeppelin/contracts/proxy/Clones.sol';
import './Implementation.sol';

contract Create2Factory {
    /// @dev the nft used to calculate the address
    IERC721Enumerable private _token;

    /// @dev the address of the implementation for the minimal proxy
    address private _implementation;

    /// @dev constructor
    constructor(address nft) {
        // nft contract used as key
        _token = IERC721Enumerable(nft); // pass into constructor, etc.
        // smart wallet implementation for minimal proxy
        _implementation = address(new Implementation());
    }

    /// @notice get the address of the instance for the given tokenId
    /// @param tokenId the tokenId
    /// @return the address of the instance
    function getAddressForTokenId(uint256 tokenId) external view returns (address) {
        return Clones.predictDeterministicAddress(_implementation, _salt(tokenId));
    }

    /// @notice some call without a callback
    /// @param tokenId the tokenId
    function doSomething(uint256 tokenId) external payable {
        // get a minimal proxy instance of the implementation
        Implementation instance = _createInstance(tokenId);
        // will auto destruct
        instance.doSomething{value: msg.value}();
    }

    /// @notice Allows the owner of an ERC721 to execute arbitrary calls on behalf of the associated wallet.
    /// @dev The wallet will be counterfactually created, calls executed, then the contract destroyed.
    /// @param tokenId The token ID
    /// @param calls The array of call structs that define that target, amount of ether, and data.
    /// @return The array of call return values.
    function executeCalls(uint256 tokenId, Implementation.Call[] calldata calls) external returns (bytes[] memory) {
        Implementation instance = _createInstance(tokenId);
        bytes[] memory result = instance.executeCalls(calls);
        // manuall cleanup
        instance.cleanup();
        return result;
    }

    /// @dev Computes the CREATE2 salt for the given token.
    /// @param tokenId The token ID
    /// @return salt bytes32 value that is unique to that token.
    function _salt(uint256 tokenId) private pure returns (bytes32 salt) {
        return keccak256(abi.encodePacked(tokenId));
    }

    /// @dev Creates a Implementation for the given token id.
    /// @param tokenId The token ID
    /// @return The address of the newly created Implementation.
    function _createInstance(uint256 tokenId) private returns (Implementation) {
        require(msg.sender == _token.ownerOf(tokenId), 'not owner');
        // get the create2 clone address
        address payable _address = payable(Clones.cloneDeterministic(_implementation, _salt(tokenId)));
        // get a minimal proxy instance of the locker
        Implementation instance = Implementation(_address);
        // return the clone instance
        return instance;
    }
}

The post NFT Keyed Ephemeral Counterfactual Minimal Proxy Contracts appeared first on Justin Silver.

The perceived value of many NFTs is based on that item’s rarity making it ideal to mint them fairly. Rarity snipers and bad actors on a team can scoop up rare items from a collection in an attempt to further profit on the secondary market. How can you both fairly distribute the tokens – both to the community and the project team?

One solution is to hide the metadata until after reveal and mint the token IDs out of order – either using a provable random number, a pseudo random number, as pseudo random number seeded with a provable random beacon, or other options depend on your security needs. For provable random numbers check out Provable Randomness with VDF.

How It Works

uint16[100] public ids;
uint16 private index;

function _pickRandomUniqueId(uint256 random) private returns (uint256 id) {
    uint256 len = ids.length - index++;
    require(len > 0, 'no ids left');
    uint256 randomIndex = random % len;
    id = ids[randomIndex] != 0 ? ids[randomIndex] : randomIndex;
    ids[randomIndex] = uint16(ids[len - 1] == 0 ? len - 1 : ids[len - 1]);
    ids[len - 1] = 0;
}

We can efficiently track which IDs have – and have not – been minted by starting with an empty and cheap to create array of empty values with a size that matches your total supply. The array size could suffice in lieu of tracking the index, but this is more gas efficient than pop()ing the array. For each round it will select a random index, bounded by the remaining supply – we will call this a “roll” as in “roll of the dice” except we will reduce the number of sides by one for each round.

Round 0

When we start the Data array will match the supply we want to create (five) and be empty (all zeroes), as well our Results, which are just empty (this represents the token ids that would be minted).

Index:    0  1  2  3  4  5
--------------------------
Data:    [0, 0, 0, 0, 0, 0] 
Results: []

Round 1: 3

For the first round, let’s say it’s a 3. We look at the third index, check to see if it is 0, and if is we return the index – this will make more sense in a moment. Next we look at the last position in the array given our remaining supply and if it is a 0 we move that index to the 3 position we rolled.

Index:    0  1  2 *3* 4  5
---------------------------
Data:    [0, 0, 0, 0, 0, 0] 
Results: []

<< before
after >>

Data:    [0, 0, 0, 5, 0] 
Results: [3]

Round 2: 3

In the previous step when we check an index for a value, if a value was set a that index we would use it rather than the index. To demonstrate this, let’s assume we rolled a 3 again. This time we look at this third position and it contains a 5, so we return that instead of a three. This is great, because we already selected a 3 and we want these to be unique. Again we look at the last position, and since it is not set we set the index 4 as the value of index 3.

Index:    0  1  2 *3* 4  5
---------------------------
Data:    [0, 0, 0, 5, 0] 
Results: [3]

<< before
after >>

Data:    [0, 0, 0, 4] 
Results: [3, 5]

Round 3: 2

Next, we roll a 2 again. We look at position 2, it’s not set, so we return a 2, again a number we haven’t selected previously. Next we check the last position which now as a 4 set, so it is moved into index 2 as we have yet to select it.

Index:    0  1 *2* 3  4  5
---------------------------
Data:    [0, 0, 0, 4] 
Results: [3, 5]

<< before
after >>

Data:    [0, 0, 4] 
Results: [3, 5, 2]

Round 4: 1

We roll a 1, and since the first index contains a 4 we move that to our results.

Index:    0 *1* 2  3  4  5
---------------------------
Data:    [0, 0, 4] 
Results: [3, 5, 2]

<< before
after >>

Data:    [0, 4] 
Results: [3, 5, 2, 1]

Round 5: 1

We roll a 1 again. This time we return the 4, but since there is nothing to move into its place, we move on.

Index:    0 *1* 2  3  4  5
---------------------------
Data:    [0, 4] 
Results: [3, 5, 2, 1]

<< before
after >>

Data:    [0] 
Results: [3, 5, 2, 1, 4]

Round 6: 0

Lastly, we get a 0, since that’s all that remains. It both contains a 0 and is in that position so we select a 0.

Index:   *0* 1  2  3  4  5
---------------------------
Data:    [0] 
Results: [3, 5, 2, 1, 4]

<< before
after >>

Data:    [] 
Results: [3, 5, 2, 1, 4, 0]

TLDR;

Each index of the array tracks an unminted ID. If the position isn’t set, that ID hasn’t been minted. If it is set, it’s because the last position was moved to it when the available indexes shrank and the last index wasn’t the one selected so we want to preserve it. If you want to start minting at 1, add 1.

Pseudo Random

Uses a pseudo random number to select from a unique set of token IDs.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;

import '@openzeppelin/contracts/token/ERC721/ERC721.sol';

contract RandomTokenIdv1 is ERC721  {

    uint16[100] public ids;
    uint16 private index;

    constructor() ERC721('RandomIdv1', 'RNDMv1') {}

    function mint(address[] calldata _to) external {
        for (uint256 i = 0; i < _to.length; i++) {
            uint256 _random = uint256(keccak256(abi.encodePacked(index++, msg.sender, block.timestamp, blockhash(block.number-1))));
            _safeMint(_to[i], _pickRandomUniqueId(random));
        }
    }

    function _pickRandomUniqueId(uint256 random) private returns (uint256 id) {
        uint256 len = ids.length - index++;
        require(len > 0, 'no ids left');
        uint256 randomIndex = random % len;
        id = ids[randomIndex] != 0 ? ids[randomIndex] : randomIndex;
        ids[randomIndex] = uint16(ids[len - 1] == 0 ? len - 1 : ids[len - 1]);
        ids[len - 1] = 0;
    }

}

Provable Random

Uses a provable random number and derivatives to select from a unique set of token IDs.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;

import '@openzeppelin/contracts/token/ERC721/ERC721.sol';
import './libraries/Randomness.sol';
import './libraries/SlothVDF.sol';

contract RandomTokenIdv2 is ERC721  {

    using Randomness for Randomness.RNG;
    
    Randomness.RNG private _rng;

    mapping(address => uint256) public seeds;
    uint256 public prime = 432211379112113246928842014508850435796007;
    uint256 public iterations = 1000;

    uint16[100] public ids;
    uint16 private index;

    constructor() ERC721('RandomIdv2', 'RNDMv2') {}

    function createSeed() external payable {
        seeds[msg.sender] = _rng.getRandom();
    }

    function mint(address[] calldata _to, uint256 proof) external {
        require(SlothVDF.verify(proof, seeds[msg.sender], prime, iterations), 'Invalid proof');

        uint256 _randomness = proof;
        uint256 _random;
        for (uint256 i = 0; i < _to.length; i++) {
            (_randomness, _random) = _rng.getRandom(_randomness);
            _safeMint(_to[i], _pickRandomUniqueId(_random));
        }
    }

    function _pickRandomUniqueId(uint256 random) private returns (uint256 id) {
        uint256 len = ids.length - index++;
        require(len > 0, 'no ids left');
        uint256 randomIndex = random % len;
        id = ids[randomIndex] != 0 ? ids[randomIndex] : randomIndex;
        ids[randomIndex] = uint16(ids[len - 1] == 0 ? len - 1 : ids[len - 1]);
        ids[len - 1] = 0;
    }

}

Random Beacon

Uses a provable random number as a beacon which is used as the seed for a pseudo random number and derivatives to select from a unique set of token IDs.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
 
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/token/ERC721/ERC721.sol';
import './libraries/Randomness.sol';
import './libraries/SlothVDF.sol';
 
contract RandomTokenIdv3 is ERC721, Ownable  {

    using Randomness for Randomness.RNG;
     
    Randomness.RNG private _rng;

    uint16[100] public ids;
    uint16 private index;
 
    uint256 public prime = 432211379112113246928842014508850435796007;
    uint256 public iterations = 1000;
    uint256 public seed;
    uint256 public beacon;
 
    constructor() ERC721('RandomTokenIdv3', 'RNDMv3') {}
 
    // create a set - use something interesting for the input.
    function createSeed() external onlyOwner {
        (uint256, uint256 _random) = _rng.getRandom();
        seed = _random;
    }
 
    // once calclated set the beacon
    function setBeacon(uint256 proof) external {
        require(SlothVDF.verify(proof, seeds[msg.sender], prime, iterations), 'Invalid proof');
        beacon = proof;
    }

    function mint(address[] calldata _to) external {
        require(beacon > 0, 'Beacon not set');
        uint256 _randomness = beacon;
        uint256 _random;
        for (uint256 i = 0; i < _to.length; i++) {
            (_randomness, _random) = _rng.getRandom(_randomness);
            _safeMint(_to[i], _pickRandomUniqueId(_random));
        }
    }
 
    function _pickRandomUniqueId(uint256 random) private returns (uint256 id) {
        uint256 len = ids.length - index++;
        require(len > 0, 'no ids left');
        uint256 randomIndex = random % len;
        id = ids[randomIndex] != 0 ? ids[randomIndex] : randomIndex;
        ids[randomIndex] = uint16(ids[len - 1] == 0 ? len - 1 : ids[len - 1]);
        ids[len - 1] = 0;
    }
 
}

The post NFT – Mint Random Token ID appeared first on Justin Silver.

A Verifiable Delay Function (VDF) is a linearly computed function that takes a relatively long time to calculate, however the resulting proof can be verified to be the result of this computation in a much shorter period of time. Since the computation can’t be sped up through parallelization or other tricks we can be sure that for a given seed the resulting value can’t be known ahead of time – thus making it a provable random number.

We can apply this to a blockchain to achieve provable randomness without an oracle by having the client compute the VDF. This process takes two transactions – the first to commit to the process and generate a seed for the VDF input, and the second to submit the calculated proof. If the length of time to calculate the VDF proof exceeds the block finality for the chain you are using, then the result of the second transaction can’t be known when the seed is generated and can thus be used as a provable random number. For more secure applications you can use multiple threads to calculate multiple VDF proofs concurrently, or for less strict requirements you can bitshift the value to get “new” random numbers.

Provable Random Numbers

The good stuff first – provable random numbers without an oracle. The user first makes a request to createSeed() typically with a commitment such as payment. This seed value along with the large prime and number of iterations are used to calculate the VDF proof – the larger the prime and the higher the iterations, the longer the proof takes to calculate and can be adjusted as needed. As long as the number of iterations takes longer to compute than the block finality we know it’s random since it’s not possible to know the result before it’s too late to change it. A blockchain like Fantom is ideal for this application with block times of ~1 second and finality after one block – validators cannot reorder blocks once the are minted.

This proof is then passed in to the prove() function. It uses the previously created seed – which now can’t be changed – and other inputs to verify the proof. If it passes, the value can be used as a random number, or can be passed into another function (as below) to create multiple random numbers by shifting the bits on each request for a random(ish) number.

Smart Contract

You can find large primes for your needs using https://bigprimes.org/, potentially even rotating them. Note that the code below is an example and should not be used directly without modifying for your needs.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;

import './libraries/SlothVDF.sol';

contract RandomVDFv1  {
    
    // large prime
    uint256 public prime = 432211379112113246928842014508850435796007;
    // adjust for block finality
    uint256 public iterations = 1000;
    // increment nonce to increase entropy
    uint256 private nonce;
    // address -> vdf seed
    mapping(address => uint256) public seeds;

    function createSeed() external payable {
        // commit funds/tokens/etc here
        // create a pseudo random seed as the input
        seeds[msg.sender] = uint256(keccak256(abi.encodePacked(msg.sender, nonce++, block.timestamp, blockhash(block.number - 1))));
    }

    function prove(uint256 proof) external {
        // see if the proof is valid for the seed associated with the address
        require(SlothVDF.verify(proof, seeds[msg.sender], prime, iterations), 'Invalid proof');

        // use the proof as a provable random number
        uint256 _random = proof;
    }
}

Hardhat Example

This code is an example Hardhat script for calling the RandomVDFv1 contract. It shows the delay to calculate a proof and attempts to submit it. In a real implementation this could be an NFT mint, etc.

import { ethers, deployments } from 'hardhat';
import { RandomVDFv1 } from '../sdk/types';
import sloth from './slothVDF';

async function main() {
  // We get the signer
  const [signer] = await ethers.getSigners();

  // get the contracts
  const deploy = await deployments.get('RandomVDFv1');
  const token = (await ethers.getContractAt('RandomVDFv1', deploy.address, signer)) as RandomVDFv1;

  // the prime and iterations from the contract
  const prime = BigInt((await token.prime()).toString());
  const iterations = BigInt((await token.iterations()).toNumber());
  console.log('prime', prime.toString());
  console.log('iterations', iterations.toString());

  // create a new seed
  const tx = await token.createSeed();
  await tx.wait();

  // get the seed
  const seed = BigInt((await token.seeds(signer.address)).toString());
  console.log('seed', seed.toString());

  // compute the proof
  const start = Date.now();
  const proof = sloth.computeBeacon(seed, prime, iterations);
  console.log('compute time', Date.now() - start, 'ms', 'vdf proof', proof);

  // this could be a mint function, etc
  const proofTx = await token.prove(proof);
  await proofTx.wait();
}

main().catch((error) => {
  console.error(error);
  process.exit(1);
});

Sloth Verifiable Delay

This off-chain implementation of Sloth VDF in Typescript will let us compute the proof on the client.

const bexmod = (base: bigint, exponent: bigint, modulus: bigint) => {
  let result = 1n;
  for (; exponent > 0n; exponent >>= 1n) {
    if (exponent & 1n) {
      result = (result * base) % modulus;
    }
    base = (base * base) % modulus;
  }
  return result;
};

const sloth = {
  compute(seed: bigint, prime: bigint, iterations: bigint) {
    const exponent = (prime + 1n) >> 2n;
    let beacon = seed % prime;
    for (let i = 0n; i < iterations; ++i) {
      beacon = bexmod(beacon, exponent, prime);
    }
    return beacon;
  },
  verify(beacon: bigint, seed: bigint, prime: bigint, iterations: bigint) {
    for (let i = 0n; i < iterations; ++i) {
      beacon = (beacon * beacon) % prime;
    }
    seed %= prime;
    if (seed == beacon) return true;
    if (prime - seed === beacon) return true;
    return false;
  },
};

export default sloth;

Next we need to be able to verify the Sloth VDF proof on chain which is easy using the following library.

// SPDX-License-Identifier: MIT
// https://eprint.iacr.org/2015/366.pdf

pragma solidity ^0.8.11;

library SlothVDF {

    /// @dev pow(base, exponent, modulus)
    /// @param base base
    /// @param exponent exponent
    /// @param modulus modulus
    function bexmod(
        uint256 base,
        uint256 exponent,
        uint256 modulus
    ) internal pure returns (uint256) {
        uint256 _result = 1;
        uint256 _base = base;
        for (; exponent > 0; exponent >>= 1) {
            if (exponent & 1 == 1) {
                _result = mulmod(_result, _base, modulus);
            }

            _base = mulmod(_base, _base, modulus);
        }
        return _result;
    }

    /// @dev compute sloth starting from seed, over prime, for iterations
    /// @param _seed seed
    /// @param _prime prime
    /// @param _iterations number of iterations
    /// @return sloth result
    function compute(
        uint256 _seed,
        uint256 _prime,
        uint256 _iterations
    ) internal pure returns (uint256) {
        uint256 _exponent = (_prime + 1) >> 2;
        _seed %= _prime;
        for (uint256 i; i < _iterations; ++i) {
            _seed = bexmod(_seed, _exponent, _prime);
        }
        return _seed;
    }
    
    /// @dev verify sloth result proof, starting from seed, over prime, for iterations
    /// @param _proof result
    /// @param _seed seed
    /// @param _prime prime
    /// @param _iterations number of iterations
    /// @return true if y is a quadratic residue modulo p
    function verify(
        uint256 _proof,
        uint256 _seed,
        uint256 _prime,
        uint256 _iterations
    ) internal pure returns (bool) {
        for (uint256 i; i < _iterations; ++i) {
            _proof = mulmod(_proof, _proof, _prime);
        }
        _seed %= _prime;
        if (_seed == _proof) return true;
        if (_prime - _seed == _proof) return true;
        return false;
    }
}

Randomness Library

Instead of using the proof directly as a single random number we can use it as the input to a random number generator for multiple provable random numbers. If we want to save a bit more gas instead of calling for a new number every time we can just shift the bits of the random number to the right and refill it when it empties. This pattern is more efficient if implemented directly your contract, but this library can be reused if you can support the relaxed security.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;

library Randomness {

    // memory struct for rand
    struct RNG {
        uint256 seed;
        uint256 nonce;
    }

    /// @dev get a random number
    function getRandom(RNG storage _rng) external returns (uint256 randomness, uint256 random) {
        return _getRandom(_rng, 0, 2**256 - 1, _rng.seed);
    }

    /// @dev get a random number
    function getRandom(RNG storage _rng, uint256 _randomness) external returns (uint256 randomness, uint256 random) {
        return _getRandom(_rng, _randomness, 2**256 - 1, _rng.seed);
    }

    /// @dev get a random number passing in a custom seed
    function getRandom(
        RNG storage _rng,
        uint256 _randomness,
        uint256 _seed
    ) external returns (uint256 randomness, uint256 random) {
        return _getRandom(_rng, _randomness, 2**256 - 1, _seed);
    }

    /// @dev get a random number in range (0, _max)
    function getRandomRange(
        RNG storage _rng,
        uint256 _max
    ) external returns (uint256 randomness, uint256 random) {
        return _getRandom(_rng, 0, _max, _rng.seed);
    }

    /// @dev get a random number in range (0, _max)
    function getRandomRange(
        RNG storage _rng,
        uint256 _randomness,
        uint256 _max
    ) external returns (uint256 randomness, uint256 random) {
        return _getRandom(_rng, _randomness, _max, _rng.seed);
    }

    /// @dev get a random number in range (0, _max) passing in a custom seed
    function getRandomRange(
        RNG storage _rng,
        uint256 _randomness,
        uint256 _max,
        uint256 _seed
    ) external returns (uint256 randomness, uint256 random) {
        return _getRandom(_rng, _randomness, _max, _seed);
    }

    /// @dev fullfill a random number request for the given inputs, incrementing the nonce, and returning the random number
    function _getRandom(
        RNG storage _rng,
        uint256 _randomness,
        uint256 _max,
        uint256 _seed
    ) internal returns (uint256 randomness, uint256 random) {
        // if the randomness is zero, we need to fill it
        if (_randomness <= 0) {
            // increment the nonce in case we roll over
            _randomness = uint256(
                keccak256(
                    abi.encodePacked(_seed, _rng.nonce++, block.timestamp, msg.sender, blockhash(block.number - 1))
                )
            );
        }
        // mod to the requested range
        random = _randomness % _max;
        // shift bits to the right to get a new random number
        randomness = _randomness >>= 4;
    }
}

This example uses the Randomness library to generate multiple random numbers from a single proof in an efficient way. Note that this is a less secure application, though still valid for many use cases.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;

import './libraries/Randomness.sol';
import './libraries/SlothVDF.sol';

contract RandomVDFv2  {

    using Randomness for Randomness.RNG;

    Randomness.RNG private _rng;
    
    // large prime
    uint256 public prime = 432211379112113246928842014508850435796007;
    // adjust for block finality
    uint256 public iterations = 1000;
    // increment nonce to increase entropy
    uint256 private nonce;
    // address -> vdf seed
    mapping(address => uint256) public seeds;

    // commit funds/tokens/etc here
    function createSeed() external payable {
        // create a pseudo random seed as the input
        seeds[msg.sender] = Randomness.RNG(0, nonce++).getRandom();
    }

    function prove(uint256 proof) external {
        // see if the proof is valid for the seed associated with the address
        require(SlothVDF.verify(proof, seeds[msg.sender], prime, iterations), 'Invalid proof');
        
        uint256 _randomness;
        uint256 _random;
        
        (_randomness, _random) = _rng.getRandom(_randomness, proof);
        (_randomness, _random) = _rng.getRandom(_randomness, proof);
        (_randomness, _random) = _rng.getRandom(_randomness, proof);
    }
}

The post Provable Randomness with VDF appeared first on Justin Silver.

Create an Alpine Linux image to run the lachesis node for the Fantom cryptocurrency.

FROM alpine:latest as build-stage

ARG LACHESIS_VERSION=release/1.0.0-rc.0

ENV GOROOT=/usr/lib/go 
ENV GOPATH=/go 
ENV PATH=$GOROOT/bin:$GOPATH/bin:/build:$PATH

RUN set -xe; \
  apk add --no-cache --virtual .build-deps \
  # get the build dependencies for go
  git make musl-dev go linux-headers; \
  # install fantom lachesis from github
  mkdir -p ${GOPATH}; cd ${GOPATH}; \
  git clone --single-branch --branch ${LACHESIS_VERSION} https://github.com/Fantom-foundation/go-lachesis.git; \
  cd go-lachesis; \
  make build -j$(nproc); \
  mv build/lachesis /usr/local/bin; \
  rm -rf /go; \
  # remove our build dependencies
  apk del .build-deps; 

FROM alpine:latest as lachesis

# copy the binary 
COPY --from=build-stage /usr/local/bin/lachesis /usr/local/bin/lachesis

COPY run.sh /usr/local/bin

WORKDIR /root

ENV LACHESIS_PORT=5050
ENV LACHESIS_HTTP=18545
ENV LACHESIS_API=eth,ftm,debug,admin,web3,personal,net,txpool
ENV LACHESIS_VERBOSITY=2

EXPOSE ${LACHESIS_PORT}
EXPOSE ${LACHESIS_HTTP}

VOLUME [ "/root/.lachesis" ]

CMD ["run.sh"]

The run.sh just starts the nodes with the ports you set in the environment.

#!/usr/bin/env sh

set -xe

lachesis \
  --port ${LACHESIS_PORT} \
  --http \
  --http.addr "0.0.0.0" \
  --http.port ${LACHESIS_HTTP} \
  --http.api "${LACHESIS_API}" \
  --nousb \
  --verbosity ${LACHESIS_VERBOSITY}

Use docker-compose to define the TCP/UDP ports to expose as well as a data volume to persist the blockchain data.

version: '3.4'

services:
  lachesis:
    image: doublesharp/fantom-lachesis:latest
    restart: always
    ports:
      - '5050:5050'
      - '5050:5050/udp'
      - '18545:18545'
    volumes:
      - lachesis:/root/.lachesis
    environment:
      LACHESIS_VERBOSITY: 2

volumes:
  lachesis: {}

The post Fantom Lachesis Full Node RPC appeared first on Justin Silver.

danosphere [3:03 PM]

joined #dantime.

danosphere [3:03 PM]

set the channel purpose: Friday AMAs!

vileda [3:04 PM]

joined #dantime along with jay.c.

vileda [3:04 PM]

1st to join, yay.

johnp [3:04 PM]

joined #dantime.

vileda [3:04 PM]

How’s things this week Dan?

Tynaghtina [3:05 PM]

joined #dantime along with 3 others.

danosphere [3:06 PM]

Things are going, there are some exciting POCs about to start getting developed by the team hackathon-style but we’re still mapping out which concepts we wanna flesh out we’re going to be at a pretty large trade show in November and we want to be able to demonstrate not only BMD and a [cant mention til we PR is to SEDAR] product we have in addition to nascent products in 2-3 other verticals docusign being one of them, the other 2 we still have a constellation of ideas we’re trying to refine down before deciding

Zontar [3:07 PM]

joined #dantime.

danosphere [3:07 PM]

web marketplaces aren’t out of the question as being one of those POCs, but further focused development on any one of those POCs is tied into customer interest thesw would be quick and dirty web experience that are full functional in respect to their interaction with the Syscoin protocol and the direct value they would provide to customers in diff industries
and im super proud of the BMD 3.1 release, dev team has done a knockout job of improving that at a rapid pace and BMD 3.2 is even better :sunglasses:

ced [3:09 PM]

joined #dantime along with 3 others.

vileda [3:10 PM]

Would be nice for http://www.blockchainfoundry.co/products to point to 3.1 rather than 3.0 (edited)
blockchainfoundry.co
Blockchain Foundry
https://res.cloudinary.com/hrscywv4p/image/upload/climit,fl_lossy,h_630,w_1200,f_auto,q_auto/v1/404267/Transparent_500pxl3bydz.png

beardedmage [3:10 PM]

have you guys spoken about OSing the indexer stuff?

alternating [3:10 PM]

joined #dantime.

danosphere [3:10 PM]

we have an entirely new and improved website launching in the next week or two, i wanna see it up by Friday but it might take an extra day or two to migrate it from the staging servers
@beardedmage we are actively evaluating that system for an IP, securing that IP if there is any, and then planning to open source it so stay tuned!

sidhujag [3:11 PM]

joined #dantime.

beardedmage [3:11 PM]

oh excellent, thanks

beardedmage [3:11 PM]

i need it

johnp [3:11 PM]

What is the latest on the Foundation (edited)

danosphere [3:12 PM]

so on the foundation front we have our group of board members but there are liability concerns for them at a personal level that we need to be cognizant of initially we were going to do this as a Canadian foundation, but we would have to pay for D&O insurance to cover people and that is >100k/yr to do, and has to be renewed every year

mca [3:13 PM]

joined #dantime.

danosphere [3:13 PM]

so we are looking at the liability+cost structures of basing the foundation in a different country at this point and we’re still working through the options there but there DO seem to be some feasible paths for us in that respect, just have to talk to more lawyers and accountants to confirm

kicken55 [3:13 PM]

joined #dantime.

Tynaghtina [3:13 PM]

dan how would you describe syscoin and BM to the crypto ignorant out there aka 99%of my friend and colleagues

danosphere [3:14 PM]

Syscoin is a protocol that makes it easier to build Dapps that are fast and scale because its DApp features are accessible to standard web devs, no new languages need to be learned

shrill [3:14 PM]

joined #dantime.

danosphere [3:14 PM]

for non-techies, I would say Syscoin is a platform that is capable of many things- BM is a demonstration of these capabilities ranging from identity, to certification, marketplaces, assets, and more and what that does is allows for removing middlemen in a number of different industries in respect to those features, and all in a transparent and proveable way

sebastien1234 [3:15 PM]

joined #dantime.

danosphere [3:16 PM]

this allows those savings to be passed on to users- be it for cutting out middlemen around digital rights management, identity data silos, or controlling what you can or can’t sell across borders and p2p and through features like escrow you get security in those activities, arbitrated through a mutually trusted party. further more things like ZDAG make SYS particularly suited for POS applications, something many protocols fall down on so when looking at Syscoin in the context of ‘how will this provide real world value or be used by everyday people’ its already got many of the key features in needs at a core level to deliver that value- now its all about enabling experiences that help to demonstrate that more tangibly for everyday users who either dont wanna download a big honking app and wait for it to sync or who don’t understand how to search things from a QT level. We’re pragmatic. We understand that today’s consumers want something easy that they can touch and feel with instant gratification

Gorm [3:20 PM]

joined #dantime.

Tynaghtina [3:20 PM]

nicely put thanks, I know we are in the middle of new and exciting things, once everything is stable is there a rough idea how often the basic user would need to update their wallets

saxscrapers [3:21 PM]

joined #dantime.

sidhujag [3:21 PM]

in what way?

danosphere [3:21 PM]

@Tynaghtina our goal is to make it so that a normal user almost never has to think about that

syshodlor [3:21 PM]

joined #dantime along with jvdv.

Tynaghtina [3:21 PM]

just to make sure they remain on the correct chain and things like that Jag

danosphere [3:21 PM]

we want to enable ‘walletless’ interfaces like Pangolin, a mobile version, and a pure web version that only require a users to enter their credentials to interact w new features and protocol versions

cradox [3:21 PM]

joined #dantime.

danosphere [3:22 PM]

we will run servers that WE upgrade to the new version, the aformentioned interfaces simply connect to them, no downloading or chain confusion for normal users

johnp [3:22 PM]

If you wish to stay behave @syshodlor

Tynaghtina [3:22 PM]

nice

J [3:22 PM]

joined #dantime.

danosphere [3:22 PM]

similar to what some of the ppl I have been watching chat in #community-dev are doing but specifically run by us, to enable the ease-of-use I was mentioning around those other things we’ll be building

bstr156 [3:22 PM]

joined #dantime.

sidhujag [3:23 PM]

yes its a good fit because in general other coins dont have this luxury as people will shout it avoids more full nodes from running but in our case we are incentivizing full nodes through masternodes as well

mac1 [3:23 PM]

joined #dantime.

danosphere [3:23 PM]

new version of sys out? no impact to user. They still go to coolguy.syscoin.org, login w a username and pass that decrypts a locally-encrypted version of their private key, and voila they get all the new goodness with none of the pain or overhead that accompanies Syscoin upgrades today its painless for them because we upgrade our servers the right way and then they just get the benefits of the updates

J [3:24 PM]

@danosphere who is the best singer out of you, Jag, and Schepis? Related, is that person available for ballads on commission? Asking for a friend.

Tynaghtina [3:24 PM]

@danosphere that is the dream

danosphere [3:24 PM]

Oh you know its @lonestar108 hahah
he has incredible rap skills

Tynaghtina [3:24 PM]

thank you for the detailed answers

danosphere [3:24 PM]

@Tynaghtina we are not far off that dream my friend and ideally a web portal would also allow for queried-interactions too so you go to coolguy.syscoin.org?buy&offer=12345AAA&qty=1

zippyjetman [3:25 PM]

joined #dantime.

danosphere [3:25 PM]

and you get immediately put to a purchase screen where you just confirm the purchase using your local key and then from there you get reverted back to the original site w a callback so the site can show you a receipt and such, similiar to paypal flows
same goes for mobile

syshodlor [3:26 PM]

@danosphere out of the things the team is working on, what are you most excited about in the next months to come?

q [3:27 PM]

joined #dantime.

danosphere [3:27 PM]

the things we are doing to enable web-based blockchain products to be used in an easy and seamless way
Pangolin is one of these, but there are other ideas cooking internally too that I don’t want to oversteer on but I think they are good ideas, and may be easier to use for certain ppl than an extension but we are still debating the merits of various approaches- the key there is what theat solution enables and i like what im seeing in #community-dev , we are getting some good ideas to kick around ourselves from the increased activity there #mobilethings and i can understand how indexer-stuff we’ve built would help the community build more things faster, and we want to enable that

blocknugget [3:29 PM]

joined #dantime.

beardedmage [3:29 PM]

i think a mobile signing thing would be better in the short term, as long as it can also handle mobile to mobile requests
buts its awesome to hear that indexer stuff is on the path to be community-useable without rewriting
i was griping about that

superdave [3:30 PM]

joined #dantime.

syshodlor [3:30 PM]

@danosphere I think a lot of people were pretty hyped for BM Web. Is that still on track for the roadmap or have priorities shifted?

danosphere [3:31 PM]

the near term priority has always been building a way for people to interact with a BMW without a way to authenticate into these types of applications in a secure way BMW is literally worthless and that continues to be the plan today- build solutions that will enable low-friction interaction with WEB based blockchain products BMW is a web based blockchain product
once we have those tools in place BMW or a host of other applications could be built, it really depends on what the landscape looks like when that stuff is ready if people beat us to a web marketplace on SYS we might help enhance that or look to acquire it, rather than reinvent the wheel but we need to have solutions that even make that kind of product feasible for people to use first

James [3:33 PM]

joined #dantime along with 2 others.

beardedmage [3:34 PM]

i like the sound of augmenting or acquiring competitors that beat you to market on the web marketplace side (if they beat you) is there a plan to enable native SYS offers to be paid in assets? I asked this in #general but the answer was convoluted
i think @sidhujag said that escrow on the protocol can control an asset but there was something about also using assetallocation send which isn’t part of normal escrow flows and so im still here :confused:

danosphere [3:37 PM]

That is something that I agree we need to enable as it greatly enhances the value and use of SYS assets themselves, im not sure how far off we are on that, not very far i think because that is a major use case for CPS as well they want to run a marketplace that utilizes solely CPS, and assets have ZDAG so there are a lot of good reasons to tie assets directly into the offer/escrow services rather than being tangentially tied to them

blgh [3:38 PM]

Thanks for being here tonight Dan :)! Can you tell us a bit more about the progress on the partnerships with AiBB, Peer Mountain?

Shahn [3:39 PM]

joined #dantime.

danosphere [3:40 PM]

So we still plan on leveraging peer mountain for all our KYC needs and we’re still working to understand the api/protocol of their system but even in Pangolin we have ideas around KYC identities so that KYC can be tied into anything that alias signs
from authenticated buyers/sellers on a marketplace to verified identities behind supply chains actors

sidhujag [3:40 PM]

beardedimage you are right.. but assets controlled by addresses will let you do this today.. the flow around it changes but the protocol lets you do it today

danosphere [3:41 PM]

but we haven’t focused on that in depth with them yet, and the press release they put out this week (which i havent read, because i had no idea they were publishing anything) may have been premature we need to get the base authentication applications working before we get into the weeds of how we enable optional KYC around identities created and managed through those solutions but all of this is tied into our long term thinking around how this stuff is useful and used in the real world an alias is great, an alias w MSFT DID based specification behind it using offchain data is even better, and all that + optional KYC is the best then if you sign in to places like Binance, Polo, etc that require KYC you don’t have to repeat the process for each site- that’s the idea you have a blockchain based, KYC’d identity to reference and partners we’re working with hold and provide those documents as needed, reducing repetition and increasing teh value to ppl who use the system

beardedmage [3:43 PM]

thanks @sidhujag I want to really force only offers that accept asset ‘X’ to show in my marketplace and that seems tricky in today’s world

keyare [3:45 PM]

joined #dantime.

sidhujag [3:45 PM]

bearededimage that is custom query to the indexer thats all and you have zmq today

beardedmage [3:46 PM]

i need to read the API more :slightlysmilingface: i know how to create an offer priced in an asset

sidhujag [3:46 PM]

you can build out an indexer that just takes those zmqs nad puts them in a table then search that db table

beardedmage [3:46 PM]

but idk how to force all escrownews against it to use that asset

sidhujag [3:47 PM]

well escrownew takes an offer guid and a txid if your not paying in sys..

blgh [3:47 PM]

@danosphere thanks for the detailed answer :). Yes truly valuable. Especially also for sellers willing to sell their products/services on different kind of market places build on syscoin in the future (as reseller channels). Doing KYC in this way for them enables them to easily scale up quickly without the hazzle and complex KYC compliance admin. (edited)

sidhujag [3:47 PM]

so pass the ext txid in and then its really up to the seller to say hey you didnt pay properly

beardedmage [3:47 PM]

is there any plan to enforce that at a protocol level tho?

sidhujag [3:47 PM]

the UI should trap that obviously by checking asset was paid into escrow

beardedmage [3:47 PM]

that sounds like overhead to me if offer guid XYZ only accepts asset FOO why would i need to do more work on top to ensure the escrows are paying in FOO

Zontar [3:48 PM]

#dantime

johnp [3:48 PM]

Hmm this is dantime :slightlysmilingface:

beardedmage [3:48 PM]

escrow new takes an offer GUID

iv_sek [3:48 PM]

joined #dantime.

johnp [3:48 PM]

Keep it on topic please

danosphere [3:48 PM]

ha sorry i dont have those answers :slightlysmilingface:

sidhujag [3:48 PM]

the only accepts is just a tag.. its not enforced
its enforced at a app layer not proto layer

beardedmage [3:49 PM]

ill take it to #community-dev sry, interested in hearing more later tho @sidhujag
we can keep this focused to the topic at hand, sorry!

bstr156 [3:51 PM]

All in all, I now realize more than ever, I need more SYS.

blgh [3:54 PM]

@danosphere Regarding Pangolin (and revenue streams), nowadays perhaps still few people use crypto to pay (because of volatility). How you guys expect Pangolin to be used by consumers/businesses with crypto on the short term/nowadays?

Or will it be enabled as well for FIAT payments on the short term (with lower fees than traditional payment providers) and you expect later people to switch more towards crypto (en mass)? Curious about that :). (edited)

peekay [3:55 PM]

joined #dantime.

danosphere [3:55 PM]

@blgh so a lil of both tbh
we are working to enable fiat to SYS/crypto directly from Pangolin- so thats for the few ppl who use it to pay
and then Pangolin (or, more broadly the authentication functionality it provides) is going to be needed for people to interact with b2b web blockchain products as a whole anyway
so i see it being used in both cases

messycaptain [3:56 PM]

joined #dantime.

danosphere [3:56 PM]

but in the latter its a requirement, in the former (pay for things) its more of an option

Bill Perkins [3:56 PM]

joined #dantime.

danosphere [3:56 PM]

but an option we want to encourage and reduce friction around even going the other way like say most ppl dont pay w crypto right, but there are all these ppl that have SYS and wanna use it where only USD is accepted. we want to enable that kinda stuff through Pangolin as well- where you say ‘Pay with Syscoin’ for something priced in USD on ebay what happens then is, through Pangolin, we convert your SYS to USD, load the USD on a virtual credit card, and then use that credit card to pay the ebay merchant in USD and you can always buy more SYS through Pangolin as well, using USD (or other fiat) – that’s the goal

messycaptain [3:59 PM]

@Dan…….. Whilst every coin was bottoming out why did someone from the team come out and said BM was shelved and being handed over to the community
And causing major syscoin stock hodlers investors
Zero or little confidence

Mass confusion amongst all those other groups telegram channels etc etc
The price went down as an obvious result of this predetermined action

The price is hardly recovering because of fear, uncertainty and doubt

danosphere [3:59 PM]

this was not a predetermined action in any way, these questions in the AMA aren’t scripted
I’m focused on the long term value of the protocol and products on top of it, im not watching price as I provide people answers related to what we’re prioritizing

vileda [4:00 PM]

No cause and effect proven there either, unless it tanked ETH too

danosphere [4:00 PM]

and 99% of other alts…
other than DOGE I guess… cause who knows

Pruane [4:02 PM]

joined #dantime.

danosphere [4:02 PM]

I gotta hope off here in 9min just a heads up if there are any remaining burning questions :slightlysmilingface:

blocknugget [4:02 PM]

In your opinion/s, what will be the first application of syscoin to truly add value to the coin?

danosphere [4:02 PM]

i honestly think creating a b2b application that a validating customer utilizes will be massive for Syscoin
some others were trying to tie SYS value to number of transactions, i think thats misleading

vileda [4:03 PM]

@danosphere any update on a timeline for a roadmap.?
Just asking before someone else brings it up after

danosphere [4:03 PM]

i think SYS value is in the use cases it can faciliate, if major companies start using it for X that will provide more value than any kinda of transactional volume ever will
because it will increase awareness while also forcing them to use the token day to day in order to get business done, it will be the kinda of thing you see on news channels all over the place like IBMs accomplishments
and i think that acts as a catalyst for more people and business to look at this ‘Syscoin’ thing and we can move into adjacent or other products from there

blgh [4:04 PM]

Aight, got it :). Looking to English Forward and the partnership; how the business case should look like more or less. Their platform is being build on Syscoin like a language marketplace where teachers are connected to students and payed with SYS (resulting in transactions on the Syscoin network)?

danosphere [4:05 PM]

syscoin fees are super low, transactional volume isnt going to make masternodes tons more value; real world use and awareness will
yep @blgh i think they are leaning towards an asset, which again even devoid of millions of transactions creates a huge amount of awareness where before there was none
they are an established company using an asset on the Syscoin protocol to reward and incentivize users, to me that does a lot of value for SYS

mcshawrick [4:06 PM]

joined #dantime along with mclovan.

danosphere [4:06 PM]

because you get these companies to use this stuff, they market their own platform which uses it, and by relation SYS gets a ton of exposure
and that is a very repeatable model
its not just a bunch of ICOs with empty promises that may never deliver, its companies using this stuff as a core part of their business

beardedmage [4:09 PM]

that sort of use is exactly where my questions around forced-asset use stem from, total :thumbsup:

rarkm [4:10 PM]

joined #dantime.

danosphere [4:11 PM]

and just to be clear @blgh yes it will result in those tx on Syscoin, but i dont think thats the bigger part of the value there

peekay [4:11 PM]

Are you guys going to the hamburg hackathon?

danosphere [4:11 PM]

i think the bigger part of the value is the company being bound to using Syscoin, marketing its asset on top of Syscoin, and in turn the ‘additional business eyeballs’ that brings the platform as a whole
We aren’t planning to at the moment @peekay but I’ll check it out now that you stuck it on my radar (edited)

peekay [4:12 PM]

Nice. Good to know.

danosphere [4:12 PM]

do you have a link btw?

vitacastro [4:12 PM]

joined #dantime.

blgh [4:12 PM]

@danosphere yeah to me too, massive and also a really cool usecase! Good way of marketing as well. Would be good to highlight this also on the new syscoin.org site. BMW is cool off course, but what we need to still make more clear to people (as community and team) is that in fact, Syscoin is a platform where 50 BMWs can be build on. Vertical market places are an ever rising trend (data, certificates, energy, language courses, you name it).. Imo Syscoin atm has the best cards to enable the potential of blockchain for (decentralise) market places of all kinds of purposes.

danosphere [4:14 PM]

10000% agree @blgh – there are a crazy number of different verticals BMWs could target; Fiverr, Upwork, Uber, Airbnb, Ebay, Amazon, Paxful, GiftcardGranny the list goes on
but people need to realize thats how all this works, its not one uber portal necessarily, there is a large amount of value in these niche marketplaces that provide direct value vs a centralized competitor in a very focused way

peekay [4:14 PM]

I’ll get it from my work. Hang on

danosphere [4:15 PM]

I actually really like the Airbnb idea, i think thats RIPE for disruption ever since airbnb started working with govts
thanks @peekay (edited)

Sergej86 [4:15 PM]

joined #dantime.

danosphere [4:16 PM]

And the airbnb path has interesting revenue opportunities too, since its literally not possible on other platforms in many locales
like i know in Vancouver airbnb is a huge nightmare now cause you need a business license, building owner approval, and airbnb checks all that
put your place on on decentralized airbnb and all those obstacles fade away and you can still get away charging a middleman fee
cause there is no other option for that market
and i expect that govt <-> airbnb coop to expand to other locales in short order

blgh [4:17 PM]

Exactly, don’t forget also online market places for food :). Rising trend in China, +60% searches their grocceries already online over there.. trend which is ‘confirmed’ by Amazon acquiring Wholefoods and moving into that e-comm vertical as well.. lots of interesting stuff going on!

danosphere [4:17 PM]

oh dont get me started on Wholefoods lol

gbeast [4:17 PM]

joined #dantime.

danosphere [4:18 PM]

I have a whole vision for improved supply chain and transparency using SYS for them that gives concious consumers 100% more transparency around those animal welfare ratings they tout so proudly and opaquely in all their stores
already have our sales guy working to get in their ear so we can pitch em
pretty simple idea – https://www.wholefoodsmarket.com/mission-values/animal-welfare/5-step-animal-welfare-rating
Whole Foods Market
5-Step® Animal Welfare Rating
Look for the ratings on our fresh beef, chicken and pork. It’s your way of knowing how the animals were raised for the meat you are buying.
May 13th, 2013
“prove it”
but again, they need a way to interact w these systems seamlessly- mobile, web, desktop; that is what we’re focused on in the very near term

lokalp [4:19 PM]

joined #dantime along with schlackyt.

danosphere [4:20 PM]

My apologies to anyone who just joined but I do need to step away here- last questions anyone?

blgh [4:20 PM]

Aight, yes so much to winn in these areas..! Of course, that makes sense.. building blocks and tech need to be in place, instead of selling baked air!
Thanks for your time Dan! :+1::skin-tone-2:

danosphere [4:21 PM]

and i dont need to go into how ‘Wholefoods uses Syscoin for supply chain transparency’ would add value to SYS to I?

blgh [4:21 PM]

Haha!!

danosphere [4:21 PM]

and how that would also likely force other major players to adopt a similar system or be left behind (Trader Joes, Harris Teeter, etc)
i mean im imaging QR codes next to the product your about to buy, that takes you to a third party website referencing blockchain data to tell you where that food has been

blgh [4:22 PM]

We can then shift to another galaxy I am afraid! :joy:

danosphere [4:22 PM]

literally from farm, to processor, to wholesaler, to the store you’re standing in
and at each step along the way you get detailed info about those different people touching your food

danosphere [4:23 PM]

same concepts apply to other industries as well; its stuff that gets me really excited and im sure once the community see some of this play our IRL they’ll be just as excited :slightlysmilingface:

jg [4:23 PM]

joined #dantime.

blgh [4:24 PM]

Yes, think so too :).

danosphere [4:24 PM]

I gotta hop off for now but appreciate everyone stopping by to ask questions and hopefully I provided some further clarity on our bigger vision for how this tech becomes even more valuable through real world use
hope everyone has a great weekend! looking forward to seeing everyone back here next week, we’ll keep using this room I like how it keeps the discussion focused :thumbsup: have a great weekend all!

beardedmage [4:25 PM]

thanks @danosphere!

online123 [4:26 PM]

joined #dantime along with 2 others.

locutus [4:28 PM]

Who left the light on?

johnp [4:28 PM]

The miner

keyare [4:29 PM]

lol nice one

blgh [4:30 PM]

Thanks Dan! :ok_hand::skin-tone-2:

Sandy [4:36 PM]

joined #dantime along with 43 others.

Syscoin 2018-09-14 Dan AMA was last modified December 29th, 2018 by Justin Silver

The post Syscoin 2018-09-14 Dan AMA appeared first on Justin Silver.

]]> https://www.justinsilver.com/technology/cryptocurrency/syscoin-2018-09-14-dan-ama/feed/ 0 https://www.justinsilver.com/technology/cryptocurrency/syscoin-zmq-node-js-realtime-blockchain/?utm_source=rss&utm_medium=rss&utm_campaign=syscoin-zmq-node-js-realtime-blockchain https://www.justinsilver.com/technology/cryptocurrency/syscoin-zmq-node-js-realtime-blockchain/#respond Fri, 13 Jul 2018 05:03:20 +0000 https://www.justinsilver.com/?p=4639 Realtime Updates from the Syscoin Blockchain You can use the ZMQ topic message queues in Syscoin to receive realtime updates for your application. Using in conjunction with syscoin-core to blockchain-enable your applications in no...

The post Syscoin + ZMQ + Node.js = Realtime Blockchain Updates! appeared first on Justin Silver.

]]> AmpedSense.OptimizeAdSpot('AP'); AmpedSense.OptimizeAdSpot('IL'); AmpedSense.OptimizeAdSpot('IR');

Realtime Updates from the Syscoin Blockchain

You can use the ZMQ topic message queues in Syscoin to receive realtime updates for your application. Using in conjunction with syscoin-core to blockchain-enable your applications in no time.

Syscoin Configuration

Make sure to enable the ZMQ listeners in your syscoin.conf file and restart syscoind or Syscoin Core Qt.

# server
server=1
daemon=1

# indexes
addressindex=1
txindex=1
litemode=0

# rpc
rpcuser=u
rpcpassword=p
rpcport=8370
rpcallowip=127.0.0.1

# zmq listener config
zmqpubaliasrecord=tcp://127.0.0.1:3030
zmqpubaliashistory=tcp://127.0.0.1:3030
zmqpubaliastxhistory=tcp://127.0.0.1:3030
zmqpubassetrecord=tcp://127.0.0.1:3030
zmqpubassetallocation=tcp://127.0.0.1:3030
zmqpubassethistory=tcp://127.0.0.1:3030
zmqpubcertrecord=tcp://127.0.0.1:3030
zmqpubcerthistory=tcp://127.0.0.1:3030
zmqpubescrowrecord=tcp://127.0.0.1:3030
zmqpubescrowbid=tcp://127.0.0.1:3030
zmqpubescrowfeedback=tcp://127.0.0.1:3030
zmqpubofferrecord=tcp://127.0.0.1:3030
zmqpubofferhistory=tcp://127.0.0.1:3030
zmqpubhashblock=tcp://127.0.0.1:3030
zmqpubhashtx=tcp://127.0.0.1:3030
zmqpubhashtxlock=tcp://127.0.0.1:3030
zmqpubrawblock=tcp://127.0.0.1:3030
zmqpubrawtx=tcp://127.0.0.1:3030
zmqpubrawtxlock=tcp://127.0.0.1:3030

Create ZMQ Client

You will need to npm install the module zeromq.

const zeromq = require('zeromq');

const subscriber = zeromq.socket('sub');
subscriber.on('message', async (topic, message) => {
  topic = topic.toString('utf8');
  message = message.toString('utf8')
  const alias = JSON.parse(message);
  console.log(JSON.stringify(alias, null, 2));
});

// connect to message producer
subscriber.connect('tcp://127.0.0.1:3030');
subscriber.subscribe('aliasrecord');
console.log('subscribed to syscoin topic aliasrecord');

Run your script with the following:

> node zmq-client.js 
subscribed to syscoin topic aliasrecord
{
  "_id": "gldm1",
  "address": "SRxK2GjfzTrm8z5PgCtLKzheN5ebd5kN8f",
  "expires_on": 1590601936,
  "encryption_privatekey": "",
  "encryption_publickey": ""
}
{
  "_id": "elatte",
  "address": "Sd8JMHxtuFVSVJN2V51M27S6MkBBMjgjHY",
  "expires_on": 1559077278,
  "encryption_privatekey": "",
  "encryption_publickey": ""
}
{
  "_id": "primitive7",
  "address": "Sk7q3kZcttBNVkUwpMXU59yQf9Pco4sAAJ",
  "expires_on": 1558656041,
  "encryption_privatekey": "",
  "encryption_publickey": ""
}
{
  "_id": "primitive9",
  "address": "SYKff6VzkrzmSn9tL3zZE7FmV2dGFSKfxs",
  "expires_on": 1558656041,
  "encryption_privatekey": "",
  "encryption_publickey": ""
}
// ....

Syscoin + ZMQ + Node.js = Realtime Blockchain Updates! was last modified July 13th, 2018 by Justin Silver

The post Syscoin + ZMQ + Node.js = Realtime Blockchain Updates! appeared first on Justin Silver.

]]> https://www.justinsilver.com/technology/cryptocurrency/syscoin-zmq-node-js-realtime-blockchain/feed/ 0 https://www.justinsilver.com/technology/cryptocurrency/syscoin-node-js-blockchain-apps/?utm_source=rss&utm_medium=rss&utm_campaign=syscoin-node-js-blockchain-apps https://www.justinsilver.com/technology/cryptocurrency/syscoin-node-js-blockchain-apps/#respond Fri, 13 Jul 2018 04:29:12 +0000 https://www.justinsilver.com/?p=4648 Getting Started You will need to have syscoind or Syscoin Core Qt running on your system and have node/npm installed. If you don’t have Node.js I recommend installing it via nvm. Syscoin Configuration First...

The post Syscoin + Node.js = Blockchain Apps! appeared first on Justin Silver.

]]> AmpedSense.OptimizeAdSpot('AP'); AmpedSense.OptimizeAdSpot('IL'); AmpedSense.OptimizeAdSpot('IR');

Getting Started

You will need to have syscoind or Syscoin Core Qt running on your system and have node/npm installed. If you don’t have Node.js I recommend installing it via nvm.

Syscoin Configuration

First make sure that syscoind is configured so that you can connect to the RPC server locally. Use the example below, choosing a secret rcpuser, rpcpassword, and optionally changing the rpcport. You will need to use these values later to connect to query the blockchain using Node.js later.

You don’t really need the ZMQ config for this example, but it shows how to tell Syscoin to listen on those ports should you want to implement a Node.js ZMQ client in your application :).

Before making changes be sure to stop Syscoin by running syscoin-cli stop, update the configuration, then run syscoind to start the process again. If you change the config file before stopping Syscoin it will prevent syscoin-cli from being able to communicate with the RPC server properly. Changing the index values may require you to restart with syscoind -reindex.

# server
server=1
daemon=1

# indexes
addressindex=1
txindex=1
litemode=0

# rpc
rpcuser=u
rpcpassword=p
rpcport=8370
rpcallowip=127.0.0.1

# zmq listener config
zmqpubaliasrecord=tcp://127.0.0.1:3030
zmqpubaliashistory=tcp://127.0.0.1:3030
zmqpubaliastxhistory=tcp://127.0.0.1:3030
zmqpubassetrecord=tcp://127.0.0.1:3030
zmqpubassetallocation=tcp://127.0.0.1:3030
zmqpubassethistory=tcp://127.0.0.1:3030
zmqpubcertrecord=tcp://127.0.0.1:3030
zmqpubcerthistory=tcp://127.0.0.1:3030
zmqpubescrowrecord=tcp://127.0.0.1:3030
zmqpubescrowbid=tcp://127.0.0.1:3030
zmqpubescrowfeedback=tcp://127.0.0.1:3030
zmqpubofferrecord=tcp://127.0.0.1:3030
zmqpubofferhistory=tcp://127.0.0.1:3030
zmqpubhashblock=tcp://127.0.0.1:3030
zmqpubhashtx=tcp://127.0.0.1:3030
zmqpubhashtxlock=tcp://127.0.0.1:3030
zmqpubrawblock=tcp://127.0.0.1:3030
zmqpubrawtx=tcp://127.0.0.1:3030
zmqpubrawtxlock=tcp://127.0.0.1:3030

Init Node App

Next create a new folder for your project and create a Node project by running npm init and answering the questions as you see fit. The only module that is required is syscoin-core, a cutting edge version can be found at my fork.

mkdir -p my-syscoin-app && cd my-syscoin-app
npm init
# answer init questions
npm install -S https://github.com/doublesharp/syscoin-core.git#dev-3.0

Create index.js Script

Once syscoin-core is installed you can use the following example to get started. Make sure that the port, username, and password match the values set in your syscoin.conf file.

const SyscoinClient = require('@syscoin/syscoin-core');

const syscoin = new SyscoinClient({
  host: process.env.SYSCOIND_HOST || 'localhost',
  port: process.env.SYSCOIND_PORT || 8370,
  username: process.env.SYSCOIND_USER || 'u',
  password: process.env.SYSCOIND_PASS || 'p',
  timeout: 30000,
});

async function run() {
  // prune expired data!
  const pruneStart = Date.now();
  const prune = await syscoin.pruneSyscoinServices();
  console.log('pruned', prune, 'in', Date.now()-pruneStart, 'ms');

  // get all alias records
  const aliasStart = Date.now();
  const list = await syscoin.listAliases(0);
  console.log('fetched', list.length, 'aliases in', Date.now()-aliasStart, 'ms');

  // get just an array of alias names
  const aliases = list.map((alias) => alias._id);
  // ...etc

  process.exit(0);
}

run();

Wrapping Up

> node index.js
pruned { services_cleaned: 0 } in 341 ms
fetched 15162 aliases in 1685 ms

You can take this same basic structure and turn it into an Express app, etc, depending on the needs of your application. It’s surprisingly easy to get started building blockchain applications with Syscoin!

Syscoin + Node.js = Blockchain Apps! was last modified July 12th, 2018 by Justin Silver

The post Syscoin + Node.js = Blockchain Apps! appeared first on Justin Silver.

]]> https://www.justinsilver.com/technology/cryptocurrency/syscoin-node-js-blockchain-apps/feed/ 0 https://www.justinsilver.com/technology/cryptocurrency/syscoin-3-alias-creation/?utm_source=rss&utm_medium=rss&utm_campaign=syscoin-3-alias-creation https://www.justinsilver.com/technology/cryptocurrency/syscoin-3-alias-creation/#comments Sun, 27 May 2018 20:17:20 +0000 https://www.justinsilver.com/?p=4549 Or, How I Learned To Stop Worrying and Love the Command Line Before we start – please read this post fully! It will only take a few minutes, and you will feel much more...

The post Syscoin 3 Alias Creation appeared first on Justin Silver.

]]> AmpedSense.OptimizeAdSpot('AP'); AmpedSense.OptimizeAdSpot('IL'); AmpedSense.OptimizeAdSpot('IR');

Or, How I Learned To Stop Worrying and Love the Command Line

Before we start – please read this post fully! It will only take a few minutes, and you will feel much more comfortable creating your alias. Don’t worry about all the text, I included a lot of detail but these are the only commands you actually need to run – it’s mostly cutting and pasting.

aliasnew YOUR_ALIAS "" 3 EXPIRATION YOUR_ALIAS_ADDRESS "" "" ""
syscointxfund ALIAS_HEX '{"addresses": ["YOUR_FUNDING_ADDRESS"]}'
signrawtransaction RAW_HEX
syscoinsendrawtransaction SIGNED_HEX

Getting Started

To use any Syscoin Alias service you will first need to enable the address index in the Syscoin Core by adding addressindex=1 to your syscoin.conf file, then restarting Syscoin Core Qt and reindexing (it will prompt you when you restart). If you are using syscoind directly you will need to run syscoin-cli stop followed by syscoind -reindex to trigger the reindexing process.

The process to create a Syscoin Alias is just 4 commands. You will need to run them once to reserve your alias, then a second time after waiting for a block confirmation to finalize your alias registration. You will need a small amount of SYS available, and either an existing address (funded or unfunded) or a new address to assign to the alias.

When selecting an expiration timestamp you will need to use Unix Epoch Time. Determine your expiration time by using a site such as https://www.epochconverter.com/ and make sure to only select 1 or 2 years for your expiration – aliases become exponentially more expensive and be quite pricey to reserve for a very long time.

If you’re wallet is encrypted (and it should be!) then you will need to unlock you wallet with `walletpassphrase ‘YOUR_PASSSPHRASE’ 1800` to unlock it for 30 minutes (1800 seconds).

It is recommended to create a new address to use to fund your alias creation transaction – you can do this by sending 1 SYS to a new address in your wallet and noting the address for later use when funding your alias creation transaction.

Alias Creation via RPC

First, get familiar with the aliasnew command. You can read the help below or run syscoin-cli help aliasnew to see it on your system.

aliasnew [aliasname] [public value] [accept_transfers_flags=3] [expire_timestamp] [address] [encryption_privatekey] [encryption_publickey] [witness]
<aliasname> alias name.
<public value> alias public profile data, 256 characters max.
<accept_transfers_flags> 0 for none, 1 for accepting certificate transfers, 2 for accepting asset transfers and 3 for all. Default is 3.
<expire_timestamp> Time in seconds. Future time when to expire alias. It is exponentially more expensive per year, calculation is FEERATE*(2.88^years). FEERATE is the dynamic satoshi per byte fee set in the rate peg alias used for this alias. Defaults to 1 hour.
<address> Address for this alias.
<encryption_privatekey> Encrypted private key used for encryption/decryption of private data related to this alias. Should be encrypted to publickey.
<encryption_publickey> Public key used for encryption/decryption of private data related to this alias.
<witness> Witness alias name that will sign for web-of-trust notarization of this transaction.

If you are running these commands from the command line and not the Syscoin Core Qt Console, just add “syscoin-cli” before each command, otherwise follow them filling in your details where there are capital letters.

aliasnew

In these examples YOUR_ALIAS is the alias name you want to register, in lower case (ironically). Replace YOUR_ALIAS_ADDRESS with the address you want to associate with your alias (possibly your masternode staking address?). For the EXPIRATION use https://www.epochconverter.com/ to generate the expiration in Unix Epoch time – no more than a year or two is strongly recommend due to exponentially increasing fees.

aliasnew YOUR_ALIAS "" 3 EXPIRATION YOUR_ALIAS_ADDRESS "" "" ""

[
 "00740000010ae45894ba90b24c5120db9354d44fc93f17b86dcc269eddd8111f2454c629f20200000000feffffff02f1020000000000005e515140313463626631663365313533636633656166643736346530396262303532373239336134343935353934333936363536323665353436656533633531316364646d7576a91464c63b4b3398452a32a8d9f47b42ee63d2a59cac88ac85c2e59a000000001976a914c1da47e228637af983e1c75172506eabd77962c188acf4040000",
 "TKA43ch9qBVh7H8LmfSNFN5GqPsXfLyNqJ"
]

syscointxfund

Copy the hex string result from the aliasnew command (the top part), which we will call ALIAS_HEX below to keep it readable. Replace YOUR_FUNDING_ADDRESS with the address you want to fund the transaction with – note that the change from this transaction will be sent to a new address, so it’s best to fund with a different address than you want to have your SYS associated with.

• ALIAS_HEX=output from aliasnew, “0074000….” in the example above
• YOUR_FUNDING_ADDRESS=address to fund tx

syscointxfund ALIAS_HEX '{"addresses": ["YOUR_FUNDING_ADDRESS"]}'

[
 "007400000179347c7191687ee50469bb8cb8a50a978db51651f482e114d24a6ba926a027ed010000001976a914572b8c4219a138984742c46b231f63afaad6688c88acffffffff02b80b0000000000005e515140373137383831646139346264353934343335383837363766373739343538386134373966313064613163373862313235373333623664373165386262623666326d7576a9149ec5c7b6544d752575ed7672d7984b5aceb14cd588ac534c0609000000001976a9147dc19cec3f574a85d94f2b05186bf3fec39f170588ac00000000"
]

signrawtransaction

The result of this command is the raw transaction hex, which we will call RAW_HEX from now on, again for brevity. Next you need to sign this raw transaction with your private key before it can be submitted.

• RAW_HEX=output from syscointxfund

signrawtransaction RAW_HEX

{
 "hex": "00740000010ae45894ba90b24c5120db9354d44fc93f17b86dcc269eddd8111f2454c629f2020000006a47304402200be0e27776d44cb9ce69dc683c5d1fc41aceca4131392957181f25d40eae186b02201ac64cdbd219f6e587f347d87f5f72f36a22a85050a8c4d79e0d9e3adb29eff9012103d0f289fbb510b953fa5cecc20cf70f95a249c6e30cc8fec292b45a0637120a19feffffff02f1020000000000005e515140313463626631663365313533636633656166643736346530396262303532373239336134343935353934333936363536323665353436656533633531316364646d7576a91464c63b4b3398452a32a8d9f47b42ee63d2a59cac88ac85c2e59a000000001976a914c1da47e228637af983e1c75172506eabd77962c188acf4040000",
 "complete": true
}

syscoinsendrawtransaction

This gives us a signed transaction hex that we can submit to the network which we will call SIGNED_HEX. Now, submit it to the network to reserve your alias.

• SIGNED_HEX=output from signrawtransaction

syscoinsendrawtransaction SIGNED_HEX

{
 "txid": "d4a5ecdd111978082862f2b2ebc199f29158dd5f397df3117dd68e791ed9f446"
}

Wait, and repeat…

The result of this is the transaction id that was submitted to the network. Now we need to wait for a couple of blocks before we can confirm the alias reservation to complete the registration. Check the current block height so you know where to start.

> getinfo

{
  "version": "3.0.4.1",
  "dashversion": "0.12.3",
  "protocolversion": 70221,
  "walletversion": 3000000,
  "balance": 26.42070085,
  "privatesend_balance": 0.00000000,
  "blocks": 36817,
  "timeoffset": 0,
  "connections": 8,
  "proxy": "",
  "difficulty": 137061451496.0324,
  "testnet": false,
  "keypoololdest": 1525736009,
  "keypoolsize": 1999,
  "unlocked_until": 0,
  "paytxfee": 0.00000000,
  "relayfee": 0.00010000,
  "errors": ""
}

In the results you can see "blocks": 36817, though it will be higher when you run these commands :). Wait for a minute or two, then run it again to check the height. After a couple of blocks you are ready to continue. Enter the same four commands again entering exactly the same information for aliasnew but updating each with the response of the commands the second time you run them.

Confirm Registation

aliasnew YOUR_ALIAS "" 3 EXPIRATION YOUR_ALIAS_ADDRESS "" "" ""
syscointxfund ALIAS_HEX '{"addresses": ["YOUR_FUNDING_ADDRESS"]}'
signrawtransaction RAW_HEX
syscoinsendrawtransaction SIGNED_HEX

Finished!

Now you’re done! You can check the status of your alias with the following commands. Fund your alias by sending to either your alias name or the underlying address.

aliasinfo YOUR_ALIAS
aliasbalance YOUR_ALIAS

Syscoin 3 Alias Creation was last modified May 28th, 2018 by Justin Silver

The post Syscoin 3 Alias Creation appeared first on Justin Silver.

]]> https://www.justinsilver.com/technology/cryptocurrency/syscoin-3-alias-creation/feed/ 7 https://www.justinsilver.com/technology/cryptocurrency/syscoin-core-3-0-build-scripts/?utm_source=rss&utm_medium=rss&utm_campaign=syscoin-core-3-0-build-scripts https://www.justinsilver.com/technology/cryptocurrency/syscoin-core-3-0-build-scripts/#comments Tue, 15 May 2018 20:24:55 +0000 https://www.justinsilver.com/?p=4487 Build Scripts Use the following commands to compile Syscoin 3.0 on a variety of operating systems. These scripts will prepare your system with the proper build tools and install the necessary libraries and source...

The post Syscoin Core 3.0 Build Scripts appeared first on Justin Silver.

]]> AmpedSense.OptimizeAdSpot('AP'); AmpedSense.OptimizeAdSpot('IL'); AmpedSense.OptimizeAdSpot('IR');

Build Scripts

Use the following commands to compile Syscoin 3.0 on a variety of operating systems. These scripts will prepare your system with the proper build tools and install the necessary libraries and source code to compile binaries on and for your system.

OSX

Requires Xcode and Homebrew.

# xcode command line tools
xcode-select --install

# update
brew update

# build tools
brew install git automake libtool miniupnpc openssl pkg-config protobuf python qt libevent qrencode librsvg

# boost
brew install boost

# berkeleydb 4.8
brew install berkeley-db@4

# miniupnpc
brew install miniupnpc

# zmq
brew install czmq

# syscoin
git clone https://github.com/syscoin/syscoin.git
cd syscoin
./autogen.sh
./configure
make -j$(sysctl -n hw.ncpu) -pipe
sudo make install

Ubuntu 16.04 LTS x64 Xenial

#!/bin/bash

# required for libdb4.8
sudo apt install -y software-properties-common
sudo add-apt-repository ppa:bitcoin/bitcoin

# update
sudo apt update -y

# build tools
sudo apt install -y git build-essential libtool autotools-dev automake pkg-config libssl-dev libevent-dev bsdmainutils python3

# boost
sudo apt install -y libboost-all-dev

# berkeleydb 4.8
sudo apt install -y libdb4.8-dev libdb4.8++-dev

# miniupnpc
sudo apt install -y libminiupnpc-dev

# zmq
sudo apt install -y libzmq3-dev

# syscoin
git clone https://github.com/syscoin/syscoin.git
cd syscoin
./autogen.sh
./configure
make -j$(nproc) -pipe
sudo make install

Ubuntu 14.04 LTS x64 Trusty

#!/bin/bash

# required for libdb4.8
sudo apt install -y software-properties-common
sudo add-apt-repository ppa:bitcoin/bitcoin

# update
sudo apt update -y

# build tools
sudo apt install -y git build-essential libtool autotools-dev automake pkg-config libssl-dev libevent-dev bsdmainutils python3 python-dev

# boost 1.65
curl -sL https://dl.bintray.com/boostorg/release/1.65.1/source/boost_1_65_1.tar.gz -o boost_1_65_1.tar.gz
tar -xvf boost_1_65_1.tar.gz && pushd boost_1_65_1
./bootstrap.sh
sudo ./b2 cxxflags=-fPIC -a --with=all -j$(nproc) toolset=gcc install
popd

# berkeleydb 4.8
sudo apt install -y libdb4.8-dev libdb4.8++-dev

# miniupnpc
sudo apt install -y libminiupnpc-dev

# zmq
sudo apt install -y libzmq3-dev

# syscoin
git clone https://github.com/syscoin/syscoin.git
cd syscoin
./autogen.sh
# must point to newer boost to prevent conflicts!
./configure --with-boost-libdir="/usr/local/lib/"
make -j$(nproc) -pipe
sudo make install

Debian Stretch

#!/bin/bash

# update
sudo apt update -y

# build tools
sudo apt install -y git build-essential libtool autotools-dev automake pkg-config libssl-dev libevent-dev bsdmainutils python3

# boost
sudo apt install -y libboost-all-dev

# berkeleydb 4.8 via syscoin contrib
source <(curl https://raw.githubusercontent.com/syscoin/syscoin/master/contrib/install_db4.sh) "$(pwd)"
export BDB_PREFIX="$(pwd)/db4"

# miniupnpc
sudo apt install -y libminiupnpc-dev

# zmq
sudo apt install -y libzmq3-dev
 
# syscoin
git clone https://github.com/syscoin/syscoin.git
cd syscoin
./autogen.sh
./configure BDB_LIBS="-L${BDB_PREFIX}/lib -ldb_cxx-4.8" BDB_CFLAGS="-I${BDB_PREFIX}/include" 
make -j$(nproc) -pipe
sudo make install

Fedora 22

#!/bin/bash

# update
sudo dnf update -y

# build tools
sudo dnf install -y git gcc-c++ libtool make autoconf automake openssl-devel libevent-devel python3

# boost
sudo dnf install -y boost-devel

# berkeleydb 4.8
sudo dnf install -y libdb4-devel libdb4-cxx-devel

# miniupnpc
sudo dnf install -y miniupnpc-devel

# zmq
sudo dnf install -y czmq-devel

# syscoin
git clone https://github.com/syscoin/syscoin.git
cd syscoin
./autogen.sh
./configure
make -j$(nproc) -pipe
sudo make install

CentOS 7

#!/bin/bash

# update
sudo yum update -y

# build tools
sudo yum install -y git gcc-c++ libtool make autoconf automake epel-release openssl-devel libevent-devel python3 python-devel patch

# boost 1.65
curl -sL https://dl.bintray.com/boostorg/release/1.65.1/source/boost_1_65_1.tar.gz -o boost_1_65_1.tar.gz
tar -xvf boost_1_65_1.tar.gz && pushd boost_1_65_1
./bootstrap.sh
sudo ./b2 cxxflags=-fPIC -a --with=all -j$(nproc) toolset=gcc link=static runtime-link=static install
popd

# berkeleydb 4.8 (requires epel-release)
sudo yum install -y libdb4-devel libdb4-cxx-devel

# upnp (requires epel-release)
sudo yum install -y miniupnpc-devel

# zmq  (requires epel-release)
sudo yum install -y czmq-devel
 
# syscoin
git clone https://github.com/syscoin/syscoin.git
cd syscoin
./autogen.sh
./configure
make -j$(nproc) -pipe
sudo make install

Syscoin Core 3.0 Build Scripts was last modified December 17th, 2018 by Justin Silver

The post Syscoin Core 3.0 Build Scripts appeared first on Justin Silver.

]]> https://www.justinsilver.com/technology/cryptocurrency/syscoin-core-3-0-build-scripts/feed/ 6