def marshal(self) -> dict:
obj = {
'market_oid': self.market_oid.bytes if self.market_oid else None,
'member_oid': self.member_oid.bytes if self.member_oid else None,
'channel_oid': self.channel_oid.bytes if self.channel_oid else None,
'timestamp': int(self.timestamp) if self.timestamp else None,
'open_at': pack_uint256(self.open_at) if self.open_at else None,
'seq': self.seq,
'channel_type': self.channel_type,
'marketmaker': bytes(self.marketmaker) if self.marketmaker else None,
'actor': bytes(self.actor) if self.actor else None,
'delegate': bytes(self.delegate) if self.delegate else None,
'recipient': bytes(self.recipient) if self.recipient else None,
'amount': pack_uint256(self.amount) if self.amount else 0,
'timeout': self.timeout,
'state': self.state,
'closing_at': pack_uint256(self.closing_at) if self.closing_at else None,
'closed_at': pack_uint256(self.closed_at) if self.closed_at else None,
'close_mm_sig': bytes(self.close_mm_sig) if self.close_mm_sig else None,
'close_del_sig': bytes(self.close_del_sig) if self.close_del_sig else None,
'close_channel_seq': self.close_channel_seq,
'close_balance': self.close_balance,
'close_is_final': self.close_is_final,
'closed_tx': bytes(self.closed_tx) if self.closed_tx else None,
}
return obj
def marshal(self):
obj = {
'tid': str(self.tid) if self.tid else None,
'created': self.created,
'created_payment_channel_seq': self._created_payment_channel_seq,
'created_paying_channel_seq': self._created_paying_channel_seq,
'offer': str(self.offer) if self.offer else None,
'amount': pack_uint256(self.amount) if self.amount else 0,
'payment_channel': self.payment_channel.bytes if self.payment_channel else None,
'paying_channel': self.paying_channel.bytes if self.paying_channel else None,
'state': self.state,
'completed': self.completed,
'completed_payment_channel_seq': self._completed_payment_channel_seq,
'completed_paying_channel_seq': self._completed_paying_channel_seq,
'key': self.key.bytes if self.key else None,
'buyer_pubkey': self.buyer_pubkey,
'payment_channel_after':
pack_uint256(self.payment_channel_after) if self.payment_channel_after else None,
'paying_channel_after':
pack_uint256(self.paying_channel_after) if self.paying_channel_after else None,
'payment_mm_sig': self.payment_mm_sig,
'payment_del_sig': self.payment_del_sig,
'paying_mm_sig': self.paying_mm_sig,
'paying_del_sig': self.paying_del_sig,
}
return obj
def marshal(self) -> dict:
obj = {
'remaining': pack_uint256(self.remaining) if self.remaining else 0,
'inflight': pack_uint256(self.inflight) if self.inflight else 0,
'seq': self.seq or 0
}
return obj
def marshal(self) -> dict:
obj = {
'market':
self.market.bytes if self.market else None,
'timestamp':
int(self.timestamp) if self.timestamp else None,
'created':
pack_uint256(self.created) if self.created else None,
'seq':
self.seq,
'owner':
bytes(self.owner) if self.owner else None,
'coin':
bytes(self.coin) if self.coin else None,
'terms':
self.terms,
'meta':
self.meta,
'maker':
bytes(self.maker) if self.maker else None,
'provider_security':
pack_uint256(self.provider_security)
if self.provider_security else None,
'consumer_security':
pack_uint256(self.consumer_security)
if self.consumer_security else None,
'market_fee':
pack_uint256(self.market_fee) if self.market_fee else None,
'tid':
bytes(self.tid) if self.tid else None,
'signature':
bytes(self.signature) if self.signature else None,
}
return obj
def marshal(self):
obj = {
'timestamp': int(self.timestamp) if self.timestamp else None,
'market': self.market.bytes if self.market else None,
'actor': bytes(self.actor) if self.actor else None,
'actor_type': self.actor_type,
'joined': pack_uint256(self.joined) if self.joined else None,
'security': pack_uint256(self.security) if self.security else None,
'meta': bytes(self.meta) if self.meta else None,
'tid': bytes(self.tid) if self.tid else None,
'signature': bytes(self.signature) if self.signature else None,
}
return obj
def build(self, builder):
block_number = self.block_number
if block_number:
block_number = builder.CreateString(pack_uint256(block_number))
block_hash = self.block_hash
if block_hash:
block_hash = builder.CreateString(block_hash)
BlockGen.BlockStart(builder)
if self.timestamp:
BlockGen.BlockAddTimestamp(builder, int(self.timestamp))
if block_number:
BlockGen.BlockAddBlockNumber(builder, block_number)
if block_hash:
BlockGen.BlockAddBlockHash(builder, block_hash)
if self.cnt_events:
BlockGen.BlockAddCntEvents(builder, self.cnt_events)
final = BlockGen.BlockEnd(builder)
return final
def build(self, builder):
oid = self.oid.bytes if self.oid else None
if oid:
oid = builder.CreateString(oid)
catalog_oid = self.catalog_oid.bytes if self.catalog_oid else None
if catalog_oid:
catalog_oid = builder.CreateString(catalog_oid)
published = self.published
if published:
published = builder.CreateString(pack_uint256(published))
schema = self.schema
if schema:
schema = builder.CreateString(schema)
meta = self.meta
if meta:
meta = builder.CreateString(meta)
tid = self.tid
if tid:
tid = builder.CreateString(tid)
signature = self.signature
if signature:
signature = builder.CreateString(signature)
ApiGen.ApiStart(builder)
if oid:
ApiGen.ApiAddOid(builder, oid)
if catalog_oid:
ApiGen.ApiAddCatalogOid(builder, catalog_oid)
if self.timestamp:
ApiGen.ApiAddTimestamp(builder, int(self.timestamp))
if published:
ApiGen.ApiAddPublished(builder, published)
if schema:
ApiGen.ApiAddSchema(builder, schema)
if meta:
ApiGen.ApiAddMeta(builder, meta)
if tid:
ApiGen.ApiAddTid(builder, tid)
if signature:
ApiGen.ApiAddSignature(builder, signature)
final = ApiGen.ApiEnd(builder)
return final
def marshal(self) -> dict:
obj = {
'timestamp':
int(self.timestamp) if self.timestamp else None,
'block_number':
pack_uint256(self.block_number) if self.block_number else 0,
'block_hash':
bytes(self.block_hash) if self.block_hash else None,
'cnt_events':
self.cnt_events,
}
return obj
def marshal(self) -> dict:
obj = {
'oid': self.oid.bytes if self.oid else None,
'catalog_oid': self.catalog_oid.bytes if self.catalog_oid else None,
'timestamp': int(self.timestamp) if self.timestamp else None,
'published': pack_uint256(self.published) if self.published else None,
'schema': self.schema,
'meta': self.meta,
'tid': bytes(self.tid) if self.tid else None,
'signature': bytes(self.signature) if self.signature else None,
}
return obj
def build(self, builder):
remaining = self.remaining
if remaining:
remaining = builder.CreateString(pack_uint256(remaining))
inflight = self.inflight
if inflight:
inflight = builder.CreateString(pack_uint256(inflight))
ChannelBalanceGen.ChannelBalanceStart(builder)
if remaining:
ChannelBalanceGen.ChannelBalanceAddRemaining(builder, remaining)
if inflight:
ChannelBalanceGen.ChannelBalanceAddInflight(builder, inflight)
if self.seq:
ChannelBalanceGen.ChannelBalanceAddSeq(builder, self.seq)
final = ChannelBalanceGen.ChannelBalanceEnd(builder)
return final
def marshal(self) -> dict:
obj = {
'market_oid': self.market_oid.bytes if self.market_oid else None,
'member': bytes(self.member) if self.member else None,
'delegate': bytes(self.delegate) if self.delegate else None,
'delegate_type': int(self.delegate_type) if self.delegate_type else None,
'catalog_oid': self.catalog_oid.bytes if self.catalog_oid else None,
'timestamp': int(self.timestamp) if self.timestamp else None,
'updated': pack_uint256(self.updated) if self.updated else None,
'consent': self.consent,
'service_prefix': self.service_prefix if self.service_prefix else None,
'tid': bytes(self.tid) if self.tid else None,
'signature': bytes(self.signature) if self.signature else None,
'synced': self.synced,
}
return obj
def marshal(self) -> dict:
obj = {
'timestamp': int(self.timestamp) if self.timestamp else None,
'offer': self.offer.bytes if self.offer else None,
'seller': bytes(self.seller) if self.seller else None,
'seller_session_id': self.seller_session_id,
'seller_authid': self.seller_authid,
'key': self.key.bytes if self.key else None,
'api': self.api.bytes if self.api else None,
'uri': self.uri,
'valid_from': int(self.valid_from) if self.valid_from else None,
'signature': bytes(self.signature) if self.signature else None,
'price': pack_uint256(self.price) if self.price else 0,
'categories': self.categories,
'expires': int(self.expires) if self.expires else None,
'copies': self.copies,
'remaining': self.remaining,
}
return obj
def build(self, builder):
tx_hash = self.tx_hash
if tx_hash:
tx_hash = builder.CreateString(tx_hash)
block_hash = self.block_hash
if block_hash:
block_hash = builder.CreateString(block_hash)
from_address = self.from_address
if from_address:
from_address = builder.CreateString(from_address)
to_address = self.to_address
if to_address:
to_address = builder.CreateString(to_address)
value = self.value
if value:
value = builder.CreateString(pack_uint256(value))
TokenTransferGen.TokenTransferStart(builder)
if tx_hash:
TokenTransferGen.TokenTransferAddTxHash(builder, tx_hash)
if block_hash:
TokenTransferGen.TokenTransferAddBlockHash(builder, block_hash)
if from_address:
TokenTransferGen.TokenTransferAddFromAddress(builder, from_address)
if to_address:
TokenTransferGen.TokenTransferAddToAddress(builder, to_address)
if value:
TokenTransferGen.TokenTransferAddValue(builder, value)
final = TokenTransferGen.TokenTransferEnd(builder)
return final
def build(self, builder):
tx_hash = self.tx_hash
if tx_hash:
tx_hash = builder.CreateString(tx_hash)
block_hash = self.block_hash
if block_hash:
block_hash = builder.CreateString(block_hash)
owner_address = self.owner_address
if owner_address:
owner_address = builder.CreateString(owner_address)
spender_address = self.spender_address
if spender_address:
spender_address = builder.CreateString(spender_address)
value = self.value
if value:
value = builder.CreateString(pack_uint256(value))
TokenApprovalGen.TokenApprovalStart(builder)
if tx_hash:
TokenApprovalGen.TokenApprovalAddTxHash(builder, tx_hash)
if block_hash:
TokenApprovalGen.TokenApprovalAddBlockHash(builder, block_hash)
if owner_address:
TokenApprovalGen.TokenApprovalAddOwnerAddress(builder, owner_address)
if spender_address:
TokenApprovalGen.TokenApprovalAddSpenderAddress(builder, spender_address)
if value:
TokenApprovalGen.TokenApprovalAddValue(builder, value)
final = TokenApprovalGen.TokenApprovalEnd(builder)
return final
def build(self, builder):
market_oid = self.market_oid.bytes if self.market_oid else None
if market_oid:
market_oid = builder.CreateString(market_oid)
member = self.member
if member:
member = builder.CreateString(member)
delegate = self.delegate
if delegate:
delegate = builder.CreateString(delegate)
delegate_type = self.delegate_type
catalog_oid = self.catalog_oid.bytes if self.catalog_oid else None
if catalog_oid:
catalog_oid = builder.CreateString(catalog_oid)
updated = self.updated
if updated:
updated = builder.CreateString(pack_uint256(updated))
service_prefix = self.service_prefix
if service_prefix:
service_prefix = builder.CreateString(service_prefix)
tid = self.tid
if tid:
tid = builder.CreateString(tid)
signature = self.signature
if signature:
signature = builder.CreateString(signature)
ConsentGen.ConsentStart(builder)
if market_oid:
ConsentGen.ConsentAddMarketOid(builder, market_oid)
if member:
ConsentGen.ConsentAddMember(builder, member)
if delegate:
ConsentGen.ConsentAddDelegate(builder, delegate)
if delegate_type:
ConsentGen.ConsentAddDelegateType(builder, delegate_type)
if catalog_oid:
ConsentGen.ConsentAddCatalogOid(builder, catalog_oid)
if self.timestamp:
ConsentGen.ConsentAddTimestamp(builder, int(self.timestamp))
if updated:
ConsentGen.ConsentAddUpdated(builder, updated)
ConsentGen.ConsentAddConsent(builder, self.consent)
ConsentGen.ConsentAddSynced(builder, self.synced or False)
if service_prefix:
ConsentGen.ConsentAddServicePrefix(builder, service_prefix)
if tid:
ConsentGen.ConsentAddTid(builder, tid)
if signature:
ConsentGen.ConsentAddSignature(builder, signature)
final = ConsentGen.ConsentEnd(builder)
return final
def build(self, builder):
address = self.address
if address:
address = builder.CreateString(address)
account_oid = self.account_oid
if account_oid:
account_oid = builder.CreateString(account_oid.bytes)
registered = self.registered
if registered:
registered = builder.CreateString(pack_uint256(registered))
eula = self.eula
if eula:
eula = builder.CreateString(eula)
profile = self.profile
if profile:
profile = builder.CreateString(profile)
tid = self.tid
if tid:
tid = builder.CreateString(tid)
signature = self.signature
if signature:
signature = builder.CreateString(signature)
MemberGen.MemberStart(builder)
if address:
MemberGen.MemberAddAddress(builder, address)
if account_oid:
MemberGen.MemberAddAccountOid(builder, account_oid)
if self.timestamp:
MemberGen.MemberAddTimestamp(builder, int(self.timestamp))
if registered:
MemberGen.MemberAddRegistered(builder, registered)
if eula:
MemberGen.MemberAddEula(builder, eula)
if profile:
MemberGen.MemberAddProfile(builder, profile)
if self.level:
MemberGen.MemberAddLevel(builder, self.level)
if tid:
MemberGen.MemberAddTid(builder, tid)
if signature:
MemberGen.MemberAddSignature(builder, signature)
final = MemberGen.MemberEnd(builder)
return final
def build(self, builder):
market = self.market.bytes if self.market else None
if market:
market = builder.CreateString(market)
actor = self.actor
if actor:
actor = builder.CreateString(actor)
joined = self.joined
if joined:
joined = builder.CreateString(pack_uint256(joined))
security = self.security
if security:
security = builder.CreateString(pack_uint256(security))
meta = self.meta
if meta:
meta = builder.CreateString(meta)
tid = self.tid
if tid:
tid = builder.CreateString(tid)
signature = self.signature
if signature:
signature = builder.CreateString(signature)
ActorGen.ActorStart(builder)
if self.timestamp:
ActorGen.ActorAddTimestamp(builder, int(self.timestamp))
if market:
ActorGen.ActorAddMarket(builder, market)
if actor:
ActorGen.ActorAddActor(builder, actor)
if self.actor_type:
ActorGen.ActorAddActorType(builder, self.actor_type)
if joined:
ActorGen.ActorAddJoined(builder, joined)
if security:
ActorGen.ActorAddSecurity(builder, security)
if meta:
ActorGen.ActorAddMeta(builder, meta)
if tid:
ActorGen.ActorAddTid(builder, tid)
if signature:
ActorGen.ActorAddSignature(builder, signature)
final = ActorGen.ActorEnd(builder)
return final
def build(self, builder):
market = self.market.bytes if self.market else None
if market:
market = builder.CreateString(market)
created = self.created
if created:
created = builder.CreateString(pack_uint256(created))
owner = self.owner
if owner:
owner = builder.CreateString(owner)
coin = self.coin
if coin:
coin = builder.CreateString(coin)
terms = self.terms
if terms:
terms = builder.CreateString(terms)
meta = self.meta
if meta:
meta = builder.CreateString(meta)
maker = self.maker
if maker:
maker = builder.CreateString(maker)
provider_security = self.provider_security
if provider_security:
provider_security = builder.CreateString(
pack_uint256(provider_security))
consumer_security = self.consumer_security
if consumer_security:
consumer_security = builder.CreateString(
pack_uint256(consumer_security))
market_fee = self.market_fee
if market_fee:
market_fee = builder.CreateString(pack_uint256(market_fee))
tid = self.tid
if tid:
tid = builder.CreateString(tid)
signature = self.signature
if signature:
signature = builder.CreateString(signature)
MarketGen.MarketStart(builder)
if market:
MarketGen.MarketAddMarket(builder, market)
if self.timestamp:
MarketGen.MarketAddTimestamp(builder, int(self.timestamp))
if created:
MarketGen.MarketAddProviderSecurity(builder, created)
if self.seq:
MarketGen.MarketAddSeq(builder, self.seq)
if owner:
MarketGen.MarketAddOwner(builder, owner)
if coin:
MarketGen.MarketAddCoin(builder, coin)
if terms:
MarketGen.MarketAddTerms(builder, terms)
if meta:
MarketGen.MarketAddMeta(builder, meta)
if maker:
MarketGen.MarketAddMaker(builder, maker)
if provider_security:
MarketGen.MarketAddProviderSecurity(builder, provider_security)
if consumer_security:
MarketGen.MarketAddConsumerSecurity(builder, consumer_security)
if market_fee:
MarketGen.MarketAddMarketFee(builder, market_fee)
if tid:
MarketGen.MarketAddTid(builder, tid)
if signature:
MarketGen.MarketAddSignature(builder, signature)
final = MarketGen.MarketEnd(builder)
return final
def build(self, builder):
market_oid = self.market_oid
if market_oid:
market_oid = builder.CreateString(market_oid.bytes)
member_oid = self.member_oid
if member_oid:
member_oid = builder.CreateString(member_oid.bytes)
channel_oid = self.channel_oid
if channel_oid:
channel_oid = builder.CreateString(channel_oid.bytes)
open_at = self.open_at
if open_at:
open_at = builder.CreateString(pack_uint256(open_at))
marketmaker = self.marketmaker
if marketmaker:
marketmaker = builder.CreateString(bytes(marketmaker))
actor = self.actor
if actor:
actor = builder.CreateString(bytes(actor))
delegate = self.delegate
if delegate:
delegate = builder.CreateString(bytes(delegate))
recipient = self.recipient
if recipient:
recipient = builder.CreateString(bytes(recipient))
amount = self.amount
if amount:
amount = builder.CreateString(pack_uint256(amount))
closing_at = self.closing_at
if closing_at:
closing_at = builder.CreateString(pack_uint256(closing_at))
closed_at = self.closed_at
if closed_at:
closed_at = builder.CreateString(pack_uint256(closed_at))
close_mm_sig = self.close_mm_sig
if close_mm_sig:
close_mm_sig = builder.CreateString(bytes(close_mm_sig))
close_del_sig = self.close_del_sig
if close_del_sig:
close_del_sig = builder.CreateString(bytes(close_del_sig))
close_balance = self.close_balance
if close_balance:
close_balance = builder.CreateString(pack_uint256(close_balance))
closed_tx = self.closed_tx
if closed_tx:
closed_tx = builder.CreateString(bytes(closed_tx))
ChannelGen.ChannelStart(builder)
if market_oid:
ChannelGen.ChannelAddMarketOid(builder, market_oid)
if member_oid:
ChannelGen.ChannelAddMemberOid(builder, member_oid)
if channel_oid:
ChannelGen.ChannelAddChannelOid(builder, channel_oid)
if self.timestamp:
ChannelGen.ChannelAddTimestamp(builder, int(self.timestamp))
if open_at:
ChannelGen.ChannelAddOpenAt(builder, open_at)
if self.seq:
ChannelGen.ChannelAddSeq(builder, self.seq)
if self.channel_type:
ChannelGen.ChannelAddChannelType(builder, self.channel_type)
if marketmaker:
ChannelGen.ChannelAddMarketmaker(builder, marketmaker)
if actor:
ChannelGen.ChannelAddActor(builder, actor)
if delegate:
ChannelGen.ChannelAddDelegate(builder, delegate)
if recipient:
ChannelGen.ChannelAddRecipient(builder, recipient)
if amount:
ChannelGen.ChannelAddAmount(builder, amount)
ChannelGen.ChannelAddTimeout(builder, self.timeout)
if self.state:
ChannelGen.ChannelAddState(builder, int(self.state))
if closing_at:
ChannelGen.ChannelAddClosingAt(builder, closing_at)
if closed_at:
ChannelGen.ChannelAddClosedAt(builder, closed_at)
if close_mm_sig:
ChannelGen.ChannelAddCloseMmSig(builder, close_mm_sig)
if close_del_sig:
ChannelGen.ChannelAddCloseDelSig(builder, close_del_sig)
if self.close_channel_seq:
ChannelGen.ChannelAddCloseChannelSeq(builder, self.close_channel_seq)
if close_balance:
ChannelGen.ChannelAddCloseBalance(builder, close_balance)
if self.close_is_final:
ChannelGen.ChannelAddCloseIsFinal(builder, self.close_is_final)
if closed_tx:
ChannelGen.ChannelAddClosedTx(builder, closed_tx)
final = ChannelGen.ChannelEnd(builder)
return final
def build(self, builder):
offer = self.offer.bytes if self.offer else None
if offer:
offer = builder.CreateString(offer)
seller = self.seller
if seller:
seller = builder.CreateString(seller)
seller_authid = self.seller_authid
if seller_authid:
seller_authid = builder.CreateString(seller_authid)
key = self.key.bytes if self.key else None
if key:
key = builder.CreateString(key)
api = self.api.bytes if self.api else None
if api:
api = builder.CreateString(api)
uri = self.uri
if uri:
uri = builder.CreateString(uri)
signature = self.signature
if signature:
signature = builder.CreateString(signature)
price = self.price
if price:
price = builder.CreateString(pack_uint256(price))
categories_keys_vec = None
categories_values_vec = None
if self._categories:
categories_keys = []
categories_values = []
for _key, _value in sorted(self._categories.items()):
assert type(
_key
) == str, 'category key must be string, but was {}: {}'.format(
type(_key), _key)
assert type(
_value
) == str, 'category value must be string, but was {}: {}'.format(
type(_value), _value)
categories_keys.append(builder.CreateString(_key))
categories_values.append(builder.CreateString(_value))
OfferGen.OfferStartCategoriesKeyVector(builder,
len(categories_keys))
for _key in categories_keys:
builder.PrependUOffsetTRelative(_key)
categories_keys_vec = builder.EndVector(len(categories_keys))
OfferGen.OfferStartCategoriesValueVector(builder,
len(categories_values))
for _value in categories_values:
builder.PrependUOffsetTRelative(_value)
categories_values_vec = builder.EndVector(len(categories_values))
OfferGen.OfferStart(builder)
if self.timestamp:
OfferGen.OfferAddTimestamp(builder, int(self.timestamp))
if offer:
OfferGen.OfferAddOffer(builder, offer)
if seller:
OfferGen.OfferAddSeller(builder, seller)
if self.seller_session_id:
OfferGen.OfferAddSellerSessionId(builder, self.seller_session_id)
if seller_authid:
OfferGen.OfferAddSellerAuthid(builder, seller_authid)
if key:
OfferGen.OfferAddKey(builder, key)
if api:
OfferGen.OfferAddApi(builder, api)
if uri:
OfferGen.OfferAddUri(builder, uri)
if self.valid_from:
OfferGen.OfferAddValidFrom(builder, int(self.valid_from))
if signature:
OfferGen.OfferAddSignature(builder, signature)
if price:
OfferGen.OfferAddPrice(builder, price)
if categories_keys_vec:
OfferGen.OfferAddCategoriesKey(builder, categories_keys_vec)
if categories_values_vec:
OfferGen.OfferAddCategoriesValue(builder, categories_values_vec)
if self.expires:
OfferGen.OfferAddExpires(builder, int(self.expires))
if self.copies:
OfferGen.OfferAddCopies(builder, self.copies)
if self.remaining:
OfferGen.OfferAddRemaining(builder, self.remaining)
final = OfferGen.OfferEnd(builder)
return final
def build(self, builder):
tid = self.tid.bytes if self.tid else None
if tid:
tid = builder.CreateString(tid)
offer = self.offer.bytes if self.offer else None
if offer:
offer = builder.CreateString(offer)
amount = self.amount
if amount:
amount = builder.CreateString(pack_uint256(amount))
payment_channel = self.payment_channel
if payment_channel:
payment_channel = builder.CreateString(payment_channel)
paying_channel = self.paying_channel
if paying_channel:
paying_channel = builder.CreateString(paying_channel)
key = self.key
if key:
key = builder.CreateString(key.bytes)
buyer_pubkey = self.buyer_pubkey
if buyer_pubkey:
buyer_pubkey = builder.CreateString(buyer_pubkey)
payment_channel_after = self.payment_channel_after
if payment_channel_after:
payment_channel_after = builder.CreateString(pack_uint256(payment_channel_after))
paying_channel_after = self.paying_channel_after
if paying_channel_after:
paying_channel_after = builder.CreateString(pack_uint256(paying_channel_after))
payment_mm_sig = self.payment_mm_sig
if payment_mm_sig:
payment_mm_sig = builder.CreateString(payment_mm_sig)
payment_del_sig = self.payment_del_sig
if payment_del_sig:
payment_del_sig = builder.CreateString(payment_del_sig)
paying_mm_sig = self.paying_mm_sig
if paying_mm_sig:
paying_mm_sig = builder.CreateString(paying_mm_sig)
paying_del_sig = self.paying_del_sig
if paying_del_sig:
paying_del_sig = builder.CreateString(paying_del_sig)
TransactionGen.TransactionStart(builder)
if tid:
TransactionGen.TransactionAddTid(builder, tid)
if self.created:
TransactionGen.TransactionAddCreated(builder, int(self.created))
if self.created_payment_channel_seq:
TransactionGen.TransactionAddCreatedPaymentChannelSeq(builder, self.created_payment_channel_seq)
if self.created_paying_channel_seq:
TransactionGen.TransactionAddCreatedPayingChannelSeq(builder, self.created_paying_channel_seq)
if offer:
TransactionGen.TransactionAddOffer(builder, offer)
if amount:
TransactionGen.TransactionAddAmount(builder, amount)
if payment_channel:
TransactionGen.TransactionAddPaymentChannel(builder, payment_channel)
if paying_channel:
TransactionGen.TransactionAddPayingChannel(builder, paying_channel)
if self.state:
TransactionGen.TransactionAddState(builder, int(self.state))
if self.completed:
TransactionGen.TransactionAddCompleted(builder, int(self.completed))
if self.completed_payment_channel_seq:
TransactionGen.TransactionAddCompletedPaymentChannelSeq(builder,
self.completed_payment_channel_seq)
if self.completed_paying_channel_seq:
TransactionGen.TransactionAddCompletedPayingChannelSeq(builder, self.completed_paying_channel_seq)
if key:
TransactionGen.TransactionAddKey(builder, key)
if buyer_pubkey:
TransactionGen.TransactionAddBuyerPubkey(builder, buyer_pubkey)
if payment_channel_after:
TransactionGen.TransactionAddPaymentChannelAfter(builder, payment_channel_after)
if paying_channel_after:
TransactionGen.TransactionAddPayingChannelAfter(builder, paying_channel_after)
if payment_mm_sig:
TransactionGen.TransactionAddPaymentMmSig(builder, payment_mm_sig)
if payment_del_sig:
TransactionGen.TransactionAddPaymentDelSig(builder, payment_del_sig)
if paying_mm_sig:
TransactionGen.TransactionAddPayingMmSig(builder, paying_mm_sig)
if paying_del_sig:
TransactionGen.TransactionAddPayingDelSig(builder, paying_del_sig)
final = TransactionGen.TransactionEnd(builder)
return final
