Document:

Exhibit 4.2

 

Date: July 10, 2018

 

To:

 

INX Limited (the “Company”); and

Holders of INX Tokens (the “Token Holders”)

 

Dear Sirs,

 

Re: Waiver and Subordination
Undertaking

 

WHEREAS, each shareholder of the Company holds shares
of the Company (the “Shareholders”);

 

WHEREAS, the Company intends to issue INX Tokens
(the “Tokens”) to certain persons, which Tokens may thereafter be transferred to other persons from time to
time; and

 

WHEREAS, each Shareholder desires to subordinate
certain claims or interests it may have on account of its shareholdings in the Company to each Token Claim and waive its rights
in connection with the cash amount reserved in the Company’s Cash Reserve Fund as set forth below;

 

NOW, THEREFORE, the undersigned, a shareholder of
the Company, hereby represents and warrants as follows:

 

		1.	It irrevocably subordinates all payments by the Company
on account of any Shareholders Claim to the prior satisfaction and payment in full by the Company of all Token Claims.

 

		2.	It irrevocably waives and subordinates, to the prior
satisfaction in full by the Company of any Token Claim, any claim, and undertakes that it shall not exercise any right or remedy,
directly or indirectly, that it may acquire under, or as a result of the following, with respect to the cash amount reserved in
the Cash Reserve Fund maintained by the Company: (i) any agreement it has with the Company; (ii) the organizational documents
of the Company (including without limitation, the Memorandum and Articles of Association of the Company); or (iii) any applicable
law or regulation.

 

		3.	In the event of any payment or distribution of assets
of the Company of any kind or character, whether in cash, property, or securities, upon the dissolution, winding up, or total
or partial liquidation or reorganization, readjustment, arrangement, or similar proceeding relating to the Company or its property,
whether voluntary or involuntary, or in bankruptcy, insolvency, receivership, arrangement, or similar proceedings or upon an assignment
for the benefit of creditors, or upon any other marshaling or composition of the assets and liabilities of the Company, or otherwise:
(i) all amounts owing on account of all Token Claims shall first be paid in full, before any Shareholders Claim Payment is made;
and (ii) so long as all Token Claims have not been paid in full, to the extent permitted by applicable law, any Shareholders Claim
Payment to which a Shareholder would be entitled except for the provisions hereof, shall be paid or delivered by the trustee in
bankruptcy, receiver, assignee for the benefit of creditors, or other liquidating agent making such payment for the benefit of
each Token Holder for application to the payment of all Token Claims.

 

		4.	In the event that, notwithstanding the provisions
of Sections 1 and 2, any Shareholders Claim Payment is received in contravention of Sections 1 and 2 by any Shareholder before
all Token Claims are paid in full, such Shareholders Claim Payment shall be held in trust for the benefit of each Token Holder
and shall be paid over or delivered to the Company for the benefit of each Token Holder for application to the payment in full
of all Token Claims remaining unpaid to the extent necessary to give effect to Sections 1 and 2, after giving effect to any concurrent
payments or distributions to each Token Holder in respect of all Token Claims.

 

     

     

    

 

		5.	Each Shareholder hereby subordinates any claim and
shall not exercise any right or remedy, directly or indirectly, that it may acquire by way of subrogation under this Waiver and
Subordination Undertaking, or as a result of the application of the provisions of this Waiver and Subordination Undertaking or
otherwise, unless and until all Token Claims have been paid in full.

 

		6.	All documents and instruments evidencing any shares
of the Company shall be endorsed with a legend noting that such documents and instruments are subject to this Waiver and Subordination
Undertaking.

 

		7.	It acknowledges, agrees and understands that:

 

		a.	There may be various agreements between the Token Holders
and the Company evidencing and governing the Token Claims, and each Shareholder acknowledges and agrees that such agreements are
not intended to confer any benefits on such Shareholder and that no Token Holder shall have any obligation to such Shareholder
or any other person to exercise any rights, enforce any remedies, or take any actions that may be available to them under such
agreements.

 

		b.	It waives, to the fullest extent permitted by law,
any and all notice of the incurrence of the Token Claims or any part thereof and any right to require marshaling of assets.

 

		c.	No right of any Token Holder to enforce the subordination
provided for herein or to exercise its other rights hereunder shall at any time in any way be prejudiced or impaired by any act
or failure to act by the Company, the Shareholders, or any other Token Holder or in connection with the such Token Holder’s
Tokens or Token Purchase Agreement, regardless of any knowledge thereof such Token Holder may have or otherwise be charged with.

 

		8.	For the purpose of this Waiver and Subordination Undertaking:

 

“Shareholders Claim” means
all indebtedness, liabilities, obligations, or undertakings of any kind or description of the Company owing to a Shareholder in
respect of any and all shares issued by the Company to such Shareholder, whether now existing or hereafter arising, and whether
due or to become due, absolute or contingent, liquidated or unliquidated, determined or undetermined.

 

“Shareholders Claim Payment” means
any payment or distribution by or on behalf of the Company, directly or indirectly, of assets of the Company of any kind or character,
whether in cash, property, or securities, including on account of the purchase, redemption, or other acquisition of shares, as
a result of any collection, sale, or other disposition of collateral, or by setoff exchange, or in any other manner, for or on
account of shares of the Company.

 

“Token Claim” means all indebtedness,
liabilities, obligations, or undertakings of any kind or description of the Company owing to any Token Holder arising out of, outstanding
under, evidenced by a Token or a Token Purchase Agreement, whether now existing or hereafter arising, and whether due or to become
due, absolute or contingent, liquidated or unliquidated, determined or undetermined, and including without limitation any claim
by a Token Holder against the Company for breaching a Token Purchase Agreement.

 

“Cash Reserve Fund” shall
bear the meaning ascribed to it in the public offering registration statement which shall be submitted to the US Securities and
Exchange Commission by the Company.

 

		9.	This Waiver and Subordination Undertaking is entered
into for the sole protection and benefit of the parties hereto, each person who is a Token Holder as of any relevant time, and
their successors and assigns, and no other person shall be a direct or indirect beneficiary of, or shall have any direct or indirect
cause of action or claim in connection with, this Waiver and Subordination Undertaking.

 

    2

     

    

 

		10.	It undertakes that it shall not sell, assign, or otherwise
transfer any right that the undersigned have in the Company (including without limitation, shares of the Company held by the undersigned)
to another party, unless such party executes a waiver in the form of this Waiver and Subordination Undertaking.

 

		11.	It acknowledges and agrees that each Token Holder
will have relied upon and will continue to rely upon this Waiver and Subordination Undertaking in purchasing INX Tokens.

 

		12.	THIS WAIVER AND SUBORDINATION UNDERTAKING SHALL BE
GOVERNED BY, AND CONSTRUED IN ACCORDANCE WITH, THE INTERNAL LAWS OF THE STATE OF NEW YORK, EXCLUDING NEW YORK’S CONFLICT
OF LAW PRINCIPLES.

 

		13.	EACH SHAREHOLDER HEREBY (I) SUBMITS TO THE EXCLUSIVE
JURISDICTION OF THE COURTS OF THE STATE OF NEW YORK AND THE FEDERAL COURTS OF THE UNITED STATES SITTING IN THE COUNTY OF NEW YORK,
STATE OF NEW YORK, FOR THE PURPOSE OF ANY ACTION OR PROCEEDING ARISING OUT OF OR RELATING TO THIS WAIVER AND SUBORDINATION UNDERTAKING,
(II) AGREES THAT ALL CLAIMS IN RESPECT OF ANY SUCH ACTION OR PROCEEDING MAY BE HEARD AND DETERMINED IN SUCH COURTS, AND (III)
IRREVOCABLY WAIVES (TO THE EXTENT PERMITTED BY APPLICABLE LAW) ANY OBJECTION THAT IT NOW OR HEREAFTER MAY HAVE TO THE LAYING OF
VENUE OF ANY SUCH ACTION OR PROCEEDING BROUGHT IN ANY OF THE FOREGOING COURTS, AND ANY OBJECTION ON THE GROUND THAT ANY SUCH ACTION
OR PROCEEDING IN ANY SUCH COURT HAS BEEN BROUGHT IN AN INCONVENIENT FORUM.

 

		14.	No amendment to any provision of this Waiver and Subordination
Undertaking shall in any event be effective unless the same shall be in writing and signed by the Company, each Shareholder, and
each Token Holder; and no waiver of any provision of this Waiver and Subordination Undertaking, or consent to any departure by
any Shareholder therefrom, shall in any event be effective unless the same shall be in writing and signed by each Token Holder.
Any such amendment, waiver, or consent shall be effective only in the specific instance and for the specific purpose for which
given.

 

	 	 
	[SHAREHOLDER]	 
	 	 	 
	By:	               	 
	 	 	 
	Date:	 	 

 

 

3Exhibit 4.3

 

	InxToken.sol	 

 

pragma solidity ^0.4.24;

 

import “./openzeppelin-solidity/contracts/math/SafeMath.sol”;

 

/** 

* @title INX Ownable

* @dev Extanded version of ownable, but with multiple
owners. The contract allow multiple owners

* to be set and checked.

*/

contract Ownable {

 

mapping ( address => uint) public owners;

 

event NewOwnerAdded(address _address);

 

/**

* @dev Throws if called by a none valid account.

*/

modifier onlyValidAddress(address _address) {

require(_address != address(0), “Address should
be valid”);

_;

}

 

/**

* @dev Throws if called by any account other than the
owner.

*/

modifier onlyOwner() {

require(isOwner(), “This operation requires an
owner privilages”);

_;

}

 

/**

 

* @return true if ‘msg.sender’ is the owner of the
contract.

*/

function isOwner() public view returns(bool) {

return owners[msg.sender] != 0;

}

 

/** 

* @dev Allows the current owner to add new oweners.

* @param newOwner The address to add as an owner.

*/

function addOwner(address newOwner) public
onlyValidAddress(newOwner) onlyOwner() returns (bool)

{

owners[newOwner] = 1;

emit NewOwnerAdded(newOwner);

return true;

}

 

/** 

* @dev Allows the current owner to remove owner from
the owners list control of the contract to a newOwner.

* @param ownerToRemoved The address of the owner that
should be removed.

*/

function removeOwner(address ownerToRemoved) public

onlyValidAddress(ownerToRemoved) onlyOwner() returns
(bool)

{

delete owners[ownerToRemoved];

return true;

}

}

 

/**

* @title INX Whitelisters

 

    1

     

    

 

	InxToken.sol	 

 

* @dev A similar version of Ownable list, but that
manages white lister - address that can only modify white listing.

*/

contract Whitelisters is Ownable{

 

mapping ( address => uint) public whitelisters;

 

event NewWhiteListerAdded(address _address);

event WhiteListerRemoved(address _address); 

 

/** 

* @dev Throws if called by a none valid account.

*/

modifier onlyValidAddress(address _address) {

require(_address != address(0), “Address should
be valid”);

_;

}

 

/** 

* @dev Throws if called by any account other than a
whitelister.

*/

modifier onlyWhitelister() {

require(isWhitelister(), “This operation requires
whitelister

privilages”);

_;

}

 

/** 

* @return true if ‘msg.sender’ is a whitelister of
the contract.

*/

function isWhitelister() public view returns(bool)
{

return whitelisters[msg.sender] != 0;

}

 

/** 

* @dev Allows the current owner to add new whitelister.

* @param newWhitelister The address to add as a whitelister.

*/

function addWhitelister(address newWhitelister) public

onlyValidAddress(newWhitelister) onlyOwner() returns
(bool) {

whitelisters[newWhitelister] = 1;

emit NewWhiteListerAdded(newWhitelister);

return true;

}

 

/** 

* @dev Allows the current owner to remove whitelister
from the whitelister list .

* @param whitelisterToRemoved The address of the owner
that should be removed.

*/

function removeWhitelister(address whitelisterToRemoved)
public

onlyValidAddress(whitelisterToRemoved) onlyOwner()
returns (bool) {

delete whitelisters[whitelisterToRemoved];

emit WhiteListerRemoved(whitelisterToRemoved);

return true;

}

}

 

contract Whitelisting is Ownable, Whitelisters {

 

event WhitelistUpdate(address _address,bool status,string
data);

  

    2

     

    

 

	InxToken.sol	 

 

struct whiteListItem {

 bool status;

string data;

}

 

// check for valid address 

modifier onlyValidAddress(address _address) {

require(_address != address(0), “Address should
be valid”);

_;

}

 

// white list status 

mapping (address => whiteListItem) public whitelist;

 

/** 

* @dev Set a white list address

* @param to the address to be set

* @param status the whitelisting status (true for yes,
false for no)

* @param data a string with data about the whitelisted
address

*/

function setWhitelist(address to, bool status, string
memory data)public

onlyValidAddress(to) onlyWhitelister returns(bool){

whitelist[to] = whiteListItem(status, data);

return true;

}

 

/** 

* @dev Check the status of the whitelist

* @param _address the address to be check

*/

function checkWhitelistStatus(address _address) public
view returns(bool){

return whitelist[_address].status;

}

 

/** 

* @dev Get the data of and address in the whitelist

* @param _address the address to retrieve the data
from

*/

function getWhitelistData(address _address) public
view returns(string memory)

{

return whitelist[_address].data;

}

}

 

contract Timelock is Ownable {

 

using SafeMath for uint256;

 

struct lockupItem {

 

uint256 amount;

uint256 releaseTime;

}

 

mapping (address => lockupItem) lockups;

 

event AccountLock(address _address, uint256 amount,
uint256 releaseTime);

event AccountRelease(address _address, uint256 amount);

 

/** 

* @dev lock address and amount and lock it, set the
release time

* @param _address the address to lock

* @param amount the amount to lock

* @param releaseTime of the locked amount
(in seconds since the epoch)

 

    3

     

    

 

	InxToken.sol	 

 

*/ 

function lock( address _address, uint256 amount, uint256
releaseTime)

public onlyOwner returns(uint256) {

require(releaseTime > block.timestamp);

require(_address != address(0));

 

lockupItem memory _lockupItem = lockupItem(amount,
releaseTime); 

lockups[_address] = _lockupItem;

emit AccountLock(_address, amount, releaseTime);

return block.timestamp;

}

 

/** 

* @dev release locked amount

* @param _address the address to retrieve the data
from

* @param amountToRelease the amount to check

*/

function release( address _address, uint256 amountToRelease)
public

onlyOwner returns(bool) {

require(_address != address(0));

 

uint256 _lockedAmount = lockups[_address].amount;

 

// nothing to release 

if(_lockedAmount == 0){

emit AccountRelease(_address, 0);

return;

}

 

// extract release time for re-locking 

uint256 _releaseTime = lockups[_address].releaseTime;

 

// delete the lock entry 

delete lockups[_address];

 

if(_lockedAmount >= amountToRelease){ 

uint256 newLockedAmount =_lockedAmount.sub(amountToRelease);

 

// re-lock the new locked balance 

lock(_address, newLockedAmount, _releaseTime);

emit AccountRelease(_address, amountToRelease);

} else {

emit AccountRelease(_address, 0);

}

 

//

 

}

 

/** 

* @dev check if the requested amount for transaction
is free for transter

* @param _address the address to retrieve the data
from

* @param amount the amount to check

*/

function checkNoneLockedAmount(address _address, uint256
amount, uint256 balance) public view returns(uint256)

 

{

 

// check if the address is listed in the lockups mapping 

if(lockups[_address].amount == 0) return amount;

 

// check if the lockup time has not passed (ie: 1555179440 

1893502800)

if(block.timestamp < lockups[_address].releaseTime){

 

    4

     

    

 

	InxToken.sol	 

 

// check if the address balance
is bigger than the locked amount 

if(balance > lockups[_address].amount) {

 

uint256 _noneLockedAvailableAmount = 0;

 

_noneLockedAvailableAmount = balance - 

lockups[_address].amount;

 

if( _noneLockedAvailableAmount >= amount) { 

return amount;

}

}

 

// the address balance is smaller
than the locked amount, return 

0;

return 0;

}

 

return amount;

 

}

 

/** 

* @dev get address lockup info

* @param _address the address to retrieve the data
from

* @return array of 2 uint256, release time (in seconds
since the epoch) and amount (in INX)

*/

function checkLockup(address _address) public view
returns(uint256,

uint256) {

 

// copy lockup data into memory 

lockupItem memory _lockupItem = lockups[_address];

 

return (_lockupItem.releaseTime, _lockupItem.amount);

 

}

}

 

import “./InxRegistry.sol”;

 

contract InxToken is Ownable, Whitelisters, Whitelisting, Timelock
{

 

using SafeMath for uint256;

 

string public symbol; 

string publicname;

uint8 public decimals;

uint256 private _totalSupply;

 

mapping (address => uint256) private _balances;

 

/** 

* @dev Total number of tokens in existence

*/

function totalSupply() public view returns (uint256)
{

return _totalSupply;

}

 

/** 

* @dev Token decimals

*/

function tokenDecimals() public view returns (uint8)
{

return decimals;

}

 

    5

     

    

 

	InxToken.sol	 

 

/** 

* @dev Gets the balance of the specified address.

* @param owner The address to query the balance of.

* @return An uint256 representing the amount owned
by the passed address.

*/

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

return _balances[owner];

}

 

// ERC20 private _allowed 

mapping (address => mapping (address => uint256))
private _allowed;

 

// service address 

address public serviceAddress;

 

InxRegistry private inxRegistery;

 

event InxServiceUpdate(address prevInxService, address
InxService);

event LockedAmount(address _address, uint256 executed,
uint256 requested, bool partialyExcuted);

event Approval(address indexed
owner, address indexed spender, uint256 value);

event Transfer(address indexed from, address indexed
to, uint256 value);

 

/** 

* @dev constructor

* @param registryService the address of the registry
service (validation

contruct)

*/

constructor(address registryService) public {

symbol = “INX”;

name = “INX Token”;

decimals = 18;

_totalSupply = 200000000 * 10 ** uint(decimals);

_balances[msg.sender] = _totalSupply; 

 

owners[msg.sender] = 1; 

whitelisters[msg.sender] = 1;

 

serviceAddress = registryService;

 

// set the registery service instace 

inxRegistery = InxRegistry(serviceAddress);

}

 

/** 

* @dev Update the referece the address of the validator

*/

function updateInxService(address _serviceAddress)
onlyOwner public {

address prevInxService = serviceAddress;

serviceAddress = _serviceAddress;

 

// set the registery service instace 

inxRegistery = InxRegistry(serviceAddress);

emit InxServiceUpdate(prevInxService, serviceAddress);

}

 

/**

 

* @dev Function to check the
amount of tokens that an owner allowed to a spender.

* @param owner address The address which owns the funds.

* @param spender address The address which will spend
the funds.

* @return A uint256 specifying the amount of tokens
still available for the spender.

 

    6

     

    

 

	InxToken.sol	 

 

*/ 

function allowance(

address owner,

address spender

)

public

view

returns (uint256)

{

return _allowed[owner][spender];

}

 

/** 

* @dev Approve the passed address to spend the specified
amount of tokens on behalf of msg.sender.

* @param spender The address which will spend the funds.

* @param value The amount of tokens to be spent.

*/

function approve(address spender, uint256 value) public
returns (bool) {

require(spender != address(0));

 

uint8 reason = 99;

 

// get the whitelist status of the INX spender 

bool _spenderWhitelistStatus = whitelist[spender].status;

 

// get the whitelist status of the INX approver 

bool _approverWhitelistStatus = whitelist[msg.sender].status;

 

// get the ownership status 

bool _isOwner = owners[msg.sender] == 1;

 

// approve validation (proxy contract) 

reason = inxRegistery.validate(msg.sender, spender,
0,

_spenderWhitelistStatus, _approverWhitelistStatus,
_isOwner,

“approve”);

 

if(reason == 0){ 

_allowed[msg.sender][spender] = value;

emit Approval(msg.sender, spender, value);

return true;

} else {

revert(“approval is not valid”);

return false;

}

}

 

/** 

* @dev Increase to the passed address the amount off
tokens that are

allowed to be spended on behalf of msg.sender.

* @param spender The address which will spend the funds.

* @param addedValue The amount of tokens to add that
can be spent.

*/

function increaseApproval(address spender, uint256
addedValue) public

returns(bool){

require(spender != address(0));

 

uint8 reason = 99;

 

// get the whitelist status of the INX spender 

bool _spenderWhitelistStatus = whitelist[spender].status;

 

// get the whitelist status of the INX approver 

bool _approverWhitelistStatus = whitelist[msg.sender].status;

 

    7

     

    

 

	InxToken.sol	 

 

// get the ownership status 

bool _isOwner = owners[msg.sender] == 1;

 

// approve validation (proxy contract) 

reason = inxRegistery.validate(msg.sender, spender,
0,

_spenderWhitelistStatus, _approverWhitelistStatus,
_isOwner,

“increaseApproval”);

 

if(reason == 0){ 

uint256 oldValue = _allowed[msg.sender][spender];

_allowed[msg.sender][spender] = oldValue.add(addedValue);

return true;

} else {

revert(“increase approval is not valid”);

return false;

}

}

 

/** 

* @dev Decrease to the passed address the amount off
tokens that are allowed to be spended on behalf of msg.sender.

* @param spender The address which will spend the funds.

* @param substractedValue The amount of
tokens to add that can be spent.

*/

function decreaseApproval(address spender, uint256
substractedValue)

public returns(bool){

require(spender != address(0));

 

uint8 reason = 99;

 

// get the whitelist status of the INX spender 

bool _spenderWhitelistStatus = whitelist[spender].status;

 

// get the whitelist status of the INX approver 

bool _approverWhitelistStatus = whitelist[msg.sender].status;

 

// get the ownership status 

bool _isOwner = owners[msg.sender] == 1;

 

// approve validation (proxy contract) 

reason = inxRegistery.validate(msg.sender, spender,
0,

_spenderWhitelistStatus, _approverWhitelistStatus,
_isOwner,

“decreaseApproval”);

 

if(reason == 0){ 

uint256 oldValue = _allowed[msg.sender][spender];

 

if(substractedValue > oldValue){ 

_allowed[msg.sender][spender] = 0;

} else {

_allowed[msg.sender][spender] =

oldValue.sub(substractedValue);

}

return true;

 

} else { 

revert(“decrease approval is not valid”);

return false;

}

  

}

 

    8

     

    

  

	InxToken.sol	 

  

/** 

* @dev Transfer tokens from one address to another

* @param from address The address which you want to
send tokens from

* @param to address The address which you want to transfer
to

* @param value uint256 the amount of tokens to be transferred

*/

function transferFrom(

address from,

address to,

uint256 value

)

public

returns (bool)

{

require(value <= _allowed[from][msg.sender], “not
enogth allowance”);

 

uint8 reason = 99;

 

// get the whitelist status of the INX spender 

bool _spenderWhitelistStatus = whitelist[msg.sender].status;

 

// get the whitelist status of the INX approver 

bool _approverWhitelistStatus = whitelist[from].status;

 

// get the ownership status 

bool _isOwner = owners[msg.sender] == 1;

 

// approve validation (proxy contract), inorder to
be consistant, we 

use the spender (msg.sender)

reason = inxRegistery.validate(from, msg.sender, 0,

_spenderWhitelistStatus, _approverWhitelistStatus,
_isOwner,

“transferFrom”);

 

if(reason == 0){ 

// substract

_allowed[from][msg.sender] = _allowed[from]

[msg.sender].sub(value);

 

_transfer(from, to, value); 

return true;

 

} else {

 

revert(“transfer from is not valid”);

return false;

}

}

 

/** 

* @dev transfer

* @param to the address to transfer the funds to

* @param value the number of tokens to transfer

*/

function transfer(address to, uint256 value) public
returns(bool) {

return _transfer(msg.sender, to, value);

}

 

/** 

* @dev _transfer

* @param to the address to transfer the funds to

* @param value the number of tokens to transfer

*/

function _transfer(address from, address to, uint256
value) internal

 

    9

     

    

 

	InxToken.sol	 

 

returns(bool) {

require(value <= _balances[from]);

require(to != address(0));

 

uint8 reason = 99;

 

// get the whitelist status of the INX receiver 

bool _toWhitelistStatus = whitelist[to].status;

 

// get the whitelist status of the INX sender 

bool _fromWhitelistStatus = whitelist[from].status;

 

// get the ownership status 

bool _isOwner = owners[msg.sender] == 1;

 

// check lockups 

uint256 _noneLockedAmount = checkNoneLockedAmount(from,
value,

_balances[from]);

 

// check if all amount is locked 

if(_noneLockedAmount == 0) {

emit LockedAmount(from,_noneLockedAmount, value, false);

revert(“amount is locked”);

}

 

// validate transaction (proxy contract) 

reason = inxRegistery.validate(from, to, _noneLockedAmount,

_toWhitelistStatus, _fromWhitelistStatus,
_isOwner, “transfer”);

 

if(reason == 0){ 

_balances[from] = _balances[from].sub(_noneLockedAmount);

_balances[to] = _balances[to].add(_noneLockedAmount);

emit Transfer(from, to, _noneLockedAmount);

} else {

revert(“transaction is not valid”);

}

 

return reason == 0;

 

}

}

 

 

10

Source: [{"source": "alea-institute/alea-institute/kl3m-data-edgar-agreements/train-00299-of-00352.parquet"}, [{"source": "alea-institute/alea-institute/kl3m-data-edgar-agreements/train-00299-of-00352.parquet"}]]