Source code for cfxdb.gen.xbrmm.Channel

# automatically generated by the FlatBuffers compiler, do not modify

# namespace: xbrmm

import flatbuffers
from flatbuffers.compat import import_numpy


[docs]
np = import_numpy()



# XBR channel (from XBR consumer to XBR market maker) and XBR paying channels (from XBR market maker to XBR provider).

[docs]
class Channel(object):

[docs]
    __slots__ = ["_tab"]


    @classmethod

[docs]
    def GetRootAs(cls, buf, offset=0):
        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
        x = Channel()
        x.Init(buf, n + offset)
        return x


    @classmethod

[docs]
    def GetRootAsChannel(cls, buf, offset=0):
        """This method is deprecated. Please switch to GetRootAs."""
        return cls.GetRootAs(buf, offset)


    # Channel

[docs]
    def Init(self, buf, pos):
        self._tab = flatbuffers.table.Table(buf, pos)


    # OID of the market this payment channel is associated with.
    # Channel

[docs]
    def MarketOid(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(
                flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)
            )
        return 0


    # Channel

[docs]
    def MarketOidAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
        if o != 0:
            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
        return 0


    # Channel

[docs]
    def MarketOidLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0


    # Channel

[docs]
    def MarketOidIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
        return o == 0


    # OID of the buyer or seller actor in the market (a XBR network member) this channel is associated with.
    # Channel

[docs]
    def MemberOid(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(
                flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)
            )
        return 0


    # Channel

[docs]
    def MemberOidAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
        if o != 0:
            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
        return 0


    # Channel

[docs]
    def MemberOidLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0


    # Channel

[docs]
    def MemberOidIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
        return o == 0


    # OID of the channel.
    # Channel

[docs]
    def ChannelOid(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(
                flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)
            )
        return 0


    # Channel

[docs]
    def ChannelOidAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
        if o != 0:
            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
        return 0


    # Channel

[docs]
    def ChannelOidLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0


    # Channel

[docs]
    def ChannelOidIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
        return o == 0


    # Database transaction time (epoch time in ns).
    # Channel

[docs]
    def Timestamp(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0


    # Block number (on the blockchain) when the channel was opened.
    # Channel

[docs]
    def OpenAt(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(
                flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)
            )
        return 0


    # Channel

[docs]
    def OpenAtAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
        if o != 0:
            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
        return 0


    # Channel

[docs]
    def OpenAtLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0


    # Channel

[docs]
    def OpenAtIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
        return o == 0


    # Channel sequence number.
    # Channel

[docs]
    def Seq(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 0


    # Channel type: payment channel (from XBR consumer to XBR market maker) or paying channel (from XBR market maker to XBR provider).
    # Channel

[docs]
    def ChannelType(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
        return 0


    # Ethereum address of the sender delegate (either XBR Consumer delegate or XBR Market delegate == market maker)
    # Channel

[docs]
    def Marketmaker(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(
                flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)
            )
        return 0


    # Channel

[docs]
    def MarketmakerAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
        if o != 0:
            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
        return 0


    # Channel

[docs]
    def MarketmakerLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0


    # Channel

[docs]
    def MarketmakerIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
        return o == 0


    # Ethereum address of the sender (either XBR Consumer or XBR Market).
    # Channel

[docs]
    def Actor(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(
                flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)
            )
        return 0


    # Channel

[docs]
    def ActorAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
        if o != 0:
            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
        return 0


    # Channel

[docs]
    def ActorLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0


    # Channel

[docs]
    def ActorIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
        return o == 0


    # Ethereum address of the sender delegate (either XBR Consumer delegate or XBR Market delegate == market maker)
    # Channel

[docs]
    def Delegate(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(
                flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)
            )
        return 0


    # Channel

[docs]
    def DelegateAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
        if o != 0:
            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
        return 0


    # Channel

[docs]
    def DelegateLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0


    # Channel

[docs]
    def DelegateIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
        return o == 0


    # Ethereum address of the recipient (either XBR Market or XBR Provider)
    # Channel

[docs]
    def Recipient(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(
                flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)
            )
        return 0


    # Channel

[docs]
    def RecipientAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
        if o != 0:
            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
        return 0


    # Channel

[docs]
    def RecipientLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0


    # Channel

[docs]
    def RecipientIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
        return o == 0


    # Amount of XBR tokens initially deposited into the channel.
    # Channel

[docs]
    def Amount(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(
                flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)
            )
        return 0


    # Channel

[docs]
    def AmountAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
        if o != 0:
            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
        return 0


    # Channel

[docs]
    def AmountLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0


    # Channel

[docs]
    def AmountIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
        return o == 0


    # Channel (non-cooperative) close timeout in blocks (committed on the blockchain).
    # Channel

[docs]
    def Timeout(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 0


    # Current state of channel.
    # Channel

[docs]
    def State(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
        return 0


    # Block number (on the blockchain) when the channel will close (at the latest).
    # Channel

[docs]
    def ClosingAt(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(
                flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)
            )
        return 0


    # Channel

[docs]
    def ClosingAtAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
        if o != 0:
            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
        return 0


    # Channel

[docs]
    def ClosingAtLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0


    # Channel

[docs]
    def ClosingAtIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
        return o == 0


    # Block number (on the blockchain) when the channel was finally closed on-chain.
    # Channel

[docs]
    def ClosedAt(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(
                flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)
            )
        return 0


    # Channel

[docs]
    def ClosedAtAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
        if o != 0:
            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
        return 0


    # Channel

[docs]
    def ClosedAtLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0


    # Channel

[docs]
    def ClosedAtIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
        return o == 0


    # Closing signature by market maker.
    # Channel

[docs]
    def CloseMmSig(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(
                flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)
            )
        return 0


    # Channel

[docs]
    def CloseMmSigAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
        if o != 0:
            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
        return 0


    # Channel

[docs]
    def CloseMmSigLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0


    # Channel

[docs]
    def CloseMmSigIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
        return o == 0


    # Closing signature by (seller or buyer) delegate.
    # Channel

[docs]
    def CloseDelSig(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(
                flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)
            )
        return 0


    # Channel

[docs]
    def CloseDelSigAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
        if o != 0:
            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
        return 0


    # Channel

[docs]
    def CloseDelSigLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0


    # Channel

[docs]
    def CloseDelSigIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
        return o == 0


    # Last off-chain, closing transaction: channel transaction sequence number.
    # Channel

[docs]
    def CloseChannelSeq(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 0


    # Remaining (closing) channel balance (XBR).
    # Channel

[docs]
    def CloseBalance(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(
                flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)
            )
        return 0


    # Channel

[docs]
    def CloseBalanceAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
        if o != 0:
            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
        return 0


    # Channel

[docs]
    def CloseBalanceLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0


    # Channel

[docs]
    def CloseBalanceIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
        return o == 0


    # Flag indication if close is final (happens immediately without a channel timeout).
    # Channel

[docs]
    def CloseIsFinal(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(44))
        if o != 0:
            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
        return False


    # When channel was finally closed on-chain, the Ethereum transaction ID.
    # Channel

[docs]
    def ClosedTx(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(
                flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)
            )
        return 0


    # Channel

[docs]
    def ClosedTxAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
        if o != 0:
            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
        return 0


    # Channel

[docs]
    def ClosedTxLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0


    # Channel

[docs]
    def ClosedTxIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
        return o == 0





[docs]
def ChannelStart(builder):
    builder.StartObject(22)




[docs]
def Start(builder):
    ChannelStart(builder)




[docs]
def ChannelAddMarketOid(builder, marketOid):
    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(marketOid), 0)




[docs]
def AddMarketOid(builder, marketOid):
    ChannelAddMarketOid(builder, marketOid)




[docs]
def ChannelStartMarketOidVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)




[docs]
def StartMarketOidVector(builder, numElems: int) -> int:
    return ChannelStartMarketOidVector(builder, numElems)




[docs]
def ChannelAddMemberOid(builder, memberOid):
    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(memberOid), 0)




[docs]
def AddMemberOid(builder, memberOid):
    ChannelAddMemberOid(builder, memberOid)




[docs]
def ChannelStartMemberOidVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)




[docs]
def StartMemberOidVector(builder, numElems: int) -> int:
    return ChannelStartMemberOidVector(builder, numElems)




[docs]
def ChannelAddChannelOid(builder, channelOid):
    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(channelOid), 0)




[docs]
def AddChannelOid(builder, channelOid):
    ChannelAddChannelOid(builder, channelOid)




[docs]
def ChannelStartChannelOidVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)




[docs]
def StartChannelOidVector(builder, numElems: int) -> int:
    return ChannelStartChannelOidVector(builder, numElems)




[docs]
def ChannelAddTimestamp(builder, timestamp):
    builder.PrependUint64Slot(3, timestamp, 0)




[docs]
def AddTimestamp(builder, timestamp):
    ChannelAddTimestamp(builder, timestamp)




[docs]
def ChannelAddOpenAt(builder, openAt):
    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(openAt), 0)




[docs]
def AddOpenAt(builder, openAt):
    ChannelAddOpenAt(builder, openAt)




[docs]
def ChannelStartOpenAtVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)




[docs]
def StartOpenAtVector(builder, numElems: int) -> int:
    return ChannelStartOpenAtVector(builder, numElems)




[docs]
def ChannelAddSeq(builder, seq):
    builder.PrependUint32Slot(5, seq, 0)




[docs]
def AddSeq(builder, seq):
    ChannelAddSeq(builder, seq)




[docs]
def ChannelAddChannelType(builder, channelType):
    builder.PrependUint8Slot(6, channelType, 0)




[docs]
def AddChannelType(builder, channelType):
    ChannelAddChannelType(builder, channelType)




[docs]
def ChannelAddMarketmaker(builder, marketmaker):
    builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(marketmaker), 0)




[docs]
def AddMarketmaker(builder, marketmaker):
    ChannelAddMarketmaker(builder, marketmaker)




[docs]
def ChannelStartMarketmakerVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)




[docs]
def StartMarketmakerVector(builder, numElems: int) -> int:
    return ChannelStartMarketmakerVector(builder, numElems)




[docs]
def ChannelAddActor(builder, actor):
    builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(actor), 0)




[docs]
def AddActor(builder, actor):
    ChannelAddActor(builder, actor)




[docs]
def ChannelStartActorVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)




[docs]
def StartActorVector(builder, numElems: int) -> int:
    return ChannelStartActorVector(builder, numElems)




[docs]
def ChannelAddDelegate(builder, delegate):
    builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(delegate), 0)




[docs]
def AddDelegate(builder, delegate):
    ChannelAddDelegate(builder, delegate)




[docs]
def ChannelStartDelegateVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)




[docs]
def StartDelegateVector(builder, numElems: int) -> int:
    return ChannelStartDelegateVector(builder, numElems)




[docs]
def ChannelAddRecipient(builder, recipient):
    builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(recipient), 0)




[docs]
def AddRecipient(builder, recipient):
    ChannelAddRecipient(builder, recipient)




[docs]
def ChannelStartRecipientVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)




[docs]
def StartRecipientVector(builder, numElems: int) -> int:
    return ChannelStartRecipientVector(builder, numElems)




[docs]
def ChannelAddAmount(builder, amount):
    builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(amount), 0)




[docs]
def AddAmount(builder, amount):
    ChannelAddAmount(builder, amount)




[docs]
def ChannelStartAmountVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)




[docs]
def StartAmountVector(builder, numElems: int) -> int:
    return ChannelStartAmountVector(builder, numElems)




[docs]
def ChannelAddTimeout(builder, timeout):
    builder.PrependUint32Slot(12, timeout, 0)




[docs]
def AddTimeout(builder, timeout):
    ChannelAddTimeout(builder, timeout)




[docs]
def ChannelAddState(builder, state):
    builder.PrependUint8Slot(13, state, 0)




[docs]
def AddState(builder, state):
    ChannelAddState(builder, state)




[docs]
def ChannelAddClosingAt(builder, closingAt):
    builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(closingAt), 0)




[docs]
def AddClosingAt(builder, closingAt):
    ChannelAddClosingAt(builder, closingAt)




[docs]
def ChannelStartClosingAtVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)




[docs]
def StartClosingAtVector(builder, numElems: int) -> int:
    return ChannelStartClosingAtVector(builder, numElems)




[docs]
def ChannelAddClosedAt(builder, closedAt):
    builder.PrependUOffsetTRelativeSlot(15, flatbuffers.number_types.UOffsetTFlags.py_type(closedAt), 0)




[docs]
def AddClosedAt(builder, closedAt):
    ChannelAddClosedAt(builder, closedAt)




[docs]
def ChannelStartClosedAtVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)




[docs]
def StartClosedAtVector(builder, numElems: int) -> int:
    return ChannelStartClosedAtVector(builder, numElems)




[docs]
def ChannelAddCloseMmSig(builder, closeMmSig):
    builder.PrependUOffsetTRelativeSlot(16, flatbuffers.number_types.UOffsetTFlags.py_type(closeMmSig), 0)




[docs]
def AddCloseMmSig(builder, closeMmSig):
    ChannelAddCloseMmSig(builder, closeMmSig)




[docs]
def ChannelStartCloseMmSigVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)




[docs]
def StartCloseMmSigVector(builder, numElems: int) -> int:
    return ChannelStartCloseMmSigVector(builder, numElems)




[docs]
def ChannelAddCloseDelSig(builder, closeDelSig):
    builder.PrependUOffsetTRelativeSlot(17, flatbuffers.number_types.UOffsetTFlags.py_type(closeDelSig), 0)




[docs]
def AddCloseDelSig(builder, closeDelSig):
    ChannelAddCloseDelSig(builder, closeDelSig)




[docs]
def ChannelStartCloseDelSigVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)




[docs]
def StartCloseDelSigVector(builder, numElems: int) -> int:
    return ChannelStartCloseDelSigVector(builder, numElems)




[docs]
def ChannelAddCloseChannelSeq(builder, closeChannelSeq):
    builder.PrependUint32Slot(18, closeChannelSeq, 0)




[docs]
def AddCloseChannelSeq(builder, closeChannelSeq):
    ChannelAddCloseChannelSeq(builder, closeChannelSeq)




[docs]
def ChannelAddCloseBalance(builder, closeBalance):
    builder.PrependUOffsetTRelativeSlot(19, flatbuffers.number_types.UOffsetTFlags.py_type(closeBalance), 0)




[docs]
def AddCloseBalance(builder, closeBalance):
    ChannelAddCloseBalance(builder, closeBalance)




[docs]
def ChannelStartCloseBalanceVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)




[docs]
def StartCloseBalanceVector(builder, numElems: int) -> int:
    return ChannelStartCloseBalanceVector(builder, numElems)




[docs]
def ChannelAddCloseIsFinal(builder, closeIsFinal):
    builder.PrependBoolSlot(20, closeIsFinal, 0)




[docs]
def AddCloseIsFinal(builder, closeIsFinal):
    ChannelAddCloseIsFinal(builder, closeIsFinal)




[docs]
def ChannelAddClosedTx(builder, closedTx):
    builder.PrependUOffsetTRelativeSlot(21, flatbuffers.number_types.UOffsetTFlags.py_type(closedTx), 0)




[docs]
def AddClosedTx(builder, closedTx):
    ChannelAddClosedTx(builder, closedTx)




[docs]
def ChannelStartClosedTxVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)




[docs]
def StartClosedTxVector(builder, numElems: int) -> int:
    return ChannelStartClosedTxVector(builder, numElems)




[docs]
def ChannelEnd(builder):
    return builder.EndObject()




[docs]
def End(builder):
    return ChannelEnd(builder)