Exhibit 3.2

—————————

LDGR Issuer

—————————

pragma solidity ^0.4.24;

import "../libs/TransferAgentControlled.sol";

import "../libs/Owned.sol";

import "./LDGRSecurity.sol";

contract LDGRIssuer is Owned, TransferAgentControlled {

string public name;

address[] securities;

event CreateSecurity(

address indexed newSecurity,

string name,

string symbol

);

constructor (

address _initialOwner,

address _initialTransferAgent,

string _name

) Owned(_initialOwner) TransferAgentControlled(_initialTransferAgent) public {

name = _name;

}

event TransferAgentUpdated(

address indexed previousTransferAgent,

address indexed newTransferAgent

);

function setTransferAgent(address _newTransferAgent) public onlyOwner {

_setTransferAgent(_newTransferAgent);

}

function _setTransferAgent(address _newTransferAgent) internal {

require(_newTransferAgent != address(0), "Address cannot be 0.");

emit TransferAgentUpdated(transferAgent, _newTransferAgent);

transferAgent = _newTransferAgent;

}

function getSecurities() public view returns (address[]) {

return securities;

}

function createSecurity(string _name, string _symbol) public onlyTransferAgent returns (address) {

return _createSecurity(_name, _symbol);

}

function _createSecurity(string _name, string _symbol) internal returns (address) {

address newSecurity = new LDGRSecurity(this, _name, _symbol);

securities.push(newSecurity);

emit CreateSecurity(newSecurity, _name, _symbol);

return newSecurity;

}

}

—————————

LDGR Security

—————————

pragma solidity ^0.4.24;

import "../libs/IssuerControlled.sol";

import "./LDGRToken.sol";

contract LDGRSecurity is IssuerControlled {

string public name;

string public symbol;

address public token; // main token 0

address[] tokens; // all tokens

event CreateToken(

address indexed newToken,

uint256 indexed issuanceNumber

);

constructor (

address _issuer,

string _name,

string _symbol

) IssuerControlled(_issuer) public {

name = _name;

symbol = _symbol;

token = new LDGRToken(_issuer, _name, _symbol, 0);

tokens.push(token);

emit CreateToken(token, 0);

}

function getAllTokens() public view returns (address[]) {

return tokens;

}

function createToken(uint256 _issuanceNumber) public onlyIssuerTransferAgent returns (address) {

return _createToken(_issuanceNumber);

}

function _createToken(uint256 _issuanceNumber) internal returns (address) {

LDGRToken newToken = new LDGRToken(issuer, name, symbol, _issuanceNumber);

tokens.push(newToken);

emit CreateToken(newToken, _issuanceNumber);

return newToken;

}

}

—————————

LDGR Token

—————————

pragma solidity ^0.4.24;

/*

Interface for LDGR

*/

import "../libs/IssuerControlled.sol";

import "../libs/openzeppelin/math/SafeMath.sol";

contract LDGRToken is IssuerControlled {

using SafeMath for uint256;

string public name;

string public symbol;

uint256 public issuanceNumber;

mapping(address => uint256) balances;

uint256 public totalSupply;

uint8 public decimals;

event Transfer(

address indexed from,

address indexed to,

uint256 value

);

event GrantTokens(

address indexed to,

uint256 value

);

event RemoveTokens(

address indexed who,

uint256 value

);

constructor(

address _issuer,

string _name,

string _symbol,

uint256 _issuanceNumber

) IssuerControlled(_issuer) public {

name = _name;

symbol = _symbol;

issuanceNumber = _issuanceNumber;

decimals = 0;

}

function balanceOf(address _investor) public view returns (uint256) {

return balances[_investor];

}

function transferFrom(address _from, address _to, uint256 _value) public onlyIssuerTransferAgent returns (bool) {

require(_value <= balances[_from], "Not enough balance.");

require(_to != address(0), "_to is not valid.");

balances[_from] = balances[_from].sub(_value);

balances[_to] = balances[_to].add(_value);

emit Transfer(_from, _to, _value);

return true;

}

function grantTokens(address _to, uint256 _value) public onlyIssuerTransferAgent returns (uint256) {

require(_to != address(0), "_to is not valid.");

balances[_to] = balances[_to].add(_value);

totalSupply = totalSupply.add(_value);

emit GrantTokens(_to, _value);

return balances[_to];

}

function removeTokens(address _who, uint256 _value) public onlyIssuerTransferAgent returns (uint256) {

require(_value <= balances[_who], "_value cannot be greater than balance.");

balances[_who] = balances[_who].sub(_value);

totalSupply = totalSupply.sub(_value);

emit RemoveTokens(_who, _value);

return balances[_who];

}

}