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 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 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);
    }