public static bool snapshotStatesMockSet(byte[][] _channelIds, byte[][] _peerFroms, BigInteger[] _seqNums, BigInteger[] _transferOuts, BigInteger[] _pendingPayOuts)
{
BasicMethods.assert(_channelIds.Length == _peerFroms.Length &&
_peerFroms.Length == _seqNums.Length &&
_seqNums.Length == _transferOuts.Length &&
_transferOuts.Length == _pendingPayOuts.Length,
"Parameter length not the same");
for (int i = 0; i < _channelIds.Length; i++)
{
BasicMethods.assert(BasicMethods._isByte32(_channelIds[i]), "_channelIds " + i + " illegal");
BasicMethods.assert(BasicMethods._isLegalAddress(_peerFroms[i]), "_peerFroms " + i + " illegal");
BasicMethods.assert(_seqNums[i] >= 0, "_seqNums " + i + " illegal");
BasicMethods.assert(_transferOuts[i] >= 0, "_transferOuts " + i + " illegal");
BasicMethods.assert(_pendingPayOuts[i] >= 0, "_pendingPayOuts " + i + " illegal");
LedgerStruct.Channel c = LedgerStruct.getChannelMap(_channelIds[i]);
byte peerFromId = LedgerChannel._getPeerId(c, _peerFroms[i]);
LedgerStruct.PeerProfile[] peerProfiles = c.peerProfiles;
LedgerStruct.PeerProfile peerProfile = peerProfiles[peerFromId];
LedgerStruct.PeerState state = peerProfile.state;
state.seqNum = _seqNums[i];
state.transferOut = _transferOuts[i];
state.pendingPayOut = _pendingPayOuts[i];
peerProfile.state = state;
peerProfiles[peerFromId] = peerProfile;
c.peerProfiles = peerProfiles;
LedgerStruct.setChannelMap(_channelIds[i], c);
}
setTmpChannelIdSet(_channelIds);
return(true);
}
public static bool openChannel(byte[] _openRequest)
{
byte[] tmpChannelId = getTmpChannelId();
LedgerStruct.Channel c = LedgerStruct.getChannelMap(tmpChannelId);
LedgerStruct.PeerProfile[] peerProfiles = c.peerProfiles;
LedgerStruct.PeerProfile peerProfile0 = peerProfiles[0];
LedgerStruct.PeerProfile peerProfile1 = peerProfiles[1];
byte[][] peerAddrs =
{
peerProfile0.peerAddr,
peerProfile1.peerAddr
};
BigInteger[] amounts =
{
peerProfile0.deposit,
peerProfile1.deposit
};
PbEntity.TokenInfo token = c.token;
LedgerStruct.setChannelMap(tmpChannelId, c);
OpenChannelEvent(
tmpChannelId,
token.tokenType,
token.address,
peerAddrs,
amounts
);
return(true);
}
public static bool intendSettleMockSet(byte[] _channelId, byte[] _peerFrom, BigInteger _seqNum, BigInteger _transferOut, byte[] _nextPayIdListHash, BigInteger _lastPayResolveDeadline, BigInteger _pendingPayOut)
{
BasicMethods.assert(BasicMethods._isByte32(_channelId), "_channelId illegal");
BasicMethods.assert(BasicMethods._isLegalAddress(_peerFrom), "_peerFrom illegal");
BasicMethods.assert(_seqNum >= 0, "_seqNum smaller than zero");
BasicMethods.assert(_transferOut >= 0, "_transferOut smaller than zero");
BasicMethods.assert(BasicMethods._isByte32(_nextPayIdListHash), "_nextPayIdListHash illegal");
BasicMethods.assert(_lastPayResolveDeadline >= 0, "_lastPayResolveDeadline smaller than zero");
BasicMethods.assert(_pendingPayOut >= 0, "_pendingPayOut smaller than zero");
LedgerStruct.Channel c = LedgerStruct.getChannelMap(_channelId);
byte peerFromId = LedgerChannel._getPeerId(c, _peerFrom);
BasicMethods.assert(peerFromId == 0 || peerFromId == 1, "peerFromId illegal");
LedgerStruct.PeerProfile[] peerProfiles = c.peerProfiles;
LedgerStruct.PeerProfile peerProfile = peerProfiles[peerFromId];
LedgerStruct.PeerState state = peerProfile.state;
state.seqNum = _seqNum;
state.transferOut = _transferOut;
state.nextPayIdListHash = _nextPayIdListHash;
state.lastPayResolveDeadline = _lastPayResolveDeadline;
state.pendingPayOut = _pendingPayOut;
peerProfile.state = state;
peerProfiles[peerFromId] = peerProfile;
c.peerProfiles = peerProfiles;
c = _updateOverallStatesByIntendState(c);
LedgerStruct.setChannelMap(_channelId, c);
setTmpChannelId(_channelId);
return(true);
}
private static LedgerStruct.Channel _resetDuplexState(LedgerStruct.Channel c)
{
c.settleFinalizedTime = 0;
LedgerStruct.ChannelStatus channelStatus = LedgerStruct.getStandardChannelStatus();
c = _updateChannelStatus(c, channelStatus.Operable);
LedgerStruct.PeerProfile[] peerProfiles = c.peerProfiles;
LedgerStruct.PeerProfile peerProfile0 = peerProfiles[0];
LedgerStruct.PeerProfile peerProfile1 = peerProfiles[1];
LedgerStruct.PeerState state = peerProfile0.state;
state.seqNum = 0;
state.transferOut = 0;
state.nextPayIdListHash = null;
state.lastPayResolveDeadline = 0;
state.pendingPayOut = 0;
peerProfile0.state = state;
state = peerProfile1.state;
state.seqNum = 0;
state.transferOut = 0;
state.nextPayIdListHash = null;
state.lastPayResolveDeadline = 0;
state.pendingPayOut = 0;
peerProfile1.state = state;
peerProfiles[0] = peerProfile0;
peerProfiles[1] = peerProfile1;
c.peerProfiles = peerProfiles;
// reset possibly remaining WithdrawIntent freezed by previous intendSettle()
LedgerStruct.WithdrawIntent intent = c.withdrawIntent;
intent.receiver = null;
intent.amount = 0;
intent.requestTime = 0;
intent.recipientChannelId = null;
c.withdrawIntent = intent;
return(c);
}
public static bool intendSettle(byte[] _signedSimplexStateArray)
{
byte[] _channelId = getTmpChannelId();
BasicMethods.assert(BasicMethods._isByte32(_channelId), "_channelId illegal");
LedgerStruct.Channel c = LedgerStruct.getChannelMap(_channelId);
IntendSettleEvent(_channelId, LedgerChannel._getStateSeqNums(c));
return(true);
}
public static bool intendWithdraw(byte[] _channelId, BigInteger _amount, byte[] _recipientChannelId)
{
BasicMethods.assert(BasicMethods._isByte32(_channelId), "_channelId illegal");
BasicMethods.assert(_amount >= 0, "_amount smaller than zero");
BasicMethods.assert(BasicMethods._isByte32(_recipientChannelId), "_recipientChannelId illegal");
LedgerStruct.Channel c = LedgerStruct.getChannelMap(_channelId);
IntendWithdrawEvent(_channelId, c.withdrawIntent.receiver, _amount);
return(true);
}
public static bool snapshotStates(byte[] _signedSimplexStateArray)
{
byte[][] tmpChannelIds = getTmpChannelIdSet();
for (int i = 0; i < tmpChannelIds.Length; i++)
{
BasicMethods.assert(BasicMethods._isByte32(tmpChannelIds[i]), "tmpChannelIds " + i + " illegal");
LedgerStruct.Channel c = LedgerStruct.getChannelMap(tmpChannelIds[i]);
SnapshotStatesEvent(tmpChannelIds[i], LedgerChannel._getStateSeqNums(c));
}
return(true);
}
public static object depositNEO(byte[] walletId)
{
BasicMethods.assert(BasicMethods._isByte32(walletId), "walletId is not byte32");
PbEntity.TokenType token = PbEntity.getStandardTokenType();
BigInteger value = LedgerStruct.getTransactionValue(token.NEO, ExecutionEngine.ExecutingScriptHash);
BasicMethods.assert(value >= 0, "amount is less than zero");
_whenNotPaused();
BasicMethods.assert(_updateBalance(walletId, LedgerStruct.NeoAddress, value, getStandardMathOperation().add), "updateBalance failed");
DepositToWallet(walletId, LedgerStruct.NeoAddress, value);
return(true);
}
public static bool confirmSettle(byte[] _channelId)
{
BasicMethods.assert(BasicMethods._isByte32(_channelId), "_channelId illegal");
LedgerStruct.Channel c = LedgerStruct.getChannelMap(_channelId);
LedgerStruct.SettleBalance balance = LedgerChannel._validateSettleBalance(c);
if (balance.isSettled != 1)
{
c = _resetDuplexState(c);
ConfirmSettleFailEvent(_channelId);
return(false);
}
LedgerStruct.ChannelStatus channelStatus = LedgerStruct.getStandardChannelStatus();
c = _updateChannelStatus(c, channelStatus.Closed);
LedgerStruct.setChannelMap(_channelId, c);
ConfirmSettleEvent(_channelId, balance.balance);
return(true);
}
public static bool intendWithdrawMockSet(byte[] _channelId, BigInteger _amount, byte[] _recipientChannelId, byte[] _receiver)
{
BasicMethods.assert(BasicMethods._isByte32(_channelId), "_channelId illegal");
BasicMethods.assert(_amount >= 0, "_amount smaller than zero");
BasicMethods.assert(BasicMethods._isByte32(_recipientChannelId), "_recipientChannelId illegal");
BasicMethods.assert(BasicMethods._isLegalAddress(_receiver), "_receiver illegal");
LedgerStruct.Channel c = LedgerStruct.getChannelMap(_channelId);
LedgerStruct.WithdrawIntent withdrawIntent = c.withdrawIntent;
withdrawIntent.receiver = _receiver;
withdrawIntent.amount = _amount;
withdrawIntent.requestTime = Blockchain.GetHeight();
withdrawIntent.recipientChannelId = _recipientChannelId;
c.withdrawIntent = withdrawIntent;
setTmpChannelId(_channelId);
LedgerStruct.setChannelMap(_channelId, c);
return(true);
}
private static LedgerStruct.Channel _updateChannelStatus(LedgerStruct.Channel _c, byte _newStatus)
{
if (_c.status == _newStatus)
{
return(_c);
}
LedgerStruct.ChannelStatus channelStatus = LedgerStruct.getStandardChannelStatus();
// update counter of old status
if (_c.status != channelStatus.Uninitialized)
{
LedgerStruct.setChannelStatusNums(_c.status, LedgerStruct.getChannelStatusNums(_c.status) - 1);
}
// update counter of new status
LedgerStruct.setChannelStatusNums(_newStatus, LedgerStruct.getChannelStatusNums(_newStatus) + 1);
_c.status = _newStatus;
return(_c);
}
public static bool confirmWithdraw(byte[] _channelId)
{
BasicMethods.assert(BasicMethods._isByte32(_channelId), "_channelId illegal");
LedgerStruct.Channel c = LedgerStruct.getChannelMap(_channelId);
LedgerStruct.WithdrawIntent withdrawIntent = c.withdrawIntent;
byte[] receiver = BasicMethods.clone(withdrawIntent.receiver);
BigInteger amount = withdrawIntent.amount;
byte[] recipientChannelId = BasicMethods.clone(withdrawIntent.recipientChannelId);
withdrawIntent.receiver = null;
withdrawIntent.amount = 0;
withdrawIntent.requestTime = 0;
withdrawIntent.recipientChannelId = null;
c.withdrawIntent = withdrawIntent;
c = LedgerChannel._addWithdrawal(c, receiver, amount);
LedgerStruct.setChannelMap(_channelId, c);
LedgerStruct.BalanceMap balanceMap = LedgerChannel.getBalanceMapInner(c);
ConfirmWithdrawEvent(_channelId, amount, receiver, recipientChannelId, balanceMap.deposits, balanceMap.withdrawals);
return(true);
}
public static byte[] migrateChannelToInner(byte[] sender, LedgerStruct.Ledger _self, byte[][] pubKeys, byte[] _migrationRequest)
{
BasicMethods.assert(BasicMethods._isLegalAddress(sender), "sender illegal");
PbChain.ChannelMigrationRequest migrationRequest =
(PbChain.ChannelMigrationRequest)Neo.SmartContract.Framework.Helper.Deserialize(_migrationRequest);
PbEntity.ChannelMigrationInfo migrationInfo =
(PbEntity.ChannelMigrationInfo)Neo.SmartContract.Framework.Helper.Deserialize(migrationRequest.channelMigrationInfo);
byte[] channelId = migrationInfo.channelId;
BasicMethods.assert(BasicMethods._isByte32(channelId), "channelId illegal");
LedgerStruct.Channel c = LedgerStruct.getChannelMap(channelId);
byte[] toLedgerAddr = migrationInfo.toLedgerAddress;
LedgerStruct.ChannelStatus channelStatus = LedgerStruct.getStandardChannelStatus();
BasicMethods.assert(
c.status == channelStatus.Operable ||
c.status == channelStatus.Settling, "status illegal"
);
byte[] h = Hash256(migrationRequest.channelMigrationInfo);
// use Channel Library instead
BasicMethods.assert(LedgerChannel._checkCoSignatures(c, h, pubKeys, migrationRequest.sigs), "Check co-sigs failed");
BasicMethods.assert(migrationInfo.fromLedgerAddress.Equals(ExecutionEngine.ExecutingScriptHash), "From ledger address is not this");
BasicMethods.assert(toLedgerAddr.Equals(sender), "To ledger address is not msg.sender");
BasicMethods.assert(Blockchain.GetHeight() <= migrationInfo.migrationDeadline, "Passed migration deadline");
c = LedgerOperation._updateChannelStatus(c, channelStatus.Migrated);
c.migratedTo = toLedgerAddr;
LedgerStruct.setChannelMap(channelId, c);
MigrateChannelToEvent(channelId, toLedgerAddr);
byte[] celerWallet = _self.celerWallet;
NEP5Contract dyncall = (NEP5Contract)celerWallet.ToDelegate();
Object[] args = new object[] { channelId, toLedgerAddr };
dyncall("transferOperatorship", args);
return(channelId);
}
public static bool openChannelMockSet(byte[] _channelId, BigInteger _disputeTimeout, byte[] _tokenAddress, byte _tokenType, byte[][] _peerAddrs, BigInteger[] _deposits)
{
BasicMethods.assert(BasicMethods._isByte32(_channelId), "_channelId illegal");
BasicMethods.assert(BasicMethods._isLegalAddress(_tokenAddress), "_channelId illegal");
BasicMethods.assert(_tokenType >= 0 && _tokenType <= 3, "_tokenType illegal");
BasicMethods.assert(_peerAddrs.Length == 2, "_peerAddrs length illegal");
BasicMethods.assert(BasicMethods._isLegalAddress(_peerAddrs[0]), "_peerAddrs 0 illegal");
BasicMethods.assert(BasicMethods._isLegalAddress(_peerAddrs[1]), "_peerAddrs 1 illegal");
BasicMethods.assert(_deposits.Length == 2, "_deposits length illegal");
BasicMethods.assert(_deposits[0] >= 0, "_deposits 0 illegal");
BasicMethods.assert(_deposits[1] >= 0, "_deposits 1 illegal");
setTmpChannelId(_channelId);
LedgerStruct.Channel c = LedgerStruct.getChannelMap(_channelId);
c.disputeTimeout = _disputeTimeout;
LedgerStruct.ChannelStatus channelStatus = LedgerStruct.getStandardChannelStatus();
c = LedgerOperation._updateChannelStatus(c, channelStatus.Operable);
PbEntity.TokenInfo token = new PbEntity.TokenInfo()
{
address = _tokenAddress,
tokenType = _tokenType
};
c.token = token;
LedgerStruct.PeerProfile[] peerProfiles = c.peerProfiles;
LedgerStruct.PeerProfile peerProfile0 = peerProfiles[0];
LedgerStruct.PeerProfile peerProfile1 = peerProfiles[1];
peerProfile0.peerAddr = _peerAddrs[0];
peerProfile0.deposit = _deposits[0];
peerProfile1.peerAddr = _peerAddrs[1];
peerProfile1.deposit = _deposits[1];
peerProfiles[0] = peerProfile0;
peerProfiles[1] = peerProfile1;
c.peerProfiles = peerProfiles;
LedgerStruct.setChannelMap(_channelId, c);
return(true);
}
public static bool vetoWithdraw(byte[] _channelId, byte[] _sender)
{
BasicMethods.assert(BasicMethods._isByte32(_channelId), "_channelId illegal");
BasicMethods.assert(BasicMethods._isLegalAddress(_sender), "_sender illegal");
BasicMethods.assert(Runtime.CheckWitness(_sender), "_sender check witness failed");
LedgerStruct.Channel c = LedgerStruct.getChannelMap(_channelId);
LedgerStruct.ChannelStatus channelStatus = LedgerStruct.getStandardChannelStatus();
BasicMethods.assert(c.status == channelStatus.Operable, "Channel status error");
LedgerStruct.WithdrawIntent withdrawIntent = c.withdrawIntent;
byte[] receiver = withdrawIntent.receiver;
BasicMethods.assert(receiver.ToBigInteger() != 0, "No pending withdraw intent");
BasicMethods.assert(LedgerChannel._isPeer(c, _sender), "msg.sender is not peer");
withdrawIntent.receiver = null;
withdrawIntent.amount = 0;
withdrawIntent.requestTime = 0;
withdrawIntent.recipientChannelId = null;
c.withdrawIntent = withdrawIntent;
LedgerStruct.setChannelMap(_channelId, c);
VetoWithdrawEvent(_channelId);
return(true);
}
public static bool migrateChannelFromInner(LedgerStruct.Ledger _self, byte[] _fromLedgerAddr, byte[] _migrationRequest, byte[][] pubKeys)
{
BasicMethods.assert(BasicMethods._isLegalAddress(_fromLedgerAddr), "_fromLedgerAddr illegal");
// TODO: latest version of openzeppelin Address.sol provide this api toPayable()
byte[] fromLedgerAddrPayable = _fromLedgerAddr;
NEP5Contract dyncall = (NEP5Contract)fromLedgerAddrPayable.ToDelegate();
Object[] args = new object[] { _migrationRequest, pubKeys };
byte[] channelId = (byte[])dyncall("migrateChannelTo", args);
LedgerStruct.Channel c = LedgerStruct.getChannelMap(channelId);
LedgerStruct.ChannelStatus channelStatus = LedgerStruct.getStandardChannelStatus();
BasicMethods.assert(c.status == channelStatus.Uninitialized, "Immigrated channel already exists");
byte[] celerWallet = _self.celerWallet;
args = new object[] { channelId };
dyncall = (NEP5Contract)celerWallet.ToDelegate();
byte[] oper = (byte[])dyncall("getOperator", args);
BasicMethods.assert(
oper.Equals(ExecutionEngine.ExecutingScriptHash),
"Operatorship not transferred"
);
c = LedgerOperation._updateChannelStatus(c, channelStatus.Operable);
// Do not migrate WithdrawIntent, in other words, migration will implicitly veto
// pending WithdrawIntent if any.
c = LedgerChannel._importChannelMigrationArgs(c, fromLedgerAddrPayable, channelId);
c = LedgerChannel._importPeersMigrationInfo(c, fromLedgerAddrPayable, channelId);
LedgerStruct.setChannelMap(channelId, c);
MigrateChannelFromEvent(channelId, _fromLedgerAddr);
return(true);
}
public static bool deposit(byte[] _channelId, byte[] _receiver, BigInteger _transferFromAmount)
{
BasicMethods.assert(BasicMethods._isByte32(_channelId), "_channelId illegal");
BasicMethods.assert(BasicMethods._isLegalAddress(_receiver), "_receiver illegal");
BasicMethods.assert(_transferFromAmount >= 0, "_transferFromAmount illegal");
LedgerStruct.Channel c = LedgerStruct.getChannelMap(_channelId);
byte rid = LedgerChannel._getPeerId(c, _receiver);
BasicMethods.assert(rid == 0 || rid == 1, "rid illegal");
PbEntity.TokenInfo token = c.token;
BigInteger value = LedgerStruct.getTransactionValue(token.tokenType, getCelerWallet());
BigInteger amount = _transferFromAmount + value;
LedgerStruct.PeerProfile[] peerProfiles = c.peerProfiles;
LedgerStruct.PeerProfile peerProfile = peerProfiles[rid];
peerProfile.deposit = peerProfile.deposit + amount;
peerProfiles[rid] = peerProfile;
c.peerProfiles = peerProfiles;
LedgerStruct.BalanceMap balanceMap = LedgerChannel.getBalanceMapInner(c);
LedgerStruct.setChannelMap(_channelId, c);
DepositEvent(_channelId, balanceMap.peerAddrs, balanceMap.deposits, balanceMap.withdrawals);
return(true);
}
public static BigInteger getCooperativeWithdrawSeqNum(byte[] _channelId)
{
BasicMethods.assert(BasicMethods._isByte32(_channelId), "_channelId illegal");
LedgerStruct.Channel c = LedgerStruct.getChannelMap(_channelId);
return(LedgerChannel.getCooperativeWithdrawSeqNumInner(c));
}
public static BigInteger getSettleFinalizedTime(byte[] _channelId)
{
BasicMethods.assert(BasicMethods._isByte32(_channelId), "_channelId illegal");
LedgerStruct.Channel c = LedgerStruct.getChannelMap(_channelId);
return(LedgerChannel.getSettleFinalizedTimeInner(c));
}
private static LedgerStruct.Channel _updateOverallStatesByIntendState(LedgerStruct.Channel c)
{
c.settleFinalizedTime = Blockchain.GetHeight() + c.disputeTimeout;
LedgerStruct.ChannelStatus channelStatus = LedgerStruct.getStandardChannelStatus();
return(_updateChannelStatus(c, channelStatus.Settling));
}
public static LedgerStruct.WithdrawIntent getWithdrawIntent(byte[] _channelId)
{
BasicMethods.assert(BasicMethods._isByte32(_channelId), "_channelId illegal");
LedgerStruct.Channel c = LedgerStruct.getChannelMap(_channelId);
return(LedgerChannel.getWithdrawIntentInner(c));
}
public static BigInteger getChannelStatusNum(BigInteger _channelStatus)
{
return(LedgerStruct.getChannelStatusNums(_channelStatus));
}
public static LedgerStruct.PendingPayOutMap getPendingPayOutMap(byte[] _channelId)
{
BasicMethods.assert(BasicMethods._isByte32(_channelId), "_channelId illegal");
LedgerStruct.Channel c = LedgerStruct.getChannelMap(_channelId);
return(LedgerChannel.getPendingPayOutMapInner(c));
}
public static LedgerStruct.LastPayResolveDeadlineMap getLastPayResolveDeadlineMap(byte[] _channelId)
{
BasicMethods.assert(BasicMethods._isByte32(_channelId), "_channelId illegal");
LedgerStruct.Channel c = LedgerStruct.getChannelMap(_channelId);
return(LedgerChannel.getLastPayResolveDeadlineMapInner(c));
}
public static LedgerStruct.NextPayIdListHashMap getNextPayIdListHashMap(byte[] _channelId)
{
BasicMethods.assert(BasicMethods._isByte32(_channelId), "_channelId illegal");
LedgerStruct.Channel c = LedgerStruct.getChannelMap(_channelId);
return(LedgerChannel.getNextPayIdListHashMapInner(c));
}
public static byte[] getMigratedTo(byte[] _channelId)
{
BasicMethods.assert(BasicMethods._isByte32(_channelId), "_channelId illegal");
LedgerStruct.Channel c = LedgerStruct.getChannelMap(_channelId);
return(LedgerChannel.getMigratedToInner(c));
}
public static BigInteger getDisputeTimeout(byte[] _channelId)
{
BasicMethods.assert(BasicMethods._isByte32(_channelId), "_channelId illegal");
LedgerStruct.Channel c = LedgerStruct.getChannelMap(_channelId);
return(LedgerChannel.getDisputeTimeoutInner(c));
}
