# automatically generated by the FlatBuffers compiler, do not modify

# namespace: xbrmm

import flatbuffers
from flatbuffers.compat import import_numpy

np = import_numpy()


# Data encryption key (off-chain) market transactions.
class Transaction(object):
    __slots__ = ["_tab"]

    @classmethod
    def GetRootAs(cls, buf, offset=0):
        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
        x = Transaction()
        x.Init(buf, n + offset)
        return x

    @classmethod
    def GetRootAsTransaction(cls, buf, offset=0):
        """This method is deprecated. Please switch to GetRootAs."""
        return cls.GetRootAs(buf, offset)

    # Transaction
    def Init(self, buf, pos):
        self._tab = flatbuffers.table.Table(buf, pos)

    # ID of the transaction.
    # Transaction
    def Tid(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

    # Transaction
    def TidAsNumpy(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

    # Transaction
    def TidLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # Transaction
    def TidIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
        return o == 0

    # Creation time of the transaction (epoch time in ns).
    # Transaction
    def Created(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0

    # Sequence number of the created-state transaction within the payment channel.
    # Transaction
    def CreatedPaymentChannelSeq(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 0

    # Sequence number of the created-state transaction within the paying channel.
    # Transaction
    def CreatedPayingChannelSeq(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 0

    # ID of the data encryption key offer this transaction is for.
    # Transaction
    def Offer(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

    # Transaction
    def OfferAsNumpy(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

    # Transaction
    def OfferLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # Transaction
    def OfferIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
        return o == 0

    # Transaction amount in ERC20 tokens of the market coin type.
    # Transaction
    def Amount(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
        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

    # Transaction
    def AmountAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
        if o != 0:
            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
        return 0

    # Transaction
    def AmountLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # Transaction
    def AmountIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
        return o == 0

    # OID of the channel (of the buyer) this transaction is transacting on.
    # Transaction
    def PaymentChannel(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
        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

    # Transaction
    def PaymentChannelAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
        if o != 0:
            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
        return 0

    # Transaction
    def PaymentChannelLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # Transaction
    def PaymentChannelIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
        return o == 0

    # OID of the channel (of the seller) this transaction is transacting on.
    # Transaction
    def PayingChannel(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

    # Transaction
    def PayingChannelAsNumpy(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

    # Transaction
    def PayingChannelLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # Transaction
    def PayingChannelIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
        return o == 0

    # State of the transaction: TransactionState.INFLIGHT when created, and then either TransactionState.SUCCESS or TransactionState.FAILED.
    # Transaction
    def State(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
        return 0

    # Completion time of the transaction (epoch time in ns)
    # Transaction
    def Completed(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0

    # Sequence number of the completed-state transaction within the payment channel.
    # Transaction
    def CompletedPaymentChannelSeq(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 0

    # Sequence number of the completed-state transaction within the paying channel.
    # Transaction
    def CompletedPayingChannelSeq(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 0

    # ID of the data encryption key sold under the transaction.
    # Transaction
    def Key(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
        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

    # Transaction
    def KeyAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
        if o != 0:
            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
        return 0

    # Transaction
    def KeyLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # Transaction
    def KeyIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
        return o == 0

    # Buyer public key (Ed25519).
    # Transaction
    def BuyerPubkey(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
        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

    # Transaction
    def BuyerPubkeyAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
        if o != 0:
            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
        return 0

    # Transaction
    def BuyerPubkeyLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # Transaction
    def BuyerPubkeyIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
        return o == 0

    # Payment channel balance after transaction.
    # Transaction
    def PaymentChannelAfter(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

    # Transaction
    def PaymentChannelAfterAsNumpy(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

    # Transaction
    def PaymentChannelAfterLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # Transaction
    def PaymentChannelAfterIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
        return o == 0

    # Payment channel balance after transaction.
    # Transaction
    def PayingChannelAfter(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

    # Transaction
    def PayingChannelAfterAsNumpy(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

    # Transaction
    def PayingChannelAfterLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # Transaction
    def PayingChannelAfterIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
        return o == 0

    # Payment channel market maker transaction signature.
    # Transaction
    def PaymentMmSig(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

    # Transaction
    def PaymentMmSigAsNumpy(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

    # Transaction
    def PaymentMmSigLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # Transaction
    def PaymentMmSigIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
        return o == 0

    # Payment channel (buyer) delegate transaction signature.
    # Transaction
    def PaymentDelSig(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

    # Transaction
    def PaymentDelSigAsNumpy(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

    # Transaction
    def PaymentDelSigLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # Transaction
    def PaymentDelSigIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
        return o == 0

    # Paying channel market maker transaction signature.
    # Transaction
    def PayingMmSig(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
        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

    # Transaction
    def PayingMmSigAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
        if o != 0:
            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
        return 0

    # Transaction
    def PayingMmSigLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # Transaction
    def PayingMmSigIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
        return o == 0

    # Paying channel (seller) delegate transaction signature.
    # Transaction
    def PayingDelSig(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

    # Transaction
    def PayingDelSigAsNumpy(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

    # Transaction
    def PayingDelSigLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # Transaction
    def PayingDelSigIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
        return o == 0


def TransactionStart(builder):
    builder.StartObject(20)


def Start(builder):
    TransactionStart(builder)


def TransactionAddTid(builder, tid):
    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(tid), 0)


def AddTid(builder, tid):
    TransactionAddTid(builder, tid)


def TransactionStartTidVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)


def StartTidVector(builder, numElems: int) -> int:
    return TransactionStartTidVector(builder, numElems)


def TransactionAddCreated(builder, created):
    builder.PrependUint64Slot(1, created, 0)


def AddCreated(builder, created):
    TransactionAddCreated(builder, created)


def TransactionAddCreatedPaymentChannelSeq(builder, createdPaymentChannelSeq):
    builder.PrependUint32Slot(2, createdPaymentChannelSeq, 0)


def AddCreatedPaymentChannelSeq(builder, createdPaymentChannelSeq):
    TransactionAddCreatedPaymentChannelSeq(builder, createdPaymentChannelSeq)


def TransactionAddCreatedPayingChannelSeq(builder, createdPayingChannelSeq):
    builder.PrependUint32Slot(3, createdPayingChannelSeq, 0)


def AddCreatedPayingChannelSeq(builder, createdPayingChannelSeq):
    TransactionAddCreatedPayingChannelSeq(builder, createdPayingChannelSeq)


def TransactionAddOffer(builder, offer):
    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(offer), 0)


def AddOffer(builder, offer):
    TransactionAddOffer(builder, offer)


def TransactionStartOfferVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)


def StartOfferVector(builder, numElems: int) -> int:
    return TransactionStartOfferVector(builder, numElems)


def TransactionAddAmount(builder, amount):
    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(amount), 0)


def AddAmount(builder, amount):
    TransactionAddAmount(builder, amount)


def TransactionStartAmountVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)


def StartAmountVector(builder, numElems: int) -> int:
    return TransactionStartAmountVector(builder, numElems)


def TransactionAddPaymentChannel(builder, paymentChannel):
    builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(paymentChannel), 0)


def AddPaymentChannel(builder, paymentChannel):
    TransactionAddPaymentChannel(builder, paymentChannel)


def TransactionStartPaymentChannelVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)


def StartPaymentChannelVector(builder, numElems: int) -> int:
    return TransactionStartPaymentChannelVector(builder, numElems)


def TransactionAddPayingChannel(builder, payingChannel):
    builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(payingChannel), 0)


def AddPayingChannel(builder, payingChannel):
    TransactionAddPayingChannel(builder, payingChannel)


def TransactionStartPayingChannelVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)


def StartPayingChannelVector(builder, numElems: int) -> int:
    return TransactionStartPayingChannelVector(builder, numElems)


def TransactionAddState(builder, state):
    builder.PrependUint8Slot(8, state, 0)


def AddState(builder, state):
    TransactionAddState(builder, state)


def TransactionAddCompleted(builder, completed):
    builder.PrependUint64Slot(9, completed, 0)


def AddCompleted(builder, completed):
    TransactionAddCompleted(builder, completed)


def TransactionAddCompletedPaymentChannelSeq(builder, completedPaymentChannelSeq):
    builder.PrependUint32Slot(10, completedPaymentChannelSeq, 0)


def AddCompletedPaymentChannelSeq(builder, completedPaymentChannelSeq):
    TransactionAddCompletedPaymentChannelSeq(builder, completedPaymentChannelSeq)


def TransactionAddCompletedPayingChannelSeq(builder, completedPayingChannelSeq):
    builder.PrependUint32Slot(11, completedPayingChannelSeq, 0)


def AddCompletedPayingChannelSeq(builder, completedPayingChannelSeq):
    TransactionAddCompletedPayingChannelSeq(builder, completedPayingChannelSeq)


def TransactionAddKey(builder, key):
    builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(key), 0)


def AddKey(builder, key):
    TransactionAddKey(builder, key)


def TransactionStartKeyVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)


def StartKeyVector(builder, numElems: int) -> int:
    return TransactionStartKeyVector(builder, numElems)


def TransactionAddBuyerPubkey(builder, buyerPubkey):
    builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(buyerPubkey), 0)


def AddBuyerPubkey(builder, buyerPubkey):
    TransactionAddBuyerPubkey(builder, buyerPubkey)


def TransactionStartBuyerPubkeyVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)


def StartBuyerPubkeyVector(builder, numElems: int) -> int:
    return TransactionStartBuyerPubkeyVector(builder, numElems)


def TransactionAddPaymentChannelAfter(builder, paymentChannelAfter):
    builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(paymentChannelAfter), 0)


def AddPaymentChannelAfter(builder, paymentChannelAfter):
    TransactionAddPaymentChannelAfter(builder, paymentChannelAfter)


def TransactionStartPaymentChannelAfterVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)


def StartPaymentChannelAfterVector(builder, numElems: int) -> int:
    return TransactionStartPaymentChannelAfterVector(builder, numElems)


def TransactionAddPayingChannelAfter(builder, payingChannelAfter):
    builder.PrependUOffsetTRelativeSlot(15, flatbuffers.number_types.UOffsetTFlags.py_type(payingChannelAfter), 0)


def AddPayingChannelAfter(builder, payingChannelAfter):
    TransactionAddPayingChannelAfter(builder, payingChannelAfter)


def TransactionStartPayingChannelAfterVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)


def StartPayingChannelAfterVector(builder, numElems: int) -> int:
    return TransactionStartPayingChannelAfterVector(builder, numElems)


def TransactionAddPaymentMmSig(builder, paymentMmSig):
    builder.PrependUOffsetTRelativeSlot(16, flatbuffers.number_types.UOffsetTFlags.py_type(paymentMmSig), 0)


def AddPaymentMmSig(builder, paymentMmSig):
    TransactionAddPaymentMmSig(builder, paymentMmSig)


def TransactionStartPaymentMmSigVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)


def StartPaymentMmSigVector(builder, numElems: int) -> int:
    return TransactionStartPaymentMmSigVector(builder, numElems)


def TransactionAddPaymentDelSig(builder, paymentDelSig):
    builder.PrependUOffsetTRelativeSlot(17, flatbuffers.number_types.UOffsetTFlags.py_type(paymentDelSig), 0)


def AddPaymentDelSig(builder, paymentDelSig):
    TransactionAddPaymentDelSig(builder, paymentDelSig)


def TransactionStartPaymentDelSigVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)


def StartPaymentDelSigVector(builder, numElems: int) -> int:
    return TransactionStartPaymentDelSigVector(builder, numElems)


def TransactionAddPayingMmSig(builder, payingMmSig):
    builder.PrependUOffsetTRelativeSlot(18, flatbuffers.number_types.UOffsetTFlags.py_type(payingMmSig), 0)


def AddPayingMmSig(builder, payingMmSig):
    TransactionAddPayingMmSig(builder, payingMmSig)


def TransactionStartPayingMmSigVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)


def StartPayingMmSigVector(builder, numElems: int) -> int:
    return TransactionStartPayingMmSigVector(builder, numElems)


def TransactionAddPayingDelSig(builder, payingDelSig):
    builder.PrependUOffsetTRelativeSlot(19, flatbuffers.number_types.UOffsetTFlags.py_type(payingDelSig), 0)


def AddPayingDelSig(builder, payingDelSig):
    TransactionAddPayingDelSig(builder, payingDelSig)


def TransactionStartPayingDelSigVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)


def StartPayingDelSigVector(builder, numElems: int) -> int:
    return TransactionStartPayingDelSigVector(builder, numElems)


def TransactionEnd(builder):
    return builder.EndObject()


def End(builder):
    return TransactionEnd(builder)
