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); }
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 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); }
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 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 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 LedgerStruct.WithdrawIntent getWithdrawIntent(byte[] _channelId) { BasicMethods.assert(BasicMethods._isByte32(_channelId), "_channelId illegal"); LedgerStruct.Channel c = LedgerStruct.getChannelMap(_channelId); return(LedgerChannel.getWithdrawIntentInner(c)); }
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)); }
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)); }